DFS em Lista de Adjacência em C

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

#define true 1
#define false 0

typedef int bool;
typedef int TIPOPESO;

#define BRANCO 0
#define AMARELO 1
#define VERMELHO 2

typedef struct adjacencia {
    int vertice;                // Vertice final da aresta.
    int peso;
    struct adjacencia *prox;
} ADJACENCIA;

typedef struct vertice {
    char cidade;
    ADJACENCIA *cabeca;
} VERTICE;

typedef struct grafo {
    int vertices;
    int arestas;
    VERTICE *adj;
} GRAFO;

GRAFO *criaGrafo(int numVertices)
{
    GRAFO *g = (GRAFO *) malloc(sizeof(GRAFO));

    g->vertices = numVertices;
    g->arestas = 0;
    g->adj = (VERTICE *) malloc(numVertices * sizeof(VERTICE));

    for (int i = 0; i < numVertices; i++) {
        g->adj[i].cabeca = NULL;
    }

    return g;
}

ADJACENCIA *criaAdj(int noFinalAresta, int peso)        // Função auxiliar.
{
    ADJACENCIA *temp = (ADJACENCIA *) malloc(sizeof(ADJACENCIA));       // Cria espaço para um nó na lista de adjacencia.

    temp->vertice = noFinalAresta;
    temp->peso = peso;
    temp->prox = NULL;

    return temp;
}

bool criaAresta(GRAFO *gr, int vi, int vf, int peso)
{
    if (!gr) return false;
    if ((vf < 0) || (vi >= gr->vertices))
        return false;

    if ((vi < 0) || (vf >= gr->vertices))
        return false;

    ADJACENCIA *novo = criaAdj(vf, peso);
    novo->prox = gr->adj[vi].cabeca;
    gr->adj[vi].cabeca = novo;
    gr->arestas++;

    return true;
}

void imprime(GRAFO *gr)
{
    printf("Vertices: %d. Arestas: %d.\n", gr->vertices, gr->arestas);

    int i;
    for (i = 0; i < gr->vertices; i++)
    {
        printf("Cidade %c | v%d: ", gr->adj[i].cidade, i);
        ADJACENCIA *ad = gr->adj[i].cabeca;

        while(ad)
        {
            printf("v%d(%d) ", ad->vertice, ad->peso);

            ad = ad->prox;
        }
        printf("\n");
    }
}
int visitaP(GRAFO *g, int u, int *cor, char cidade)
{
    cor[u] = AMARELO;

    if (g->adj[u].cidade == cidade)
    {
        return u;
    }

    ADJACENCIA *v = g->adj[u].cabeca;

    while(v)
    {
        if (cor[v->vertice] == BRANCO)
        {
            int res = visitaP(g, v->vertice, cor, cidade);
            if (res != -1) return res;
        }
        v = v->prox;
    }
    cor[u] = VERMELHO;

    return -1;
}

int profundidade(GRAFO *g, char cidade)
{
    int numVertices = g->vertices;
    int cor[numVertices];

    int u;
    for (u = 0; u < numVertices; u++)
    {
        cor[u] = BRANCO;
    }

    for (u = 0; u < numVertices; u++)
    {
        if (cor[u] == BRANCO)
        {
            int resultado = visitaP(g, u, cor, cidade);
            if (resultado != -1) return resultado;
        }
    }
    return -1;
}

bool atribuiValor(GRAFO *gr, int no, char cidade)
{
    if (!gr) return false;

    if ((no < 0) || (no >= gr->vertices))
        return false;

    if (profundidade(gr, cidade) == -1)
    {
        gr->adj[no].cidade = cidade;
        return true;
    }
}

int main()
{
    GRAFO *meuGrafo = criaGrafo(5);

    atribuiValor(meuGrafo, 0, 'A');
    atribuiValor(meuGrafo, 1, 'B');
    atribuiValor(meuGrafo, 2, 'C');
    atribuiValor(meuGrafo, 3, 'D');
    atribuiValor(meuGrafo, 4, 'E');

    criaAresta(meuGrafo, 0, 1, 2);
    criaAresta(meuGrafo, 1, 2, 4);
    criaAresta(meuGrafo, 2, 0, 12);
    criaAresta(meuGrafo, 2, 4, 40);
    criaAresta(meuGrafo, 3, 1, 3);
    criaAresta(meuGrafo, 4, 3, 8);

    imprime(meuGrafo);

    int posC = profundidade(meuGrafo, 'X');

    printf("Posicao de X: %d\n", posC);

    return 0;
}