Confira também as instruções para o trabalho e o programa apresentado abaixo!

#include<stdio.h>
#include<stdlib.h>

typedef int *vetor;
typedef vetor *matriz;

matriz alocarMatriz(int ordem)
{
    matriz M;
    M=(vetor*) malloc(ordem*sizeof(vetor));
    for(int i=0; i<ordem; i++)
    {
        M[i]=(int*)malloc(ordem*sizeof(int));
    }
    return M;
}

void escreverMatriz(matriz M, int ordem, FILE *saida)
{
    for(int i=0; i<ordem; i++)
    {
        for(int j=0; j<ordem; j++)
        {
            if(j==ordem-1)
                fprintf(saida, "%d", M[i][j]);
            else
                fprintf(saida, "%d ", M[i][j]);
        }
        fprintf(saida, "\n");
    }
    fprintf(saida, "\n");
}

void lerMatriz(matriz M, int ordem, FILE *entrada)
{
    for(int i=0; i<ordem; i++)
    {
        for(int j=0; j<ordem; j++)
        {
            fscanf(entrada, "%d", &M[i][j]);
        }
    }
}

void desalocarMatriz(matriz M, int ordem)
{
    for(int i=0; i<ordem; i++)
    {
        free(M[i]);
    }
    free(M);
}



void aux2Maior(matriz M, int ordem, int *maior, int linha, int coluna)
{
    if(coluna<ordem)
    {
        if(*maior<M[linha][coluna])
            *maior=M[linha][coluna];
        aux2Maior(M, ordem, maior, linha, coluna+1);
    }
    else
        return;
}

void aux1Maior(matriz M, int ordem, int *maior, int linha)
{
    if(linha<ordem)
    {
        aux2Maior(M, ordem, maior, linha, 0);
        aux1Maior(M, ordem, maior, linha+1);
    }
    else
        return;
}

int retornarMaiorElemento(matriz M, int ordem)
{
    int maior;
    maior=M[0][0];
    aux1Maior(M, ordem, &maior, 0);
    return maior;
}


void transpor(matriz M, matriz transposta, int linha, int ordem)
{
    ordem--;
    if(ordem<0)
        return;
    else
    {
        transposta[ordem][linha]=M[linha][ordem];
        transposta[linha][ordem]=M[ordem][linha];
        transpor(M, transposta, linha, ordem);
    }
}

void auxTranspor(matriz M, matriz transposta, int linha, int ordem)
{
    if(linha<0)
        return;
    else
    {
        transpor(M, transposta, linha, ordem);
        auxTranspor(M, transposta, linha-1, ordem);
    }
}



matriz criarTransposta(matriz M, int ordem)
{
    matriz transposta;
    int linha;

    linha=ordem-1;
    transposta=alocarMatriz(ordem);
    auxTranspor(M, transposta, linha, ordem);
    return transposta;
}

void aux4(matriz produto, matriz M, matriz N, int ordem, int linha, int coluna, int k)
{
    if(k==0)
        produto[linha][coluna]=M[linha][k]*N[k][coluna];
    else
        produto[linha][coluna]+=M[linha][k]*N[k][coluna];
}
void aux3(matriz produto, matriz M, matriz N, int ordem, int linha, int coluna, int contador)
{
    if(contador<ordem)
    {
        aux4(produto, M, N, ordem, linha, coluna, contador);
        aux3(produto, M, N, ordem, linha, coluna, contador+1);
    }
    else
        return;
}

void aux2(matriz produto, matriz M, matriz N, int ordem, int linha, int contador)
{
    if(contador<ordem)
    {
        aux3(produto, M, N, ordem, linha, contador, 0);
        aux2(produto, M, N, ordem, linha, contador+1);
    }
    else
        return;
}

void aux1(matriz produto, matriz M, matriz N, int ordem, int contador)
{
    if(contador<ordem)
    {
        aux2(produto, M, N, ordem, contador, 0);
        aux1(produto, M, N, ordem, contador+1);
    }
    else
        return;
}

matriz calcularProduto(matriz M, matriz N, int ordem)
{
    matriz produto;
    produto=alocarMatriz(ordem);
    aux1(produto, M, N, ordem, 0);
    return produto;
}



matriz menorComplementar(matriz M, int n, int i)
{
    matriz A;
    A=alocarMatriz(n-1);

    for(int j=0; j<n-1; j++)
    {
        for(int k=0; k<n-1; k++)
        {
            if(k<i)
                A[j][k]=M[j+1][k];
            else
                A[j][k]=M[j+1][k+1];
        }
    }
    return A;
}



int calcularDeterminante(matriz M, int n)
{
    int det=0;
    if(n==1)
    {
        det=M[0][0];
    }
    else
    {
        for(int i=0; i<n; i++)
        {
            matriz A;
            A=menorComplementar(M, n, i);
            if(i%2==0)
                det+=M[0][i]*calcularDeterminante(A, n-1);
            else
                det-=M[0][i]*calcularDeterminante(A, n-1);
        }
    }
    return det;
}


int main()
{
    int vezes, operacao, ordem;
    FILE *entrada, *saida;
    matriz M;

    entrada=fopen("entrada.txt", "r");
    saida=fopen("saida.txt", "w");

    fscanf(entrada, "%d", &vezes);

    while(vezes>0)
    {
        fscanf(entrada, "%d %d", &operacao, &ordem);
        M=alocarMatriz(ordem);
        lerMatriz(M, ordem, entrada);

        switch(operacao)
        {
        case 1:
            int maior_elemento;
            maior_elemento=retornarMaiorElemento(M, ordem);
            fprintf(saida, "%d\n\n", maior_elemento);
            break;
        case 2:
            matriz transposta;
            transposta=criarTransposta(M, ordem);
            escreverMatriz(transposta, ordem, saida);
            desalocarMatriz(transposta, ordem);
            break;
        case 3:
            matriz produto, N;
            N=alocarMatriz(ordem);
            lerMatriz(N, ordem, entrada);
            produto=calcularProduto(M, N, ordem);
            escreverMatriz(produto, ordem, saida);
            desalocarMatriz(produto, ordem);
            desalocarMatriz(N, ordem);
            break;
        case 4:
            int det;
            det=calcularDeterminante(M, ordem);
            fprintf(saida, "%d\n\n", det);
            break;
        }
        desalocarMatriz(M, ordem);
        vezes--;
    }

    fclose(entrada);
    fclose(saida);

    return 0;
}