Mais um Lab de CES-11! Esta abaixo o código utilizado:

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

#define infinito 9999

typedef struct caminho caminho;
typedef struct node node;
typedef struct digrafo digrafo;
typedef struct dijkstra dijkstra;

struct dijkstra{
int distancia;
int ordem;
bool check;
};

struct caminho{
int vertice;
int minutos;
caminho *prox;
};

struct node{
char aeroporto[30];
caminho *rota;
};

struct digrafo{
int total;
node vertices[100];//utilizaremos do indice 1 ao m(e nao do 0 ao n-1)
};

void rota_minima(int origem, int chegada, digrafo g, FILE *saida){
int revistados = 0, atual = origem, anterior = origem, proximo;
dijkstra lista[100];
bool conexao = true;
for(int i = 1; i < 100; i++){
lista[i].ordem = lista[i].distancia = infinito;
lista[i].check = false;
}
lista[origem].distancia = 0;
while(revistados < g.total && anterior != atual){
lista[atual].check = true;
caminho *fim;
for(fim = g.vertices[atual].rota, proximo = fim->vertice; fim != NULL; fim = fim->prox){
if(lista[fim->vertice].distancia > lista[atual].distancia + fim->minutos){
lista[fim->vertice].distancia = lista[atual].distancia + fim->minutos;
lista[fim->vertice].ordem = atual;
if(lista[proximo].distancia > lista[fim->vertice].distancia && lista[proximo].check == false)
proximo = fim->vertice;
}
}
anterior = atual;
if(lista[proximo].check == false)
atual = proximo;
revistados++;
}
int resposta[100];
int i;
for(int atual = chegada, i = 0; atual != origem; i++){
if(lista[atual].ordem != infinito){
atual = lista[atual].ordem;
resposta[i] = atual;
}
else{
//printf("Nao existe caminho\n");
conexao = false;
}
}
if(conexao == true){
//fprintf(saida, "%d a %d: %d", origem, chegada, chegada);
for(; i >= 0; i--){
//fprintf(saida, "-%d", resposta[i]);
}
//fprintf(saida, "\n");
}
}

int main(){
digrafo g;///nome do digrafo
FILE *entrada = fopen("entrada.txt", "r");
FILE *saida = fopen("saida.txt", "w");

fscanf(entrada, "%d\n", &g.total);

for(int i = 1; i <= g.total; i++){
//g.vertices[i] = (node*)malloc(sizeof(node));
g.vertices[i].rota = NULL;
fgets(g.vertices[i].aeroporto, 31, entrada);
}//lidos os nomes

int aux;
fscanf(entrada, "%d", &aux);

for(int i = 0; i < aux; i++){
int origem, chegada, tempo;
caminho *fim = g.vertices[origem].rota;
fscanf(entrada, "%d %d %d", &origem, &chegada, &tempo);
if(fim == NULL){
g.vertices[origem].rota = (caminho*)malloc(sizeof(caminho));
g.vertices[origem].rota->minutos = tempo;
g.vertices[origem].rota->vertice = chegada;
g.vertices[origem].rota->prox = NULL;
}
else{
for(; fim->prox != NULL; fim = fim->prox){
}
fim->prox = (caminho*)malloc(sizeof(caminho));
fim->prox->minutos = tempo;
fim->prox->vertice = chegada;
fim->prox->prox = NULL;
}
}//lidas as linhas de voo e alocada a lista de adjacenscias
//falta ordenar a lista

//fprintf(saida, "Digrafo:\n");
for(int i = 1; i <= g.total; i++){
//fprintf(saida, "%d (%s):", (i-1), g.vertices[i]->aeroporto);
caminho *fim = g.vertices[i].rota;
while(fim != NULL){
//fprintf(saida, " %d(%d)", fim->vertice, fim->minutos);
fim = fim->prox;
}
//fprintf(saida, "\n");
}
//fprintf(saida, "\n");//imprimiu o digrafo

fscanf(entrada, "%d", &aux);
//fprintf(saida, "Rotas minimas:\n");
for(int i = 0; i < aux; i++){
int origem, chegada;
fscanf(entrada, "%d %d", &origem, &chegada);
rota_minima(origem, chegada, g, saida);
}//lido todo o documento de entrada
//fprintf(saida, "\n");//imprimiu as rotas minimas

fclose(entrada);
fclose(saida);
return 0;
}

0

E aí, pessoal! Tudo bem?

Mais um lab de CES-11! espero que aproveitem!

Código:
#include<stdio.h>
#include<stdlib.h>

typedef struct node node;
typedef struct lista lista;
typedef struct arvore arvore;

/*************************************
struct dos nos pra criar as listas ligadas
*************************************/
struct node{
    int valor;
    node *prox;
};

/*************************************
struct das listas maximais crescente
*************************************/
struct lista{
    int tamanho;
    node *first;
};

/*************************************
Funcao sift
*************************************/
void sift(lista heap[], int n, int i){
    int esq = 2*i;
    int dir = 2*i + 1;
    int menor = i;
    if(esq <= n && heap[esq].tamanho < heap[i].tamanho)
       menor = esq;
    if(dir <= n && heap[dir].tamanho < heap[menor].tamanho)
        menor = dir;
    if(menor != i){
        lista aux = heap[i];
        heap[i] = heap[menor];
        heap[menor] = aux;
        sift(heap, n, menor);
    }
}

/*************************************
funcao build para transformar um vetor em heap
*************************************/
void build(lista heap[], int n){
        for(int i = n/2; i > 0; i--)
            sift(heap, n, i);
}

int main(){
    lista heap[400];
    FILE *entrada, *saida;
    node *aux;
    lista maximal;
    int atual, anterior, n; ///n eh o tamanho do heap
    int tempo = 0;
//Inicia-se a leitura do documento (primeiro elemento)
    maximal.tamanho = 1;
    n = 0;
    entrada = fopen("entrada.txt", "r");
    saida = fopen("saida", "w");
    maximal.first = (node*)malloc(sizeof(node));
    aux = maximal.first;
    aux->prox = NULL;
    fscanf(entrada, "%d", &anterior);
    aux->valor = anterior;

//Continua a leitura ate o final
    while(fscanf(entrada, "%d", &atual) > 0){
        if(atual >= anterior){
            aux->prox = (node*)malloc(sizeof(node));
            aux = aux->prox;
            aux->prox = NULL;
            maximal.tamanho ++;
            aux->valor = atual;
        }
        else{
            n ++;
            heap[n] = maximal;
            maximal.first = (node*)malloc(sizeof(node));
            maximal.tamanho = 1;
            aux = maximal.first;
            aux->valor = atual;
            aux->prox = NULL;
        }
        anterior = atual;
    }
    n ++;
    heap[n] = maximal;

///transforma o vetor heap[] em um heap de minimo
    build(heap, n);

    while(n > 1){
     
///junçao de listas
    node *v1, *v2;
    v1 = heap[1].first;

    if(n < 3 || heap[2].tamanho <= heap[3].tamanho)
        v2 = heap[2].first;
    else
        v2 = heap[3].first;

    if(v2->valor < v1->valor){
        heap[1].first = v2;
        v2 = v2->prox;
        heap[1].first->prox = v1;
        v1 = heap[1].first;
    }
    while(v1->prox != NULL && v2 != NULL){
        if(v1->prox->valor <= v2->valor)
            v1 = v1->prox;
        else{
            aux = v1->prox;
            v1->prox = v2;
            v2 = v2->prox;
            v1 = v1->prox;
            v1->prox = aux;
        }
    }
    if(v2 != NULL)
        v1->prox = v2;

        if(n < 3 || heap[2].tamanho <= heap[3].tamanho)
            heap[1].tamanho += heap[2].tamanho;
        else
            heap[1].tamanho += heap[3].tamanho;
        //fim da juncao de duas listas
        tempo += heap[1].tamanho;
     

        if(n < 3 || heap[2].tamanho <= heap[3].tamanho)
            heap[2] = heap[3];
        n--;//diminui o tamanho do heap[]
        for(int i = 4; i <= n; i++)
            heap[i-1] = heap[i];
        sift(heap, n, 1);//reaordenar o array
    }

    aux = heap[1].first;
    while(aux != NULL){
        fprintf(saida, "%d\n", aux->valor);
        aux = aux->prox;
    }
    fprintf(saida, "%d\n", tempo);

    fclose(entrada);
    fclose(saida);

    return 0;
}

0

E aí, galera! Mais um programa aqui, desta vez um contador de palavras. Espero que se aproveitem. Obrigado.

Obs.: o código segue abaixo:

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

typedef struct node node;

typedef node *arvore;

typedef node *posicao;

struct node{

    char letra;

    int cont;

    node *filhos[26];

};

/***********************************

funcao que transforma letras maiusculas em minusculas 

***********************************/

char minuscula(char c){

    if(c >= 'A' && c <= 'Z')

        c = c - 'A' + 'a';

    return c;

}

/***********************************

funcao que retorna o numero associado a  uma dada letra

exemplo: a = 0, b = 1, c = 2, ... 

***********************************/

int numero(char c){

    return (c - 'a');

} 

/***********************************

funcao que percorre a arvore em pre-ordem 

***********************************/

void ordem(arvore tree, char palavra[1000], arvore princ, FILE *saida){

    node *c;

    int tamanho;

    tamanho = strlen(palavra);

    if(tree->letra != 'D'){

            palavra[tamanho] = tree->letra;

            palavra[tamanho+1] = '\0';

    }

    if(tree->cont > 0 && palavra[0] != 'D')

        fprintf(saida, "%d %s\n", tree->cont, palavra);

    c = tree->filhos[0];

    for(int i = 1; i < 26; i++){

        if(c != NULL)

            ordem(c, palavra, princ, saida);

        c = tree->filhos[i];

        palavra[tamanho+1] = '\0';

        if(tree == princ)

            palavra[0] = '\0';

    }

}

/***********************************

funcao principal 

***********************************/

int main(){

    arvore principal, aux;

    FILE *entrada, *saida;

    char carac;

    int posic;

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

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

    principal = (arvore)malloc(sizeof(node));

    for(int i = 0; i < 26; i++)

        principal->filhos[i] = NULL;

    principal->letra = 'D';

    principal->cont = 0;

    aux = principal;

//vamos ler o arquivo ate chegar no final

    while((fscanf(entrada, "%c", &carac)) > 0){

        if((carac >= 'a' && carac <= 'z') || (carac >= 'A' && carac <= 'Z')){    //sabe se eh letra ou nao

            carac = minuscula(carac);

            posic = numero(carac);

            if(aux->filhos[posic] == NULL){

                aux->filhos[posic] = (arvore)malloc(sizeof(node));  //aloca espaco para "novas" letras

                aux->filhos[posic]->letra = carac;

                aux->filhos[posic]->cont = 0;

                for(int i = 0; i < 26; i++)

                    aux->filhos[posic]->filhos[i] = NULL;

            }

            aux = aux->filhos[posic];

        }

        else{

            if(aux != principal)

                aux->cont++;

            aux=principal;

        }

    }

    char palavra[1000];

    strcpy(palavra, "\0");

    ordem(principal, palavra, principal, saida);    //funcao q le e imprime a arvore

    fclose(entrada);

    fclose(saida);

    return 0;

}

0

E aí, galera! Aqui vai um post sobre árvores. Neste problema da nossa P1 era preciso implementar um solução que calculasse o valor de uma expressão aritmética utilizando árvore. Segue o código abaixo!


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

#define max 100

typedef struct celula celula;
typedef celula *node;
typedef struct pilha pilha;

struct pilha{
    char caracter[max];
    int t;
};

struct celula{
    char info;
    celula *filhos[max];
};


/**********************************************************************************************************
funcao que aloca a expressao na arvore
**********************************************************************************************************/
node alocar(char expressao[], node *arvore){
    *arvore=(node)malloc(sizeof(celula));
    int aberto=0;
    char dir[max], esq[max];
    bool achou=false;
    for(int i=0; expressao[i]!='\0'; i++){
        if(expressao[i]=='(') aberto++;
        else if(expressao[i]==')') aberto--;
        if(aberto==1 && (expressao[i]=='*' || expressao[i]=='+' || expressao[i]=='-' || expressao[i]=='/')){
            (*arvore)->info=expressao[i];
            (*arvore)->filhos[0]=(*arvore)->filhos[1]=NULL;
            for(int j=1; j<i; j++){
                esq[j-1]=expressao[j];
            }
            esq[i-1]='\0';
            for(int j=i+1; j<(strlen(expressao)); j++){
                dir[j-i-1]=expressao[j];
                dir[j-i]='\0';
            }
            //dir[j]='\0';
            alocar(esq, &(*arvore)->filhos[0]);
            alocar(dir, &(*arvore)->filhos[1]);
            achou=true;
        }
    }
    if(achou==false){
        for(int i=0; expressao[i]!='\0'; i++){
            if(expressao[i]!='(' && expressao[i]!=')')
                (*arvore)->info=expressao[i];
        }
    }
}



/**********************************************************************************************************
funcao que calcula o valor da expressao armazenada na arvore
**********************************************************************************************************/
int calcular(node arvore){
    if(arvore->info>='0' && arvore->info<='9')
        return ((arvore->info)-'0');
    else if(arvore->info=='*' || arvore->info=='+' || arvore->info=='-' || arvore->info=='/'){
        switch(arvore->info){
            case '*': return (calcular(arvore->filhos[0]))*(calcular(arvore->filhos[1]));
            case '-': return (calcular(arvore->filhos[0]))-(calcular(arvore->filhos[1]));
            case '/': return (calcular(arvore->filhos[0]))/(calcular(arvore->filhos[1]));
            case '+': return (calcular(arvore->filhos[0]))+(calcular(arvore->filhos[1]));
        }
    }
    else{
        printf("expressao invalida");
        return 0;
    }
}


int main(){
    int parenteses=0, resultado;
    pilha P;
    char expressao[max];
    node arvore;

    P.t=-1;
    scanf("%[^\n]s", expressao);
    for(int i=0; i<strlen(expressao); i++){
        if(expressao[i]=='('){
            P.t++;
            P.caracter[P.t]='(';
           }
        else if(expressao[i]==')'){
            if(P.t==-1){
                printf("expressao invalida");
                return 0;
            }
            else P.t--;
        }
        else if((expressao[i]<'0' || expressao[i]>'9') && expressao[i]!='+' && expressao[i]!='-' && expressao[i]!='*' && expressao[i]!='/'){
            printf("expressao invalida");
            return 0;
        }
    }
    if(P.t!=-1){
        printf("expressao invalida");
        return 0;
    }
    alocar(expressao, &arvore);
    resultado=calcular(arvore);
    printf("resultado = %d\n", resultado);

    return 0;
}

0

Olá, pessoal!

No nosso segundo lab de CES-11 tivesmos que implementar um dicionário utilizando hash table (tabela de dispersão). O programa está logo abaixo!

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

typedef struct palavra palavra;
typedef struct significado significado;
typedef palavra *vetor;

/***********************************************************************
estrutura de um significado de uma dada expressão
***********************************************************************/
struct significado{
    char definicao[50];
    significado *proximo;
};

/***********************************************************************
estrutura de uma expressao
***********************************************************************/
struct palavra{
    char expressao[50];
    significado *significados;
    palavra *prox;
};


///Funções:
/***********************************************************************
funcao que calcula a posicao de uma expressao no dicionario
***********************************************************************/

int dispersao(char exp[], int N){
    int soma=0;
    for(int i=0; exp[i]!='\0'; i++)
        soma+=exp[i];
    soma=soma%N;
    return soma;
}

/***********************************************************************
funcao que INSERE uma nova palavra com um novo significado na tabela
de dispersao
***********************************************************************/
void inserir(char exp[], char def[], vetor *dicionario, int n){
    int posicao;
    posicao=dispersao(exp, n);
    palavra *auxiliar, *copia;
    significado *aux, *cola;

    int palavra_igual=0;
    int significado_igual=0;
    for(auxiliar=dicionario[posicao]; auxiliar!=NULL; auxiliar=dicionario[posicao]->prox){
        if(strcmp(auxiliar->expressao, exp)==0){
            palavra_igual=1;
            for(aux=auxiliar->significados; aux!=NULL; aux=aux->proximo){
                if(strcmp(aux->definicao, def)==0){
                    significado_igual=1;
                }
            }
            if(significado_igual==0){
                    cola=auxiliar->significados;
                    aux=(significado*)malloc(sizeof(significado));
                    auxiliar->significados=aux;
                    aux->proximo=cola;
                    strcpy(aux->definicao, def);
            }
        }
    }
    if(palavra_igual==0){
        copia=dicionario[posicao];
        auxiliar=(palavra*)malloc(sizeof(palavra));
        dicionario[posicao]=auxiliar;
        dicionario[posicao]->significados=(significado*)malloc(sizeof(significado));
        auxiliar->prox=copia;
        strcpy(dicionario[posicao]->significados->definicao, def);
        strcpy(dicionario[posicao]->expressao, exp);
        dicionario[posicao]->significados->proximo=NULL;
    }
}


/***********************************************************************
funcao que CARREGA A BASE DE DADOS inicial do dicionario
***********************************************************************/
void baseDeDados(vetor *dicionario, int n, FILE *inicio){
    char linha[100], *pch, exp[50], total[100], def[50];

    while(fscanf(inicio, "%s",total)!=EOF){
        fgets(linha, 101, inicio);
        strcat(total, linha);
        total[strlen(total)-1]='\0';
        strcpy(linha, total);
        pch=strtok(total, "|");
        strcpy(exp, pch);
        pch=strtok(NULL, "|");
        strcpy(def, pch);
        inserir(exp, def, dicionario, n);
    }
}

/***********************************************************************
funcao que CONSULTA uma expressao no dicionario
***********************************************************************/
void consultar(FILE *saida, char exp[], int n, vetor *dicionario){
    int posicao;
    palavra *auxiliar;
    significado *aux;

    posicao=dispersao(exp, n);

    int encontrada=0;
    for(auxiliar=dicionario[posicao]; auxiliar!=NULL; auxiliar=auxiliar->prox){
        if(strcmp(auxiliar->expressao, exp)==0){
            encontrada=1;
            for(aux=dicionario[posicao]->significados; aux!=NULL; aux=aux->proximo){
                fprintf(saida, "%s\n", aux->definicao);
            }
            fprintf(saida, "\n");
        }
    }
    if(encontrada==0){
        fprintf(saida, "nada consta\n\n");
    }
}


/***********************************************************************
funcao que ELIMINA um significado do dicionario
***********************************************************************/
void eliminar_significado(vetor *dicionario, int n, char exp[], char def[]){
    int posicao;
    posicao=dispersao(exp, n);
    palavra *auxiliar;
    significado *aux, *copia, *anterior;

    anterior=NULL;
    for(auxiliar=dicionario[posicao]; auxiliar!=NULL; auxiliar=auxiliar->prox){
        if(strcmp(auxiliar->expressao, exp)==0){
            for(aux=dicionario[posicao]->significados; aux!=NULL; anterior=aux, aux=aux->proximo){
                if(strcmp(aux->definicao, def)==0){
                    if(anterior==NULL){
                        dicionario[posicao]->significados=aux->proximo;
                    }
                    else{
                        copia=aux->proximo;
                        anterior=copia;
                    }
                    free(aux);
                }
            }
        }
    }
}


/***********************************************************************
funcao que ELIMINA uma expressao do dicionario
***********************************************************************/
void eliminar_expressao (vetor *dicionario, int n, char exp[]){
    int posicao;
    posicao=dispersao(exp, n);
    palavra *auxiliar, *anterior;
    significado *aux, *next;

    anterior=NULL;
    for(auxiliar=dicionario[posicao]; auxiliar!=NULL; anterior=auxiliar, auxiliar=auxiliar->prox){
        if(strcmp(auxiliar->expressao, exp)==0){
            aux=auxiliar->significados;
            next=aux->proximo;
            if(anterior!=NULL){
                anterior=auxiliar->prox;
            }
            else{
                dicionario[posicao]=auxiliar->prox;
            }
            while(aux!=NULL){
                free(aux);
                aux=aux->proximo;
            }
            free(auxiliar);
        }
    }

}


/***********************************************************************
funcao que gera a base de dados final
***********************************************************************/
void gerar_base(int n, vetor *dicionario){
    palavra *auxiliar;
    significado *aux;
    FILE *base;

    base=fopen("dicionitaa.txt", "w");

    for(int i=0; i<n; i++){
        for(auxiliar=dicionario[i]; auxiliar!=NULL; auxiliar=auxiliar->prox){
            for(aux=dicionario[i]->significados; aux!=NULL; aux=aux->proximo){
                fprintf(base, "%s|%s\n", auxiliar->expressao, aux->definicao);
            }
        }
    }
    fprintf(base, "\n");
    fclose(base);
}


/*************************************************************************************/
int main(){
    int vezes, operacao, n;
    char linha[100], lixo, exp[50], def[50], *pch;
    vetor *dicionario;
    FILE *entrada, *inicio, *saida;

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

    fscanf(entrada, "%d %d", &n, &vezes);
    dicionario=(vetor*)malloc(n*sizeof(vetor));
    for(int i=0; i<n; i++){
        dicionario[i]=NULL;
    }

    while(vezes>0){
        fscanf(entrada, "%d%c", &operacao, &lixo);
        fgets(linha, 101, entrada);
        linha[strlen(linha)-1]='\0';
        switch(operacao){
        case 1:
            baseDeDados(dicionario, n, inicio);
            break;
        case 2:
            consultar(saida, linha, n, dicionario);
            break;
        case 3:
            pch=strtok(linha, "|");
            strcpy(exp, pch);
            pch=strtok(NULL, "|");
            strcpy(def, pch);
            inserir(exp, def, dicionario, n);
            break;
        case 4:
            pch=strtok(linha, "|");
            strcpy(exp, pch);
            pch=strtok(NULL, "|");
            strcpy(def, pch);
            eliminar_significado(dicionario, n, exp, def);
            break;
        case 5:
            eliminar_expressao (dicionario, n, linha);
            break;
        case 6:
            gerar_base(n, dicionario);
            break;
        }
        vezes--;
    }

    fclose(entrada);
    fclose(inicio);
    fclose(saida);

    return 0;
}

0

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;
}

0