static tpVertice* ObterOrigem (GRA_tppGrafo grafo, tpVertice* v) {
tpVertice** us = NULL; //Vetor com componentes a iterar;
tpVertice* u = NULL;
LIS_tppLista origens = grafo->componentes;
int i = 0;
LIS_IrInicioLista(grafo->vertices);
LIS_IrInicioLista(origens);
if (LIS_ProcurarValor(origens, v) == LIS_CondRetOK) {
return v; //é a origem da própria componente
}
if(LIS_NumeroDeElementos(origens) > 0) {
us = (tpVertice**) calloc(LIS_NumeroDeElementos(origens), sizeof(tpVertice*));
LIS_IrInicioLista(origens);
do {
u = (tpVertice *)LIS_ObterValor(origens);
if(u == NULL) break;
us[i] = u;
i++;
} while(LIS_AvancarElementoCorrente(origens, 1) == LIS_CondRetOK);
for ( i;i; i--) {
if (BFS(us[i-1],v) == 1) {
u = us[i-1];
}
}
free(us);
}
return u;
}
static int* converteListaParaVetorDeInteiros(LIS_tppLista lista, int* len) {
int* vet;
*len = 0;
if (lista == NULL || LIS_NumeroDeElementos(lista) == 0) {
return NULL;
}
vet = (int*)calloc(LIS_NumeroDeElementos(lista) ,sizeof(int));
LIS_IrInicioLista(lista);
do {
vet[*len] = getInt(LIS_ObterValor(lista));
*len = (*len)+1;
} while(LIS_AvancarElementoCorrente(lista, 1) == LIS_CondRetOK);
return vet;
}
GRA_tpCondRet GRA_BuscarVertice( GRA_tppGrafo pGrafo , int* idVertice , int predicado(void* pDado, void* _parametro), void* parametro )
{
LIS_tppLista vertices;
tpVertice* vertice;
vertices = pGrafo->vertices;
if(LIS_NumeroDeElementos(vertices) == 0){
*idVertice = -1;
return GRA_CondRetGrafoVazio;
}
LIS_IrInicioLista(vertices);
do
{
vertice = (tpVertice*)LIS_ObterValor(vertices);
if (predicado(vertice->pNode->pValor, parametro))
{
*idVertice = vertice->id;
return GRA_CondRetOK;
}
}
while (LIS_AvancarElementoCorrente(vertices, 1) == LIS_CondRetOK);
return GRA_CondRetNaoEhVertice;
}
GRA_tpCondRet GRA_InserirVertice (GRA_tppGrafo pGrafo, void* pValor, int id)
{
int i;
tpVertice * pElem = NULL ;
tpVertice * v = NULL ;
#ifdef _DEBUG
assert( pGrafo != NULL ) ;
#endif
/* Criar o Vertice antes */
pElem = CriarVertice( pGrafo, pValor, id ) ;
if ( pElem == NULL ) {
return GRA_CondRetFaltouMemoria ;
}
if( LIS_InserirElementoApos (pGrafo->vertices, pElem) != LIS_CondRetOK) {
free(pElem);
return GRA_CondRetFaltouMemoria ;
}
if(pGrafo->corrente == -1) {
pGrafo->corrente = id;
}
LIS_NumeroDeElementos(pElem->pNode->arestas);
return GRA_CondRetOK ;
}
PILHA_tpCondRet PILHA_VerificarPilha( PILHA_tppPilha pPilha, int * quantidadeErros){
*quantidadeErros = 0;
if(LIS_VerificaLiberaElemCorrente(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_VerificaSucessorNULL(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_VerificaPredecessorNULL(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_VerificaLixoSucessor(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_VerificaLixoPredecessor(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_VerificaConteudoNulo(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_VerificaTipoConteudo(pPilha->topo, "carta") != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_VerificaCorrenteNulo(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_NumeroDeElementos(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
if(LIS_confereNumero(pPilha->topo) != LIS_CondRetOK)
*quantidadeErros += 1;
return PILHA_CondRetOK;
}
static GRA_tpCondRet ExcluirVertice (GRA_tppGrafo pGrafo, tpVertice* pVertice) {
tpAresta** vizinhos = NULL;
tpNode* no = NULL;
tpVertice * pVerticeVizinho = NULL;
int i = 0;
no = pVertice->pNode;
LIS_IrInicioLista(pGrafo->componentes);
LIS_ProcurarValor(pGrafo->componentes, pVertice);
LIS_ExcluirElemento(pGrafo->componentes);
if (LIS_NumeroDeElementos(no->arestas) > 0) {
vizinhos = (tpAresta**)calloc(LIS_NumeroDeElementos(no->arestas), sizeof(tpAresta*));
LIS_IrInicioLista(no->arestas);
do {
vizinhos[i] = (tpAresta *)LIS_ObterValor(no->arestas);
i++;
} while ( LIS_AvancarElementoCorrente(no->arestas,1) == LIS_CondRetOK);
for (i; i; i--) {
ExcluirAresta(pGrafo, pVertice, vizinhos[i-1]->pVizinho);
}
if (pGrafo->ExcluirValor != NULL && no->pValor != NULL) {
pGrafo->ExcluirValor(no->pValor);
no->pValor = NULL;
}
free(vizinhos);
}
LIS_DestruirLista(no->arestas);
no->arestas = NULL;
pVertice->pNode = NULL;
free(no);
LIS_IrInicioLista(pGrafo->vertices);
LIS_ProcurarValor(pGrafo->vertices, pVertice);
LIS_ExcluirElemento(pGrafo->vertices);
return GRA_CondRetOK;
}
static int BFS(tpVertice* v, tpVertice* u) {
LIS_tppLista V = NULL; // LISTA VERTICE VISITADOS
LIS_tppLista Q = NULL; //FILA
LIS_tppLista arestas = NULL;
tpVertice* t = NULL;
tpVertice* s = NULL;
tpAresta* a = NULL;
int achou = 0;
int achou_V = 0;
V = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
Q = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
LIS_InserirElementoApos(V, v);
LIS_InserirElementoApos(Q, v); //Usado como uma Fila.
while (LIS_NumeroDeElementos(Q) > 0) {
LIS_IrInicioLista(Q);
t = (tpVertice *)LIS_ObterValor(Q);
LIS_ExcluirElemento(Q);
if (t == u) {
achou = 1;
break;
}
arestas = t->pNode->arestas;
LIS_IrInicioLista(arestas);
do {
a = (tpAresta *)LIS_ObterValor(arestas);
if(a == NULL) continue;
s = a->pVizinho;
LIS_IrInicioLista(V);
achou_V = 0;
do {
tpVertice * re = (tpVertice *)LIS_ObterValor(V);
if (re == NULL) {
continue;
}
if(re == s) achou_V = 1;
} while(LIS_AvancarElementoCorrente(V, 1) == LIS_CondRetOK);
if (!achou_V) {
if(LIS_InserirElementoApos(V, s)!= LIS_CondRetOK){ achou = -1;break;}
if(LIS_InserirElementoApos(Q, s)!= LIS_CondRetOK){ achou = -1;break;}
}
} while(LIS_AvancarElementoCorrente(arestas, 1) == LIS_CondRetOK);
}
LIS_DestruirLista(V);
LIS_DestruirLista(Q);
return achou;
}
/***********************************************************************
*
* $FC Função: MEN GetMenuOpcoes
*
***********************************************************************/
MEN_tpCondRet MEN_GetMenuOpcoes(MEN_tppMenus m,int id,char** l, int* tam){
int n,x;
MEN_tppMenu menu;
char* l1;
n = 0;
GRA_ObterValor(m->grafo,id,(void**)&menu);
x = LIS_NumeroDeElementos(menu->opcoes);
*l = (char*)malloc(x);
l1 = (char*)malloc(x);
LIS_IrInicioLista(menu->opcoes);
do{
MEN_tppOpcao o = (MEN_tppOpcao)LIS_ObterValor(menu->opcoes);
l1[n] = o->cmd;
n++;
}
while(LIS_AvancarElementoCorrente(menu->opcoes,1)==LIS_CondRetOK);
*tam = n;
strcpy(*l,l1);
return MEN_CondRetOK;
}
GRA_tpCondRet GRA_ObterVizinhos ( GRA_tppGrafo pGrafo, int idVertice, LIS_tppLista* pLista) {
tpVertice * pVertice = get_by_id(pGrafo,idVertice);
LIS_tppLista vizinhos = NULL;
LIS_tppLista Ret_vizinhos = NULL;
tpAresta* aresta = NULL;
int* idVerticeVizinho = NULL;
if (pVertice == NULL)
return GRA_CondRetNaoEhVertice;
Ret_vizinhos = LIS_CriarLista(free);
if (Ret_vizinhos == NULL) {
return GRA_CondRetFaltouMemoria;
}
vizinhos = pVertice->pNode->arestas;
LIS_IrInicioLista(vizinhos);
if (LIS_NumeroDeElementos(vizinhos) > 0) {
do {
idVerticeVizinho = (int*) calloc(1, sizeof(int));
aresta = (tpAresta *)LIS_ObterValor(vizinhos);
(*idVerticeVizinho) = aresta->pVizinho->id;
if (LIS_InserirElementoApos( Ret_vizinhos, idVerticeVizinho) != LIS_CondRetOK ) {
LIS_DestruirLista(Ret_vizinhos);
return GRA_CondRetFaltouMemoria;
}
}
while(LIS_AvancarElementoCorrente(vizinhos, 1) == LIS_CondRetOK);
}
*pLista = Ret_vizinhos;
return GRA_CondRetOK;
}
GRA_tpCondRet GRA_BuscarCaminho( GRA_tppGrafo pGrafo , int idVerticeOrigem, int idVerticeDestino, LIS_tppLista * pLista ) {
tpVertice * v = NULL;
tpVertice * u = NULL;
tpVertice * origem1 = NULL;
tpVertice * origem2 = NULL;
int lenV = 0;
LIS_tppLista Q = NULL; //FILA
LIS_tppLista arestas = NULL;
LIS_tppLista retorno = NULL;
int t;
int len = 0;
int achou = 0;
int ok = 0;
int i,j,in;
int lenD;
int alt = 0;
int* visitados = NULL; // Vetor de vertices visitados
int* vizinhos = NULL;
int* idAux = NULL;
Dist** dists = NULL;
Dist* dist = NULL; //aux;
Dist* currDist = NULL;
lenD = 1;
v = get_by_id(pGrafo, idVerticeOrigem);
u = get_by_id(pGrafo, idVerticeDestino);
if(v == NULL || u == NULL) {
return GRA_CondRetNaoEhVertice;
}
origem1 = ObterOrigem(pGrafo, v);
origem2 = ObterOrigem(pGrafo, u);
if (origem1 != origem2) {
return GRA_CondRetNaoEhConexo;
}//Else: É conexo, devia retornar Ok.
for (;;) {
dists = (Dist**)calloc(LIS_NumeroDeElementos(pGrafo->vertices)+1, sizeof(Dist*));
if (dists == NULL) {break;}
dists[0] = newDist(idVerticeOrigem, 0);
retorno = LIS_CriarLista(free);
if (retorno == NULL) { break; }
else if (v == u) {
if( LIS_InserirElementoApos(retorno, newInt(idVerticeOrigem)) == LIS_CondRetOK) {
*pLista = retorno;
return GRA_CondRetOK;
} else {
break;
}
}
visitados = (int*) calloc(LIS_NumeroDeElementos(pGrafo->vertices)+1,sizeof(int));
if (visitados == NULL) { break; }
Q = LIS_CriarLista(free);
if (Q == NULL) { break; }
visitados[0] = idVerticeOrigem;
lenV = 1;
if (LIS_InserirElementoApos(Q, newInt(idVerticeOrigem)) != LIS_CondRetOK) { break;} //enque
ok = 1;
break;
}
if (!ok) {
free(dists);
LIS_DestruirLista(retorno);
free(visitados);
LIS_DestruirLista(Q);
return GRA_CondRetFaltouMemoria;
}
while (LIS_NumeroDeElementos(Q) > 0) {
//dequeue
LIS_IrInicioLista(Q);
t = getInt(LIS_ObterValor(Q));
LIS_ExcluirElemento(Q);
//Iterar sobre vizinhos
GRA_ObterVizinhos(pGrafo, t, &arestas);
vizinhos = converteListaParaVetorDeInteiros(arestas, &len);
LIS_DestruirLista(arestas);
arestas = NULL;
currDist = getDist(dists, t);
if(!currDist) {
return GRA_CondRetFaltouMemoria;
} else {
}
alt = currDist->dist + 1;
for (i=0; i < len; i++) {
in = 0;
for (j=0; j < lenV; j++) {
if (visitados[j] == vizinhos[i]) {
in = 1;
}
}
if (!in) {
dist = getDist(dists, vizinhos[i]);
if (dist == NULL) { //infinity
dists[lenD] = newDist(vizinhos[i], alt);
dists[lenD]->prev = currDist;
dist = dists[lenD];
lenD++;
} else if (alt < dist->dist) {
dist->dist = alt;
dist->prev = currDist;
}
if (idVerticeDestino == vizinhos[i]) {
currDist = dist;
achou = 1;
}
visitados[lenV] = vizinhos[i];
lenV++;
LIS_InserirElementoAntes(Q, newInt(vizinhos[i]));
}
}
free(vizinhos);
if (achou) {
currDist = dist;
break;
}
if(lenV == LIS_NumeroDeElementos(pGrafo->vertices)) {
break;
}
}
if (achou) {
//printf("\n");
// for(i=0; i < lenD; i++) {
// printf("endr: %p, id: %d, dist: %d, prev: %p \n", *(dists+i), dists[i]->id, dists[i]->dist, dists[i]->prev);
// }
while (currDist) {
LIS_InserirElementoAntes(retorno, newInt(currDist->id));
currDist = currDist->prev;
}
}
//Limpando a memória
for (i=0; i < lenD; i++) {
free(dists[i]);
}
free(dists);
free(visitados);
LIS_DestruirLista(Q);
*pLista = retorno;
return GRA_CondRetOK;
}
