Exemplo n.º 1
0
grafo escreve_grafo(FILE *output, grafo g) {

	if(!(g && output)) return NULL;

	vertice v;
	aresta  a;
	no nv, na;

    fprintf( output, "strict %sgraph \"%s\" {\n\n", g->direcionado ? "di" : "", g->nome );

    // Imprime vertices

	for( nv = primeiro_no(g->vertices); nv; nv = proximo_no(nv) ){
		v = conteudo(nv);
		fprintf( output, "    \"%s\"\n", v->nome );
	}
	fprintf( output, "\n" );

    // Imprime arestas

	lista la = arestas(g);
	const char *dir = g->direcionado ? "->" : "--";
	for( na = primeiro_no(la); na; na = proximo_no(na) ){
		a = conteudo(na);
		fprintf( output, "    \"%s\" %s \"%s\"", nome_vertice(a->origem), dir, nome_vertice(a->destino) );
		if( g->ponderado ) fprintf( output, " [peso=%ld]", a->peso );
		fprintf( output, "\n" );
	}
    fprintf( output, "}\n" );
    destroi_lista(la, NULL);

    return g;
}
Exemplo n.º 2
0
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;
}
Exemplo n.º 3
0
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;
}
Exemplo n.º 4
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;
}
Exemplo n.º 5
0
//------------------------------------------------------------------------------
int main(void) {
  struct grafo *g, *d, *c;
  struct vertice *v;
  struct no *n;
  lista l;

  g = le_grafo(stdin);
  escreve_grafo(stdout, g);

  if((l = ordena(g)) != NULL) {
    for(n = primeiro_no(l); n != NULL; n = proximo_no(n)) {
      v = (struct vertice *) conteudo(n);
      fprintf(stdout, "%s\n", nome_vertice(v));
    }

    destroi_lista(l, nao_destroi_nos);
  }

  if((l = componentes(g)) != NULL) {
    for(n = primeiro_no(l); n != NULL; n = proximo_no(n)) {
      c = (struct grafo *) conteudo(n);
      escreve_grafo(stdout, c);
    }

    destroi_lista(l, destroi_grafo);
  }

  d = arvore_geradora_minima(g);
  if(d != NULL) {
    escreve_grafo(stdout, d);
    destroi_grafo(d);
  }


  /*
  d = arborescencia_caminhos_minimos(g, v);
  if(d != NULL) {
    escreve_grafo(stdout, d);
    destroi_grafo(d);
  }
  */

  d = distancias(g);
  if(d != NULL) {
    escreve_grafo(stdout, d);
    destroi_grafo(d);
  }

  fprintf(stdout, "Diametro = %ld\n", diametro(g));

  if(conexo(g)) {
    fprintf(stdout, "Conexo!\n");
  } else {
    fprintf(stdout, "Não é conexo!\n");
  }

  if(fortemente_conexo(g)) {
    fprintf(stdout, "Fortemente conexo!\n");
  } else {
    fprintf(stdout, "Não é fortemente conexo!\n");
  }

  /*if((l_blocos = blocos(g)) != NULL) {
    fprintf(stderr, "\n--Blocos criados:\n" );
    for(n = primeiro_no(l); n != NULL; n = proximo_no(n)) {
      c = (struct grafo *) conteudo(n);
      escreve_grafo(stdout, c);
    }

    destroi_lista(l_blocos, destroi_grafo);
  }*/

  destroi_grafo(g);
  return 0;
}