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;
}
static lista arestas( grafo g ) {
lista la = constroi_lista();
if( !g ) return la;
for( no nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){
vertice v = conteudo(nv);
for( no na = primeiro_no(v->arestas_saida); na; na = proximo_no(na) ){
aresta a = conteudo(na);
if( !busca_aresta(la, a->origem, a->destino) )
insere_lista( a, la );
}
if( g->direcionado ) {
for( no na = primeiro_no(v->arestas_entrada); na; na = proximo_no(na) ){
aresta a = conteudo(na);
if( !busca_aresta(la, a->origem, a->destino) )
insere_lista( a, la );
}
}
}
return la;
}
//------------------------------------------------------------------------------
static Agraph_t *mostra_grafo(Agraph_t *g) {
if ( ! g )
return NULL;
direcionado = agisdirected(g);
n_vertices = agnnodes(g);
n_arestas = agnedges(g);
lista_arestas = constroi_lista();
printf("strict %sgraph \"%s\" {\n\n",
agisdirected(g) ? "di" : "",
agnameof(g)
);
mostra_vertices(g);
printf("\n");
mostra_arestas();
printf("}\n");
destroi_lista(lista_arestas, NULL);
return g;
}
static lista vizinhanca_entrada(vertice v){
lista viz = constroi_lista();
for (no n=primeiro_no(v->adjacencias_entrada); n!=NULL; n=proximo_no(n)) {
adjacencia a = conteudo(n);
insere_lista(a->v_origem, viz);
}
return viz;
}
int sao_isomorfos(grafo g, grafo f)
{
int i = 0;
int j, k;
int iso = 0;
int tam = g.n_vertices;
int *tmp = (int*) malloc(sizeof(int));
int v[tam], t_perm = 0;
lista *perm;
perm = constroi_lista();
for(i=0; i < tam; i++)
{
v[i] = i;
}
if((g.n_vertices != f.n_vertices) || (g.arestas != f.arestas)
|| (!iguais(g, f)))
return iso;
perm = nova_permuta(perm, v, 0, tam);
t_perm = tamanho_lista(perm);
for(i=0; i < t_perm; i++)
{
tmp = (int*) remove_lista(perm);
//mostre(tmp, tam);
iso = 1;
for(j=0; j < tam; j++)
{
for(k=0; k < tam; k++)
{
if(g.matriz[j][k] != f.matriz[tmp[j]][tmp[k]])
{
iso = 0;
/*printf("Nao e isomorfo - ");
mostre(tmp, tam);*/
break;
}
}
if(!iso)
break;
}
if(iso)
{
/*printf("E isomorfo - ");
mostre(tmp, tam);*/
destroi_lista(perm);
return 1;
}
}
destroi_lista(perm);
return 0;
}
static lista vizinhanca_saida(vertice v){
lista viz = constroi_lista();
for (no n=primeiro_no(v->adjacencias_saida); n!=NULL; n=proximo_no(n)) {
if(n != NULL){
adjacencia a = conteudo(n);
insere_lista(a->v_destino, viz);
}
}
return viz;
}
//------------------------------------------------------------------------------
//
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;
}
//------------------------------------------------------------------------------
// cria, insere no grafo e retorna o vertice
static vertice cria_vertice(grafo g, const char *nome){
vertice v = malloc(sizeof(struct vertice));
if(v == NULL){
return 0;
}else{
v->id = g->n_vertices;
v->nome = malloc((strlen(nome) +1) *sizeof(char));
strcpy(v->nome, nome);
v->adjacencias_saida = constroi_lista();
v->adjacencias_entrada = constroi_lista();
v->grau_entrada = 0;
v->grau_saida = 0;
v->removido = 0;
g->vertices[v->id] = v;
g->n_vertices++;
}
return v;
free(v->nome);
free(v);
}
lista vizinhanca(vertice v, int direcao, grafo g) {
lista la, lv = constroi_lista();
if( !v || !g ) return lv;
switch( direcao ){
case 0 : la = v->arestas_saida; break;
case 1 : la = v->arestas_saida; break;
case -1 : la = v->arestas_entrada; break;
}
for( no n = primeiro_no(la); n; n = proximo_no(n) ){
aresta a = conteudo(n);
if( v == a->origem ){
insere_lista( a->destino, lv );
}
if( v == a->destino ){
insere_lista( a->origem, lv );
}
}
return lv;
}
//------------------------------------------------------------------------------
//
static lista caminho_aumentante(grafo g) {
if( !g ) return NULL;
lista l;
for( no n = primeiro_no(g->vertices); n; n = proximo_no(n) ){
vertice v = conteudo(n);
if( !v->coberto ) {
v->visitado = 1;
l = constroi_lista();
if( busca_caminho(v, l, 1) ) {
return l;
}
else {
printf("busca deu errado\n");
desvisita_vertices(g);
destroi_lista(l, NULL);
}
}
}
desvisita_vertices(g);
return NULL;
}
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;
}
