Digraph DIGRAPHconstruct (char *nomeDoArquivo) {
FILE *arq;
Digraph G;
int V;
Vertex v, w;
char ch;
int i, numeroLinhas = 4;
arq = fopen(nomeDoArquivo, "r");
printf("%s\n", nomeDoArquivo);
if ( arq != NULL) printf("ok\n");
printf("numero de linhas %d", numeroLinhas);
G = DIGRAPHinit(3);
DIGRAPHinsertA(G, 0, 1);
DIGRAPHinsertA(G, 1, 2);
DIGRAPHinsertA(G, 2, 0);
fclose(arq);
return G;
}
int main(){
int NumVert, NumArcs, i, posLine, tam, *parnt, teste;
double *cst;
char line[LINESIZE], ptr[LINESIZE], arc1[LINESIZE], arc2[LINESIZE], csts[LINESIZE];
Graph G;
teste = 0;
while ( fgets(line, LINESIZE, stdin) != NULL ) {
sscanf(line, "%s %n", ptr, &tam);
NumVert = atoi(ptr);
if ( NumVert == 0 ) break;
teste++;
posLine = tam;
sscanf(line+posLine, "%s %n", ptr, &tam);
NumArcs = atoi(ptr);
G = DIGRAPHinit(NumVert);
parnt = malloc(NumVert*sizeof(int));
cst = malloc(NumVert*sizeof(double));
for ( i = 0; i < NumArcs; i++ ) {
fgets(line, LINESIZE, stdin);
if ( sscanf(line, "%s %s %s", arc1, arc2, csts) == 3 ) {
GRAPHinsertE( G, atoi(arc1)-1, atoi(arc2)-1, atof(csts) );
}
}
GRAPHmstP2(G, parnt, cst);
printf("Teste %d\n", teste);
for ( i = G->V-1; i > 0; i-- ) {
if ( parnt[i]+1 > i+1 ) printf("%d %d\n", i+1, parnt[i]+1);
else printf("%d %d\n", parnt[i]+1, i+1);
}
}
return 0;
}
int main()
{
Digraph A = DIGRAPHinit(DIGRAPH_VALUES);
static int lbl[DIGRAPH_VALUES]; // Variavel para a busca em profundidade
DIGRAPHinsertA(A,0,0);
DIGRAPHinsertA(A,1,2);
DIGRAPHinsertA(A,2,2);
DIGRAPHinsertA(A,3,5);
DIGRAPHinsertA(A,4,5);
DIGRAPHinsertA(A,5,3);
DIGRAPHinsertA(A,4,5);
DIGRAPHshow(A);
int line,col;
for(line=0;line<6;line++)
{
printf("\n");
for(col=0;col<6;col++)
printf("%d",A->adj[line][col]);
}
printf("\n\n");
DOT_OUTPUT(A);
printf("\nResultado: %d",DIGRAPHreach(A,2,2,lbl));
return 0;
}
int main () {
Digraph d;
d = DIGRAPHinit (6);
printf ("Teste de inserção de arco: ");
DIGRAPHinsertA (d, 1, 2);
test_feedback (d->A == 1);
DIGRAPHinsertA (d, 2, 0);
DIGRAPHinsertA (d, 2, 3);
printf ("Teste de grau de saída de vértice: ");
test_feedback (DIGRAPHoutdeg (d, 2) == 2);
printf ("Teste de grau de entrada de vértice: ");
test_feedback (DIGRAPHindeg (d, 2) == 1);
DIGRAPHdestroy (d);
printf ("Teste de DIGRAPHrand1 (): ");
d = DIGRAPHrand1 (10, 5);
test_feedback (d->A == 5 && d->V == 10);
DIGRAPHdestroy (d);
printf ("Teste de DIGRAPHrand2 (): ");
d = DIGRAPHrand2 (10, 5);
test_feedback (d->A > 0 && d->V == 10);
DIGRAPHdestroy (d);
printf ("Teste de GRAPHrand1 (): ");
d = GRAPHrand1 (10, 7);
test_feedback (d->A == 14 && d->V == 10);
DIGRAPHdestroy (d);
printf ("Teste de GRAPHrand2 (): ");
d = GRAPHrand2 (10, 7);
test_feedback (d->A > 1 && d->V == 10);
DIGRAPHdestroy (d);
return 0;
}
/* REPRESENTAÇÃO POR LISTAS DE ADJACÊNCIAS: a função DIGRAPHrand2 ()
constrói um digrafo aleatório com vértices 0..V-1 e número esperado de
arcos igual a A. (As duas pontas de cada arco devem ser diferentes.) A
função supõe que V >= 2 e A <= V*(V-1). (Código inspirado no Program
17.8 de Sedgewick.) */
Digraph DIGRAPHrand2 (int V, int A) {
Vertex v, w;
double p = (double) A / V / (V-1);
Digraph G = DIGRAPHinit (V);
for (v = 0; v < V; v++)
for (w = 0; w < V; w++)
if (v != w && rand () < p * (RAND_MAX + 1.0))
DIGRAPHinsertA (G, v, w);
return G;
}
/* REPRESENTAÇÃO POR LISTAS DE ADJACÊNCIAS: A função DIGRAPHrand1 ()
constrói um digrafo aleatório com vértices 0..V-1 e exatamente A
arcos. (As duas pontas de cada arco devem ser diferentes.) A função
supõe que A <= V*(V-1). Se A for próximo de V*(V-1), a função pode
consumir muito tempo. (Código inspirado no Programa 17.7 de
Sedgewick.) */
Digraph DIGRAPHrand1 (int V, int A) {
Vertex v, w;
Digraph G = DIGRAPHinit (V);
while (G->A < A) {
v = randV (G);
w = randV (G);
if (v != w)
DIGRAPHinsertA (G, v, w);
}
return G;
}
/* REPRESENTAÇÃO POR LISTAS DE ADJACÊNCIAS: A função GRAPHrand1 ()
constrói um grafo aleatório com vértices 0..V-1 e exatamente E arestas
(As duas pontas de cada aresta devem ser diferentes.). A função
supõe que E <= V*(V-1)/2. Se E for próximo de V*(V-1)/2, a função pode
consumir muito tempo. (Código inspirado no Programa 17.7 de
Sedgewick.) */
Digraph GRAPHrand1 (int V, int E) {
Vertex v, w;
Digraph G = DIGRAPHinit (V);
while (G->A / 2 < E) {
v = randV (G);
w = randV (G);
if (v != w)
{
DIGRAPHinsertA (G, v, w);
DIGRAPHinsertA (G, w, v);
}
}
return G;
}
Digraph DIGRAPHaleatorio(int V, int A){
Vertex v, w;
Digraph G = DIGRAPHinit(V);
srand(time(NULL));
while (G->A < A) {
v = rand() % V;
w = rand() % V;
DIGRAPHinsertA( G, v, w);
}
return G;
}
int recebeDigrafoArbo( )
{
int V, v, w, linha;
Digraph G;
fscanf( stdin, "%d", &V);
G = DIGRAPHinit( V);
for (linha = 0; linha < V; linha++) {
fscanf( stdin, "%d", &v);
while (getc(stdin) != '\n') {
fscanf( stdin, "%d", &w);
DIGRAPHinsertA( G, v, w);
}
}
if (DIGRAPHarborescencia( G) == -1) printf("-1\n");
return 0;
}
/*
Digraph DIGRAPHconstruct(){
Digraph G;
FILE *arq;
int V;
Vertex v, w;
arq = fopen("dados.txt", "r");
if (arq == NULL){
printf("ERRO ao abrir\n");
system("pause");
exit(1);
}
fscanf(arq, "%d", &V);
G = DIGRAPHinit(V);
while(fscanf(arq, "%d %d", &v, &w) != EOF)
DIGRAPHinsertA(G, v, w);
fclose(arq);
return G;
}
*/
Digraph DIGRAPHaleatorio(int V, int A){
Vertex v, w;
double cst;
Digraph G = DIGRAPHinit(V);
srand(time(NULL));
while (G->A < A) {
v = rand() % V;
w = rand() % V;
cst = (double)(rand() % 100);
DIGRAPHinsertA( G, v, w, cst);
}
return G;
}
resultado Experimento(int V, double p) {
int i, j;
struct timespec M_dfs_ini, M_dfs_fim, M_bfs_ini, M_bfs_fim;
struct timespec L_dfs_ini, L_dfs_fim, L_bfs_ini, L_bfs_fim;
resultado ans;
Digraph G = DIGRAPHinit(V);
f (i, 0, V)
f (j, 0, V)
if (i != j && rand() < p*RAND_MAX)
DIGRAPHinsertA (G, i, j);
clock_gettime(CLOCK_REALTIME, &M_dfs_ini);
f (i, 0, 8)
DIGRAPHdfsM (G);
clock_gettime(CLOCK_REALTIME, &M_dfs_fim);
ans.m_dfs = diff_timespec(M_dfs_fim, M_dfs_ini);
clock_gettime(CLOCK_REALTIME, &L_dfs_ini);
f (i, 0, 8)
DIGRAPHdfsL (G);
clock_gettime(CLOCK_REALTIME, &L_dfs_fim);
ans.l_dfs = diff_timespec(L_dfs_fim, L_dfs_ini);
clock_gettime(CLOCK_REALTIME, &M_bfs_ini);
f (i, 0, V)
f(j, 0, 8)
DIGRAPHbfsM(G, i);
clock_gettime(CLOCK_REALTIME, &M_bfs_fim);
ans.m_bfs = diff_timespec(M_bfs_fim, M_bfs_ini);
clock_gettime(CLOCK_REALTIME, &L_bfs_ini);
f (i, 0, V)
f(j, 0, 8)
DIGRAPHbfsL(G, i);
clock_gettime(CLOCK_REALTIME, &L_bfs_fim);
ans.l_bfs = diff_timespec(L_bfs_fim, L_bfs_ini);
ans.arcos = G->A;
DIGRAPHfree(G);
return ans;
}
int main( int argc, char *argv[]) {
Digraph G;
int V, arc, i, c, maxC1 = 1, maxC2 = 0, *price;
Vertex *parent, x, y, s, t, t1, t2;
scanf( "%i", &V); G = DIGRAPHinit( V);
parent = malloc( G->V * sizeof( Vertex));
price = malloc( G->V * sizeof( int));
scanf( "%i", &arc); scanf( "%i %i", &s, &t);
for (i = 0; i < arc; i++) {
scanf( "%i %i %i", &t1, &t2, &c);
DIGRAPHinsertA( G, t1, t2, c);
maxC1 += c;
}
t1 = t2 = -1;
imprimecabecalho();
DIGRAPHsptD2( G, s, parent, price, -1, -1);
if (!verificaRelaxamento( G, parent, price, s)) return 0;
if(parent[t] != -1) {
maxC1 = price[t];
x = parent[t]; y = t;
while (x != y) {
DIGRAPHsptD2( G, s, parent, price, x, y);
if (!verificaRelaxamento( G, parent, price, s)) return 0;
if (price[t] > maxC2) {
maxC2 = price[t];
t1 = x; t2 = y;
}
y = x; x = parent[x];
}
printf( "priceancia de %i a %i sem remocao de arcos: %i\n", s, t, maxC1);
if (maxC2 != 0) {
printf( "Arco removido, cuja nova priceancia ");
printf( "%i a %i e' maxima: %i-%i\n", s, t, t1, t2);
printf( "Nova priceancia: %i\n", maxC2);
}
else printf("Nao se pode remover nenhum arco.\n");
}
else printf("Nao existe caminho de %i a %i.\n", s, t);
free( parent);
free( price);
return 0;
}
Digraph DIGRAPHconstruct(){
Digraph G;
FILE *arq;
int V;
Vertex v, w;
arq = fopen("dados.txt", "r");
if (arq == NULL){
printf("ERRO ao abrir\n");
system("pause");
exit(1);
}
fscanf(arq, "%d", &V);
G = DIGRAPHinit(V);
while(fscanf(arq, "%d %d", &v, &w) != EOF)
DIGRAPHinsertA(G, v, w);
fclose(arq);
return G;
}
int main(int argc, char *argv[]){
int i;
Digraph G = DIGRAPHinit(5);
if(argc>1){
for(i=0; i<argc; i++)
printf("%s ", argv[i]);
printf("\n");
}
DIGRAPHinsert(G,0,1);
DIGRAPHinsert(G,0,3);
DIGRAPHinsert(G,2,4);
DIGRAPHinsert(G,4,1);
GRAPHinsert(G,2,3);
DIGRAPHshow(G);
/*
DIGRAPHremove(G,0,1);
DIGRAPHremove(G,0,3);
DIGRAPHremove(G,0,4);
DIGRAPHremove(G,2,1);
DIGRAPHremove(G,4,2);
DIGRAPHremove(G,3,4);
DIGRAPHshow(G);
printf("\n");
GRAPHremove(G,2,3);
GRAPHremove(G,1,4);
DIGRAPHshow(G);
*/
if(DIGRAPHpath(G,0,4))
printf("Existe caminho de 0 --> 4\n");
else
printf("Não existe caminho de 0 --> 4\n");
if(DIGRAPHpath(G,1,4))
printf("Existe caminho de 1 --> 4\n");
else
printf("Não existe caminho de 1 --> 4\n");
printf("\n");
GRAPHinsert(G,1,3);
DIGRAPHshow(G);
if(DIGRAPHpath(G,1,4))
printf("Existe caminho de 1 --> 4\n");
else
printf("Não existe caminho de 1 --> 4\n");
if(DIGRAPHcycle(G))
printf("Existe ciclo em G\n");
else
printf("Não existe ciclo em G\n");
printf("\n");
printf("\n");
DIGRAPHremove(G,3,1);
DIGRAPHremove(G,3,2);
DIGRAPHshow(G);
if(DIGRAPHcycle(G))
printf("Existe ciclo em G\n");
else
printf("Não existe ciclo em G\n");
printf("\n");
return 0;
}
