int main(void) {
grafo g = le_grafo(stdin);
long int d = diametro(g);
printf("%s\n", nome(g));
printf("%sdirecionado\n", direcionado(g) ? "" : "não ");
if ( direcionado(g) )
printf("%sfortemente conexo\n", fortemente_conexo(g) ? "" : "não ");
else
printf("%sconexo\n", conexo(g) ? "" : "des");
if ( d == infinito )
printf("diâmetro: oo\n");
else
printf("diâmetro: %ld\n", d);
destroi_grafo(escreve_grafo(stdout, distancias(g)));
printf("\n");
return ! destroi_grafo(g);
}
//------------------------------------------------------------------------------
grafo le_grafo(FILE *input) {
Agraph_t *g;
grafo grafo_lido;
char peso_string[] = "peso";
/* Aloca estrutura do grafo lido */
grafo_lido = (grafo) malloc(sizeof(struct grafo));
if(grafo_lido != NULL) {
/* Armazena em g o grafo lido da entrada */
if((g = agread(input, NULL)) == NULL) {
destroi_grafo(grafo_lido);
return NULL;
}
/* Carrega na estrutura os vértices de g */
if((grafo_lido->grafo_vertices = obter_vertices(g, &(grafo_lido->grafo_n_vertices))) == NULL) {
agclose(g);
destroi_grafo(grafo_lido);
return NULL;
}
/* Verifica se g é um grafo ponderado ou não */
if(agattr(g, AGEDGE, peso_string, (char *) NULL) != NULL) {
grafo_lido->grafo_ponderado = 1;
} else {
grafo_lido->grafo_ponderado = 0;
}
/* Define o nome do grafo e se ele é direcionado */
grafo_lido->grafo_direcionado = agisdirected(g);
grafo_lido->grafo_nome = strdup(agnameof(g));
/* Carrega na estrutura a matriz de adjacência de g */
if((grafo_lido->grafo_matriz = obter_matriz_adjacencia(g, grafo_lido->grafo_vertices, grafo_lido->grafo_ponderado, grafo_lido->grafo_direcionado, grafo_lido->grafo_n_vertices)) == NULL) {
agclose(g);
destroi_grafo(grafo_lido);
return NULL;
}
agclose(g);
}
return grafo_lido;
}
//------------------------------------------------------------------------------
grafo distancias(grafo g) {
int i;
vertice v;
grafo t;
if (!g) {
return NULL;
}
grafo g_dist = (grafo) malloc(sizeof(struct grafo));
g_dist->nome = (char *) malloc(strlen(g->nome)+1);
strcpy(g_dist->nome, g->nome);
g_dist->n_vertices = g->n_vertices;
g_dist->tipo = 1;
g_dist->peso = 1;
g_dist->vertice = (vertice) malloc( (unsigned int)g_dist->n_vertices * sizeof(struct vertice));
for(i = 0; i < g->n_vertices; i++){
g_dist->vertice[i].nome = (char *) malloc(strlen(g->vertice[i].nome)+1);
strcpy(g_dist->vertice[i].nome, g->vertice[i].nome);
g_dist->vertice[i].aresta = NULL;
g_dist->vertice[i].id = i;
g_dist->vertice[i].next = &g_dist->vertice[i+1];
}
g_dist->vertice[i-1].next = NULL;
for (v = g_dist->vertice; v; v = v->next) {
t = arborescencia_caminhos_minimos(g, v);
if (!t) {
return NULL;
}
busca_em_profundidade(g_dist, t, v);
destroi_grafo(t);
}
return g_dist;
}
int main() {
enum Options {INSERE_VERTEX = 1, REMOVE_VERTEX = 2, INSERE_ARESTA = 3, REMOVE_ARESTA = 4,
CALCULA_DISTANCIA = 5, GRAFO_CONEXO = 6, GRAFO_CONSISTENTE = 7};
char answer, origem[TAM_MAX], destino[TAM_MAX];
char input_name[TAM_MAX], output_name[TAM_MAX];
int option, type;
float peso;
FILE *input = NULL, *output = NULL;
TpGrafo grafo;
TpVertex vertex1;
printf("Digite o nome do arquivo de entrada:\n");
scanf("%[^\n]", input_name);
getchar();
input = fopen(input_name, "r");
printf("Digite o nome do arquivo de saida:\n");
scanf("%[^\n]", output_name);
getchar();
output = fopen(output_name, "w");
assert(input != NULL && output != NULL);
le_grafo(input, &grafo);
printf("\nPrograma para realizar operacoes sobre um grafo.\n\n");
printf("Digite a operacao que deseja realizar:\n");
printf("[1] Insere vertice.\n");
printf("[2] Remove vertice.\n");
printf("[3] Insere aresta.\n");
printf("[4] Remove aresta.\n");
printf("[5] Calcula distancia.\n");
printf("[6] Verifica se o grafo e conexo.\n");
printf("[7] Verifica se o grafo e consistente.\n");
printf("[8] Sai da aplicacao.\n");
scanf("%d", &option);
getchar();
while(option < 1 || option > 8) {
printf("Valor invalido. Tente novamente.\n");
printf("[1] Insere vertice.\n");
printf("[2] Remove vertice.\n");
printf("[3] Insere aresta.\n");
printf("[4] Remove aresta.\n");
printf("[5] Calcula distancia.\n");
printf("[6] Verifica se o grafo e conexo.\n");
printf("[7] Verifica se o grafo e consistente.\n");
printf("[8] Sai da aplicacao.\n");
scanf("%d", &option);
getchar();
}
while(option != 8) {
switch (option) {
case INSERE_VERTEX:
printf("Digite o nome do vertice que sera inserido:\n");
fgets(vertex1.nome, TAM_MAX, stdin);
vertex1.id = grafo.numero_vertices;
printf("O vertice e origem [s/n]?\n");
scanf("%c", &answer);
while(answer != 's' && answer != 'n') {
printf("Resposta invalida. Tente novamente.\n");
printf("O vertice e origem [s/n]?\n");
scanf("%c", &answer);
}
answer == 's'? type = ORIGEM: type = NAO_ORIGEM;
insere_vertex(&grafo, vertex1, type);
break;
case REMOVE_VERTEX:
printf("Deseja proceder com a operacao [s/n]? O grafo pode se tornar inconsistente.\n");
while(answer != 's' && answer != 'n') {
printf("Resposta invalida. Tente novamente.\n");
printf("Deseja proceder com a operacao [s/n]? O grafo pode se tornar inconsistente.\n");
scanf("%c", &answer);
}
if(answer == 'n') {
break;
}
printf("Digite o nome do vertice que sera retirado:\n");
fgets(vertex1.nome, TAM_MAX, stdin);
remove_vertex(&grafo, &vertex1, vertex1.nome);
break;
case INSERE_ARESTA:
printf("Digite o nome da origem da aresta que sera criada:\n");
fgets(origem, TAM_MAX, stdin);
printf("Digite o nome do destino da aresta que sera criada:\n");
fgets(destino, TAM_MAX, stdin);
printf("Digite o peso entre os vertices:n");
scanf("%f", &peso);
insere_aresta(&grafo, origem, destino, peso);
break;
case REMOVE_ARESTA:
printf("Digite o nome da origem da aresta que sera retirada:\n");
fgets(origem, TAM_MAX, stdin);
printf("Digite o nome do destino da aresta que sera retirada:\n");
fgets(destino, TAM_MAX, stdin);
remove_aresta(&grafo, origem, destino);
break;
case CALCULA_DISTANCIA:
printf("Digite o nome da origem para o calculo da distancia:\n");
fgets(origem, TAM_MAX, stdin);
printf("Digite o nome do destino para o calculo da distancia:\n");
fgets(destino, TAM_MAX, stdin);
calculaDistancia(&grafo, origem, destino);
break;
case GRAFO_CONEXO:
grafoConexo(&grafo) == EXIT_SUCCESS? printf("O grafo e conexo.\n"): printf("O grafo nao e conexo.\n");
break;
case GRAFO_CONSISTENTE:
grafoConsistente(&grafo) == EXIT_SUCCESS? printf("O grafo e consistente.\n"): printf("O grafo nao e consistente.\n");
break;
default:
printf("ERRO!\n");
}
printf("Digite a operacao que deseja realizar:\n");
printf("[1] Insere vertice.\n");
printf("[2] Remove vertice.\n");
printf("[3] Insere aresta.\n");
printf("[4] Remove aresta.\n");
printf("[5] Calcula distancia.\n");
printf("[6] Verifica se o grafo e conexo.\n");
printf("[7] Verifica se o grafo e consistente.\n");
printf("[8] Sai da aplicacao.\n");
scanf("%d", &option);
getchar();
while(option < 1 || option > 8) {
printf("Valor invalido. Tente novamente.\n");
printf("[1] Insere vertice.\n");
printf("[2] Remove vertice.\n");
printf("[3] Insere aresta.\n");
printf("[4] Remove aresta.\n");
printf("[5] Calcula distancia.\n");
printf("[6] Verifica se o grafo e conexo.\n");
printf("[7] Verifica se o grafo e consistente.\n");
printf("[8] Sai da aplicacao.\n");
scanf("%d", &option);
getchar();
}
}
escreve_grafo(output, &grafo);
destroi_grafo(&grafo);
printf("Fim da execucao da aplicacao.\n");
printf("Pressione a tecla 'enter' para encerrar.\n");
getchar();
return 0;
}
//------------------------------------------------------------------------------
int main(void) {
return ! destroi_grafo(escreve_grafo(stdout, le_grafo(stdin)));
}
//------------------------------------------------------------------------------
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;
}
