trabalho quase terminado

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

/*
 *  Alunos:
 *  - Richardson Kuerten Silva 12111BSI231
 *  - Marco Túlio Sousa Costa 12111BSI240
 *  - Eduardo Santos Pires 12111BSI203
 */

//-----------------------------------PILHA E SUAS FUNCOES----------------------------------------

typedef struct
{
    int tamanho;
    int elementos[100];
    int topo;
} Pilha;

Pilha *cria(int *deucerto)
{
    Pilha *p = (Pilha *)malloc(sizeof(Pilha));

    if(p == NULL)
    {
        *deucerto = 0;
    }
    else
    {
        *deucerto = 1;
    }

    p->topo=-1;
    p->tamanho=100;

    return p;
}

void libera(Pilha *p, int *deucerto)
{
    if(p == NULL)
    {
        *deucerto = 0;
        return;
    }
    else
    {
        *deucerto = 1;
        free(p);
    }
}

int cheia(Pilha *p)
{
    if(p->topo == p->tamanho-1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int vazia(Pilha *p)
{
    if(p->topo == -1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

void empilha(Pilha *p, int elemento, int *deucerto)
{
    if(cheia(p))
    {
        *deucerto=0;
    }
    else
    {
        p->topo = p->topo+1;
        p->elementos[p->topo] = elemento;
        *deucerto = 1;
    }
}

int desempilha(Pilha *p, int *deucerto)
{
    int elementoretirado;

    if(vazia(p))
    {
        *deucerto = 0;
        return;
    }
    else
    {
        elementoretirado = p->elementos[p->topo];
        p->topo = p->topo-1;

        *deucerto = 1;
    }

    return elementoretirado;
}


int main()
{
    int i, j;
    int vertices;
    //a variavel v representa a quantidade de vertices e dita o tamanho da matriz

    scanf("%d",&vertices);

    int **matriz;

    //alocando matriz dinamica
    matriz = (int**) malloc(sizeof(int*) * vertices);
    for(i=0; i<vertices; i++)
    {
        matriz[i] = (int*) malloc(sizeof(int) * vertices);
    }

    //setando a matr5iz para 0
    for(i=0; i<vertices; i++)
    {
        for(j=0; j<vertices; j++)
        {
            matriz[i][j]= 0;
        }
    }

    int aresta;
    //a variavel a representa a quantidade de arestas, e sera condicao para um laco

    scanf("%d",&aresta);

    int x, y;
    //x e y representa as conexoes de origem e destino respectivamente

    //laco que recebe as entradas dos valores das conexoes
    for(i=0; i<aresta; i++)
    {
        int custo;
        scanf("%d %d %d", &x, &y, &custo);

        //a indexacao da matriz comeca no zero em C, como recebemos comecando em 1 e preciso fazer -1
        matriz[x-1][y-1] = custo;
    }

//-------------------------------------comeco do algoritmo-----------------------

    //criando pilha
    Pilha *p;
    int deucerto;
    p = cria(&deucerto);

    int origem, destino;

    //leitura origem destino
    scanf("%d %d", &origem, &destino);

    //linha inicia com o valor da origem -1
    int vizinho, linha = origem-1;

    //pilha inicia com o valor da origem
    empilha(p, origem, &deucerto);

    i=0;
    //laco que percorre linha da matriz
    while(1)
    {

        if(linha+1 == destino)
        {
            break;
        }
        if(vazia(p))
        {
            break;
        }

        for(i; i<vertices; i++)
        {

            //caso este ponto na matriz seja um vizinho, empilha o vizinho(eh o i)
            if(matriz[linha][i] != 0)
            {

                vizinho = i;
                empilha(p, vizinho+1, &deucerto);
                linha = vizinho;

                //quando encontrado novo vizinho percorre linha desde o comeco
                i=0;
                break;
            }

            //caso percorremos toda linha e nao achou vizinho,
            if(i==vertices-1 && matriz[linha][i]==0)
            {

                i = desempilha(p, &deucerto);
                //caso o que desempilhamos for correspondente o final de uma linha,
                //continua desempilhando pois significa que nao ha mais oq procurar
                while(i==vertices-1 && !vazia(p))
                {
                    i = desempilha(p, &deucerto);
                }

                if(!vazia(p))
                {
                    linha = (desempilha(p, &deucerto)-1);
                    empilha(p, linha+1, &deucerto);

                    break;
                }
            }
        }
    }

    int custo=0, coluna;

    if(vazia(p))
    {
        custo = -1;
    }
    else
    {
        linha = desempilha(p, &deucerto) - 1;

        while(!vazia(p))
        {
            coluna = linha;
            linha = desempilha(p, &deucerto) - 1;
            custo = custo + matriz[linha][coluna];
        }
    }

    printf("%d\n", custo);

    //liberando a memória da matriz dinamica
    for(i=0; i<vertices; i++)
    {
        free(matriz[i]);
    }
    free(matriz);

    //liberando a memória da pilha "p"
    libera(p, &deucerto);

    return 0;
}