static aresta copia_aresta( aresta a, grafo ng ) {
aresta at = malloc(sizeof(struct aresta)+1);
at->peso = a->peso;
at->visitada = a->visitada;
at->coberta = a->coberta;
at->origem = busca_vertice(ng->vertices, nome_vertice(a->origem));
at->destino = busca_vertice(ng->vertices, nome_vertice(a->destino));
return at;
}
static aresta cria_aresta( lista lv, Agedge_t *e ){
char *findme = malloc(sizeof(char) * strlen("peso\0")+1);
strcpy( findme, "peso\0" );
aresta a = malloc(sizeof(struct aresta));
a->visitada = 0;
a->coberta = 0;
a->origem = busca_vertice(lv, agnameof(agtail(e)));
a->destino = busca_vertice(lv, agnameof(aghead(e)));
char *peso = agget( e, findme );
a->peso = peso ? strtol(peso,NULL,10) : 0;
free(findme);
return a;
}
grafo copia_grafo(grafo g) {
struct grafo *ng = malloc(sizeof(struct grafo));
if( !ng ) return NULL;
vertice v;
no nv, na;
ng->nome = malloc(sizeof(char) * strlen(nome_grafo(g)+1));
strcpy(ng->nome, g->nome);
ng->vertices = constroi_lista();
for( nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){
vertice vt = malloc(sizeof(struct vertice));
v = conteudo(nv);
vt->nome = malloc(sizeof(char) * strlen(nome_vertice(v))+1);
strcpy(vt->nome, nome_vertice(v));
vt->visitado = v->visitado;
vt->coberto = v->coberto;
vt->arestas_saida = constroi_lista();
vt->arestas_entrada = constroi_lista();
insere_lista(vt, ng->vertices);
}
for( nv = primeiro_no(ng->vertices); nv; nv = proximo_no(nv) ){
vertice vd = conteudo(nv);
vertice vo = busca_vertice(g->vertices, nome_vertice(vd));
for( na = primeiro_no(vo->arestas_saida); na; na = proximo_no(na) ){
aresta at = copia_aresta( conteudo(na), ng );
insere_lista(at, vd->arestas_saida);
}
if( g->direcionado ){
for( na = primeiro_no(vo->arestas_entrada); na; na = proximo_no(na) ){
aresta at = copia_aresta( conteudo(na), ng );
insere_lista(at, vd->arestas_entrada);
}
}
}
ng->direcionado = g->direcionado;
ng->ponderado = g->ponderado;
ng->n_vertices = g->n_vertices;
ng->n_arestas = g->n_arestas;
return ng;
}
// Insere uma cidade em um vertice do Grafo.
int insere_vertice(Tipo_Grafo* grafo, int cidade, int tamanho)
{
if (grafo->num_vertices < tamanho)
{
if (busca_vertice(grafo, cidade, tamanho) == -1)
{
grafo->vertices[grafo->num_vertices].cidade = cidade;
grafo->vertices[grafo->num_vertices].chave = grafo->num_vertices;
grafo->num_vertices++;
return 1;
}
}
return 0;
}
// Insere uma cidade em um vertice do Grafo.
int insere_vertice(Tipo_Grafo* grafo, int chave, int tamanho)
{
if (grafo->num_vertices < tamanho)
{
if (busca_vertice(grafo, chave, tamanho) == -1)
{
grafo->vertices[grafo->num_vertices].chave = chave;
grafo->vertices[grafo->num_vertices].prox = NULL;
grafo->num_vertices++;
return 1;
}
}
return 0;
}
//------------------------------------------------------------------------------
//
static grafo grafo_emparelhamento(grafo g) {
grafo e = malloc(sizeof(struct grafo));
if( !e ) return NULL;
e->nome = malloc(sizeof(char) * strlen(g->nome)+1);
strcpy(e->nome, g->nome);
e->direcionado = g->direcionado;
e->ponderado = g->ponderado;
e->vertices = constroi_lista();
for( no nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){
vertice ve = malloc(sizeof(struct vertice));
vertice vg = conteudo(nv);
ve->nome = malloc(sizeof(char) * strlen(nome_vertice(vg))+1);
strcpy(ve->nome, nome_vertice(vg));
ve->visitado = 0;
ve->coberto = vg->coberto;
ve->arestas_saida = constroi_lista();
ve->arestas_entrada = constroi_lista();
insere_lista(ve, e->vertices);
}
e->n_vertices = tamanho_lista(e->vertices);
e->n_arestas = 0;
for( no nv = primeiro_no(e->vertices); nv; nv = proximo_no(nv) ){
vertice ve = conteudo(nv);
vertice vg = busca_vertice(g->vertices, nome_vertice(ve));
for( no na = primeiro_no(vg->arestas_saida); na; na = proximo_no(na) ){
aresta ag = conteudo(na);
if (ag->origem != vg) continue;
if( ag->coberta ){
aresta ae = copia_aresta( ag, e );
insere_lista(ae, ae->destino->arestas_saida);
insere_lista(ae, ae->origem->arestas_saida);
e->n_arestas++;
}
}
}
return e;
}
grafo le_grafo(FILE *input) {
Agraph_t *ag = agread(input, 0);
if(!(ag && agisstrict(ag)))
return NULL;
// struct grafo *g = malloc(sizeof(struct grafo));
grafo g = malloc(sizeof(struct grafo));
if( !g ) return NULL;
g->vertices = constroi_lista();
g->nome = malloc(sizeof(char) * strlen(agnameof(ag)+1));
strcpy(g->nome, agnameof(ag));
g->direcionado = agisdirected(ag);
g->n_vertices = (unsigned int)agnnodes(ag);
g->n_arestas = (unsigned int)agnedges(ag);
g->ponderado = 0;
for( Agnode_t *v = agfstnode(ag); v; v = agnxtnode(ag,v) ){
vertice vt = malloc(sizeof(struct vertice));
vt->nome = malloc(sizeof(char) * strlen(agnameof(v))+1);
strcpy( vt->nome, agnameof(v) );
vt->visitado = 0;
vt->coberto = 0;
vt->arestas_saida = constroi_lista();
vt->arestas_entrada = constroi_lista();
insere_lista(vt, g->vertices);
}
for( Agnode_t *v = agfstnode(ag); v; v = agnxtnode(ag,v) ){
vertice vt = busca_vertice(g->vertices, agnameof(v));
if( g-> direcionado ){
for( Agedge_t *e = agfstout(ag,v); e; e = agnxtout(ag,e) ){
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, vt->arestas_saida);
}
for( Agedge_t *e = agfstin(ag,v); e; e = agnxtin(ag,e) ){
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, vt->arestas_entrada);
}
}
else {
for( Agedge_t *e = agfstedge(ag,v); e; e = agnxtedge(ag,e,v) ){
if( agtail(e) != v ) continue;
aresta at = cria_aresta(g->vertices, e);
if( at->peso != 0 ) g->ponderado = 1;
insere_lista(at, at->origem->arestas_saida);
insere_lista(at, at->destino->arestas_saida);
}
}
}
if( agclose(ag) )
return NULL;
return g;
}