Ceros por debajo-Fila0 constante- Bonito XD

#include <stdio.h>
#include <conio.h>
#include <math.h>

/*********** VARIABLES GLOBALES **********************/
int N = 5; //N contiene el tama¤o de la matriz cuadrada
double matriz[5][5];
double identidad[5][5];

/*********** PROTOTIPOS DE FUNCIONES *****************/

void hallar_matriz(void);
void escalonar_matriz(void);
void permutar_filas(int fila1, int fila2);
void multip_fila(int fila,double factor);
void sumar_fila_multip(int fila1,int fila2, double factor);
void ceros_abajo(int fila_pivote, int columna_pivote);
/*****************************************************/


int main()
{
srand (time(NULL));
int fi, co;

for(fi=0;fi<N;fi++)
{
for(co=0;co<N;co++)
{

int numero= rand()%99; //numeros entre 0 y 99
matriz[fi][co] = numero;
printf("%d ", numero);
}
printf("\n");
}
printf("Calculando la matriz .... \n");
hallar_matriz();

return 0;
}

/*-------------------------------------------------------------------------*/

void hallar_matriz(void)
{
int cont,cont2, flag=0;

escalonar_matriz();


for(cont=1;cont<N;cont++) //recorre filas, como queremos que la primera fila no se cambie empezamos en la 1
{
for(cont2=1;cont2<N;cont2++) //recorre columnas, como queremos que la primera columna no se cambie empezamos en la 1
{
if(matriz[cont][cont2]!=0) //busca pivote (elemento ditinto de 0)
{
if(matriz[cont][cont2]!=1) //si pivote no es 1, se lo multiplica
{
multip_fila(cont,pow(matriz[cont][cont2],-1));
}

ceros_abajo(cont,cont2); // 0's por debajo del pivote

break;
}
}
}

for(cont=0;cont<N;cont++)
{printf("|");
for(cont2=0;cont2<N;cont2++)
{

printf("%7.3g ",matriz[cont][cont2]); //forzar a 7 caracteres, precision 3 decimales y usar el minimo de caracteres
}
printf("|\n");
}


printf("\n Presione una tecla para continuar...");
getch();


}

/*-----------------------------------------------------------------------*/
/* */
/* Ordena la matriz de forma que quede en su forma escalonada por */
/* renglones */
/* */
/*-----------------------------------------------------------------------*/

void escalonar_matriz(void)
{
int cont, col, ceros, vec[10];
int flag, aux;

for(cont=0;cont<N;cont++)
{
col=0,ceros=0;

if(matriz[cont][col]==0)
{
do{
ceros++;
col++;
}while(matriz[cont][col]==0);
}
vec[cont]=ceros;
}


do
{
flag=0;
for(cont=0;cont<N-1;cont++)
{
if(vec[cont]>vec[cont+1])
{
aux=vec[cont];
vec[cont]=vec[cont+1];
vec[cont+1]=aux;

permutar_filas(cont,cont+1);

flag=1;
}
}
}while(flag==1);

}

/*----------------------------------------------------------------------*/
/* SE DEFINEN LAS 3 OPERACIONES ELEMENTALES DE FILA */
/* */
/* Las operaciones que se le realizen a la matriz para reducirla */
/* tambien deberan realizarsele a la matriz identidad para obtener */
/* la matriz inversa */
/*----------------------------------------------------------------------*/


void permutar_filas(int fila1,int fila2)
{
float auxval;
int cont;

for(cont=0;cont<N;cont++)
{
auxval=matriz[fila1][cont];
matriz[fila1][cont]=matriz[fila2][cont];
matriz[fila2][cont]=auxval;

auxval=identidad[fila1][cont];
identidad[fila1][cont]=identidad[fila2][cont];
identidad[fila2][cont]=auxval;
}
}

/*----------------------------------------------------------------------*/

void multip_fila(int fila,double factor)
{
int cont;

for(cont=0;cont<N;cont++)
{
matriz[fila][cont]=(matriz[fila][cont])*factor;
identidad[fila][cont]=(identidad[fila][cont])*factor;
}
}

/*----------------------------------------------------------------------*/

void sumar_fila_multip(int fila1,int fila2, double factor)
{
int cont;
for(cont=0;cont<N;cont++)
{
matriz[fila1][cont]=(matriz[fila1][cont])+((matriz[fila2][cont])*factor);
identidad[fila1][cont]=(identidad[fila1][cont])+((identidad[fila2][cont])*factor);
}
}

/*-------------------------------------------------------------------------*/
void ceros_abajo(int fila_pivote, int columna_pivote)
{
int cont;

for(cont=columna_pivote+1;cont<N;cont++)
{
sumar_fila_multip(cont,fila_pivote,((matriz[cont][columna_pivote])*(-1)));
}

}