int main(void)
{
	int node_num, edge_num;
	struct Matrix_Graph mat_graph;
	struct Point_Graph poi_graph;

	while (scanf("%d %d", &node_num, &edge_num) != EOF) {
		initGraph(&mat_graph, &poi_graph, node_num);
		input(&mat_graph, &poi_graph, edge_num);
		printf("matrix multiplication:\n");
		matrix_mult(&mat_graph);
		output(&mat_graph);
		clearChoose(&mat_graph, &poi_graph);

		printf("floyd warshall:\n");
		floyd_warshall(&mat_graph);
		output(&mat_graph);
		clearChoose(&mat_graph, &poi_graph);

		printf("johnson:\n");
		johnson(&mat_graph, &poi_graph);
		output(&mat_graph);
		
		clearEdge(&poi_graph);
	}
	
	return 0;
}
Exemple #2
0
int main() {
    while( scanf("%d %d", &n, &m) == 2 && m != 0 && n != 0 ) {
        for( int i = 0; i < n; i++ )
            for( int j = 0; j < n; j++ )
                c[i][j] = INF;
        for( int i = 0; i < n; i++ )
            c[i][i] = 0;

        for( int i = 0; i < m; i++ ) {
            int a, b, d;
            scanf( "%d %d %d", &a, &b, &d );
            c[a][b] = d;
            c[b][a] = d;
        }
        int k;
        scanf( "%d", &k );
        for( int i = 0; i < k; i++ ) {
            int a, b;
            scanf( "%d %d", &a, &b );
            c[a][b] = INF;
            c[b][a] = INF;
        }
        floyd_warshall();
        int q;
        scanf( "%d", &q );
        for( int i = 0; i < q; i++ ) {
            int a, b;
            scanf( "%d %d", &a, &b );
            printf( "%d\n", c[a][b] == INF ? -1 : c[a][b] );
        }
    }
    return 0;
}
Exemple #3
0
int main() {
	int graph[V][V] = {
		{0, 5, INF, 10},
		{INF, 0, 3, INF},
		{INF, INF, 0, 1},
		{INF, INF, INF, 0},
	};
	floyd_warshall(graph);
	return 0;
}
int main(int argc, char *argv[]) {
    FILE *fin = fopen("dist.txt", "r");
    fscanf(fin, "%d", &n);
    int i, j;
    for (i = 0; i < n; ++i)
        for (j = 0; j < n; ++j)
            fscanf(fin, "%d", &dist[i][j]);
    fclose(fin);
 
    floyd_warshall();
 
    return 0;
}
int main( ) {
    int dist[n][n] = { 
        {0, 3, 10},
        {3, 0, 1000},
        {10, 1000, 0}
    };

    floyd_warshall(dist);
    
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            std::cout << "Menor distancia de " << i << " para " << j << ": " 
                    << dist[i][j] << "\n";
    return 0;
}
int main()
{
	struct timer tm ;
	init_timer(&tm) ;

	start_timer(&tm) ;
	int i ;
	for(i=0 ; i<NUM_ITER ; i++)
		floyd_warshall(path1) ;
	stop_timer(&tm) ; 

	print_time(&tm) ;


	return 0 ;
}
Exemple #7
0
int main() {
  int cases;
 
  int N;  // city number
  int R;  // road number
  int C1, C2;  // the number of city
  int P;  // Path
 
  int S;  // start city
  int E;  // destination city
  int T;  // the numer of visitors
 
  int i, j;
 
  int matrix[MAX][MAX];
 
  int res;
 
  scanf("%d", &cases);
 
  while(cases--) {
    scanf("%d %d", &N, &R);
 
    for(i = 0 ; i < N; i++)
      for(j = 0; j < N; j++)
    matrix[i][j] = 0;
 
    for(i = 0; i < R; i++) {
      scanf("%d %d %d", &C1, &C2, &P);
      matrix[C1-1][C2-1] = matrix[C2-1][C1-1] = P;
    }
 
    scanf("%d %d %d", &S, &E, &T);
 
    res  = floyd_warshall(matrix, N, S-1, E-1);
 
    printf("%d\n", T/(res-1) + (T % (res - 1) ? 1 : 0));
  }
 
  return 0;
}                                 
int main()
{
	struct timer tm ;
	init_timer(&tm) ;

	pthread_barrier_init(&barrier,NULL,2);

	start_timer(&tm) ;
	p_floyd_warshall(path2) ;
	stop_timer(&tm) ; 

	print_time(&tm) ;

	floyd_warshall(path1) ;
	if(verify(path1, path2))
		printf("VERIFICATION PASS\n") ;
	else
		printf("VERIFICATION FAILED\n") ;

	return 0 ;
}
Exemple #9
0
graph_info *graph_info_from_nauty(graph *g, int n)
{
    graph_info *ret = malloc(sizeof(graph_info));
    ret->n = n;
    ret->distances = malloc(n * n * sizeof(*ret->distances));
    ret->k = malloc(n * sizeof(*ret->k));

    int m = (n + WORDSIZE - 1) / WORDSIZE;
    ret->m = 0; //total number of edges
    for (int i = 0; i < n; i++) {
        ret->k[i] = 0;
        for (int j = 0; j < n; j++) {
            if(i == j)
                ret->distances[n*i + j] = 0;
            else if(ISELEMENT(GRAPHROW(g, i, m), j))
            {
                ret->distances[n*i + j] = 1;
                ret->k[i]++;
                ret->m++;
            }
            else
                ret->distances[n*i + j] = GRAPH_INFINITY;
        }
    }
    ret->m /= 2;

    ret->max_k = 0;
    for (int i = 0; i < n; i++)
        if (ret->k[i] > ret->max_k)
            ret->max_k = ret->k[i];

    floyd_warshall(*ret);
    ret->sum_of_distances = calc_sum(*ret);
    ret->diameter = calc_diameter(*ret);
    ret->nauty_graph = malloc(n * m * sizeof(graph));
    ret->gcan = NULL;
    memcpy(ret->nauty_graph, g, n * m * sizeof(graph));

    return ret;
}
Exemple #10
0
void prepare()
{
	for (int i = 0; i < 64; ++i)
		for (int j = 0; j < 64; ++j)
			g[i][j] = INF;

	for (int i = 0; i < 8; ++i)
		for (int j = 0; j < 8; ++j) {
			g[Pos(i, j)][Pos(i, j)] = 0;

			for (int k = 0; k < 8; ++k) {
				int ti = i + moves[k][0];
				int tj = j + moves[k][1];
				if (! valid_pos(ti, tj)) continue;

				g[Pos(i, j)][Pos(ti, tj)] = 1;
			}

		}

	floyd_warshall();
}
Exemple #11
0
int main() {
    int a, b, c = 1, cc = 0;

    clear_graph();

    while (std::cin >> a >> b) {
        if (!(a | b)) {
            if (cc == 0) {
                break;
            }
            floyd_warshall();
            double ans = avg_calc();
            cc = 0;
            printf("Case %i: average length between pages = %.3f clicks\n", c++, ans);
            // Clear Graphs
            clear_graph();
        } else {
            cc++;
            graph[a].push_back(b);
        }
    }

    return 0;
}
int main(int argc, char **argv) {

 
  int rank, M, j,i, *d_graph;
  int *local_matrix, *row_matrix, *col_matrix, *res_matrix, *rowIds, *colIds;
  int P, N, q, p_row, p_col;
  double start, finish;
  MPI_Status status;
 
  MPI_Init(&argc, &argv);
  MPI_Comm_size(MPI_COMM_WORLD, &P);
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);

  //INPUT HANDLED BY THE ROOT PROCESSOR
  if (rank == ROOT){
    scanf("%d", &N);  
    q = check_fox_conditions(P,N);

    //Check's if the fox's conditions are met
    if(q == 0){
      MPI_Abort(MPI_COMM_WORLD, 0);
      return 1; //error
    }  

    d_graph = (int*)malloc((N*N) * sizeof(int));

    for(i=0; i < N; i++){
      for(j=0; j < N; j++){
	scanf("%d", &d_graph[GET_MTRX_POS(i,j,N)]);
	if (d_graph[GET_MTRX_POS(i,j,N)] == 0 && i != j) {
	  d_graph[GET_MTRX_POS(i,j,N)] = INF;
	}
      }
    }



    MPI_Bcast(&q, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&N, 1, MPI_INT, 0, MPI_COMM_WORLD);

    if(q > 1)
      divide_matrix( d_graph, N, q); 
      
  }
  else{
    MPI_Bcast(&q, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&N, 1, MPI_INT, 0, MPI_COMM_WORLD);
  }
  //---------------COMMON------------------
   
  int lngth = N / q;


  local_matrix = (int*)malloc((lngth*lngth) * sizeof(int));
  row_matrix   = (int*)malloc((lngth*lngth) * sizeof(int));
  col_matrix   = (int*)malloc((lngth*lngth) * sizeof(int));
  res_matrix   = (int*)malloc((lngth*lngth) * sizeof(int));
  
  if(q>1)
    chnkd_MPI_Recv(local_matrix, lngth*lngth, MPI_INT, 0);
  else
    local_matrix = d_graph;
    
  p_row = ( rank / q );
  p_col = ( rank % q );
    
  //CREATE COMMUNICATORS 
  MPI_Group MPI_GROUP_WORLD;
  MPI_Comm_group(MPI_COMM_WORLD, &MPI_GROUP_WORLD);
  MPI_Group row_group, col_group;
  MPI_Comm row_comm, col_comm, grid_comm;
  int tmp_row, tmp_col, proc;
  int row_process_ranks[q], col_process_ranks[q];
    
  for(proc = 0; proc < q; proc++){   
    row_process_ranks[proc] = (p_row * q) + proc;
    col_process_ranks[proc] = ((p_col + proc*q) %(q*q));
  }    
  radixsort(col_process_ranks, q);
  radixsort(row_process_ranks, q);

  MPI_Group_incl(MPI_GROUP_WORLD, q, row_process_ranks, &row_group);  
  MPI_Group_incl(MPI_GROUP_WORLD, q, col_process_ranks, &col_group);  
     
  MPI_Comm_create(MPI_COMM_WORLD, row_group, &row_comm);  
  MPI_Comm_create(MPI_COMM_WORLD, col_group, &col_comm);  

  if ((rank / q) == (rank % q)) {
      memcpy(row_matrix, local_matrix, (lngth*lngth) * sizeof(int));
  }
  int ln,d,flag;
  int step, rotation_src, rotation_dest, src;
  int count = 0;
  memcpy(res_matrix, local_matrix, (lngth*lngth) * sizeof(int));
  rotation_src = (p_row + 1) % q;
  rotation_dest = ((p_row - 1) + q) % q;
  ln = (lngth*q) << 1;
  start = MPI_Wtime();  

  for (d = 2; d < ln; d = d << 1) {
    memcpy(col_matrix, local_matrix, (lngth*lngth) * sizeof(int));
    for ( step = 0;  step < q;  step++) {
      src = (p_row +  step) % q;
      count++;
      if (src == p_col) {
	MPI_Bcast(local_matrix, lngth*lngth, MPI_INT, src, row_comm);
	floyd_warshall( local_matrix, col_matrix, res_matrix, lngth);
      } else {
	MPI_Bcast(row_matrix, lngth*lngth, MPI_INT, src, row_comm);
	floyd_warshall( row_matrix, col_matrix, res_matrix, lngth);
      }  
      if( step < q-1) 
        MPI_Sendrecv_replace(col_matrix, lngth*lngth, MPI_INT, rotation_dest, STD_TAG,rotation_src, STD_TAG, col_comm, MPI_STATUS_IGNORE);
  	
    }
    memcpy(local_matrix, res_matrix, (lngth*lngth) * sizeof(int));
  }
  
  
  int *sol;
  sol = malloc(N*N*sizeof(int));  
  
  MPI_Gather(res_matrix, lngth*lngth, MPI_INT, sol,  lngth*lngth, MPI_INT, 0, MPI_COMM_WORLD);
  
  if (rank == 0) {
    finish = MPI_Wtime();
    printf("Tempo de execução %f\n",finish - start);
  }
 
  if (rank == 0) {
    int row, col, pos_x, pos_y, pos, tmp_y, tmp_x;

    for (i = 0; i < P; i++) {
      pos_x = i / q;
      pos_y = i % q;
      pos = i * lngth*lngth;

      for (row = 0; row < lngth; row++) {
	for (col = 0; col < lngth; col++) {
          tmp_x = GET_MTRX_POS(pos_x,row,lngth);
          tmp_y = GET_MTRX_POS(pos_y,col,lngth);
          
	  if (sol[GET_MTRX_POS(row,col,lngth) + pos] == INF)
	    d_graph[GET_MTRX_POS(tmp_x,tmp_y,N)] = 0;
	  else
	    d_graph[GET_MTRX_POS(tmp_x,tmp_y,N)] = sol[GET_MTRX_POS(row,col,lngth) + pos];
	}
      }
    }
    prints_matrix(d_graph,N);
  }
  
  MPI_Finalize();
  return 0;
}
Exemple #13
0
    /*
    	Formulates the minimum path problem
    	as a minimum cost flow. Validate the
    	found solution comparing it to Floyd-Warshall.

    	The instances are random graphs with at most
    	50 vertex and at most 25 * 50 non-parallel edges
    */
    void test_minimum_path(int nv, int ne)
    {
        srand(time(NULL));

        // random number of vertexs
        //int n = rand()%100 + 2;
        int n = nv;
        Graph_Mean grafo_mean(n);
        Graph_Cycle grafo_cycle(n);

        // random number of edges
        //int m = rand()%(n/2 * n);
        int m = ne;

        // force the graph to have a path
        // between 0 and n - 1
        //grafo_mean.set_edge(0, n - 1, 1000 * 1000, 1);
        //grafo_cycle.set_edge(0, n - 1, 1000 * 1000, 1);


        // generate the remaining edges randomly
        for (int i = 0; i < m - 1; ++i)
        {
            int u, v, c;
            // generate a new edge, check if it or its inverse were
            // already generated. Parallel edges are not allowed.
            do
            {
                u = rand()%n;
                v = rand()%n;
                ca = (rand() + 1) %100000; // no zero capacity
                co = (rand() + 1) %100000; // no zero cost
            } while (grafo_mean.is_edge_set(u, v) || grafo_mean.is_edge_set(v, u));

            grafo_mean.set_edge(u, v, co, ca);
            grafo_cycle.set_edge(u, v, co, ca);

            mp_graph[u][v] = 1;
            mp_cost[u][v] = c;
        }

        grafo_mean.set_inbalance(0, 1);
        grafo_cycle.set_inbalance(0, 1);

        grafo_mean.set_inbalance(n-1, -1);
        grafo_cycle.set_inbalance(n-1, -1);

        int expected_value = floyd_warshall(0, n - 1, mp_graph, mp_cost);

        // Mean
        time_t tstart, tend;
        time(&tstart);
        assert(grafo_mean.min_cost_flow() == MCF_SUCCESS);

        //assert(grafo.is_valid_flow());
        int value = grafo_mean.calc_flow_cost();
        time(&tend);
        total_time_mean += difftime(tend, tstart);
        assert(value == expected_value);

        // Cycle
        time(&tstart);
        assert(grafo_cycle.min_cost_flow() == MCF_SUCCESS);

        //assert(grafo.is_valid_flow());
        value = grafo_cycle.calc_flow_cost();
        time(&tend);
        total_time_cycle += difftime(tend, tstart);
        assert(value == expected_value);

        cerr<< "test_minimum_path: SUCCESS!"<<'\n';
    }
int main(int argc, char **argv){
    int num_vertices = 0;
    int num_edges = 0;
    int i;                  // counter to loop through parameters
    int print = 0;          // print resulting adjacency matrix?
    int oriented = 0;       // whether or not the random matrix is oriented
    int **matrix;           // adjacency matrix
    int **parent_matrix;    // matrix used to restore paths
    int num_bad_edges = 0;  // number of bad edges in file
    int total_distance;
    int diameter;
    char filename[100];     // filename if given as param

    struct timeval start, end;
    double time;


    // print usage
    usage();

    // read params
    for(i=1; i<argc; i++){
        if(strcmp(argv[i], "-print") == 0){
            print = 1;
        } else if(strcmp(argv[i], "-read") == 0){
            // assume filename is not longer than 100 chars
            strcpy(filename, argv[++i]);
        } else if(strcmp(argv[i], "-random") == 0){
            num_vertices = atoi(argv[++i]);
            oriented = atoi(argv[++i]);
        } else {
            num_vertices = 4000;
            oriented = 1;
        }
    }

    if(num_vertices > 0){
        // init random adjacency matrix for testing
        total_distance = init_random_adjacency_matrix(num_vertices, &num_edges, &matrix, &parent_matrix, oriented);
    } else {
        // generate adjacency matrix from file
        total_distance = read_adjacency_matrix(filename, &num_vertices, &num_edges, &matrix, &parent_matrix, &oriented, &num_bad_edges);
    }

    fprintf(stderr, "Running ASP with %d rows and %d edges (%d are bad)\n", num_vertices, num_edges, num_bad_edges);

    if(gettimeofday(&start, 0) != 0){
        fprintf(stderr, "Error starting timer\n");
        exit(EXIT_FAILURE);
    }

    floyd_warshall(matrix, parent_matrix, num_vertices);

    diameter = calculate_diameter(matrix, num_vertices);

    if(gettimeofday(&end, 0) != 0){
        fprintf(stderr, "Error stopping timer\n");
        exit(EXIT_FAILURE);
    }

    time = (end.tv_sec + end.tv_usec / 1000000.0) -
            (start.tv_sec + start.tv_usec / 1000000.0);


    fprintf(stderr, "Total distance: %d\n", total_distance);
    fprintf(stderr, "Diameter: %d\n", diameter);
    fprintf(stderr, "ASP took %10.3f seconds\n", time);

    if(print){
        print_paths(matrix, parent_matrix, num_vertices);
    }

    free_matrix(matrix, num_vertices);
    free_matrix(parent_matrix, num_vertices);

    return 0;
}
Exemple #15
0
int main(){
  int n,cont,e,i,j;
  scanf("%d",&n);
  while(n!=0){
    for(i=1;i<=n;i++){
      for(j=1;j<=n;j++)
	graph[i][j]=INF;
      graph[i][i]=0;
    }
    for(i=1;i<=n;i++){
      scanf("%d",&cont);
      for(j=1;j<=cont;j++){
	scanf("%d",&e);
	if(e==0) break;
	scanf("%d",&graph[i][e]);
      }
    }
    for(i=1;i<=n;i++)
      for(j=1;j<=n;j++)
	dis[i][j]=graph[i][j];
    floyd_warshall(n);
    int max;
    for(i=1;i<=n;i++){
      max=dis[i][1];
      for(j=1;j<=n;j++){
	if(dis[i][j]!=max && dis[i][j]>max)
	  max=dis[i][j];
      }
      res[i]=max;
    }
    int min = INF,pos=1;
    for(i=1;i<=n;i++)
      if(res[i]<min)
	{min = res[i];pos = i;}
    if(min==INF)
      printf("disjoint\n");
    else
      printf("%d %d\n",pos,min);
    scanf("%d",&n);
  }
  /* for(i=1;i<=n;i++){ */
  /*   for(j=1;j<=n;j++){ */
  /*     if(graph[i][j]==INF) */
  /* 	printf("%5s","INF"); */
  /*     else */
  /* 	printf("%5d",graph[i][j]); */
  /*   } */
  /*   printf("\n"); */
  /* } */
  /* printf("\n"); */
  /* for(i=1;i<=n;i++){ */
  /*   for(j=1;j<=n;j++){ */
  /*     if(dis[i][j]==INF) */
  /* 	printf("%5s","INF"); */
  /*     else */
  /* 	printf("%5d",dis[i][j]); */
  /*   } */
  /*   printf("\n"); */
  /* } */
  return 0;
}
int
main(void) {
  floyd_warshall();
  return 0;
}
Exemple #17
0
int main( int argc, char **argv )
{    
    //Declaring variables
    double floyd_time, di_time;

    /*
     *Handling user input.
     */
    if( find_option( argc, argv, "-h" ) >= 0 )
    {
        printf( "Options:\n" );
        printf( "-h to see this help\n" );
        printf( "-n <int> to set the number of vertices\n" );
        printf( "-no turns off all correctness checks\n");
        printf( "-csv outputs in csv format (n, floyd_time, di_time)\n");
        return 0;
    } 
    int n = read_int( argc, argv, "-n", 100 );

    /*
     * Setting up the data structures
     * All data structures are assumed to be row major.
     */

    // An n*n matrix, where the element in the ith row and jth column
    // represents the weight of the edge from vertex i to j.
    float *graph = (float*) malloc( n * n * sizeof(float));
    
    // An n*n matrix, where the element in the ith row and jth column
    // represents the second vertex on the shortest path from u -> v
    int *p = (int*) malloc(n * n * sizeof(int));

    // An n*n matrix, where the element in the ith row and jth column
    // represents the penultimate vertex on the shortest path from u -> v
    int *q = (int*) malloc(n * n * sizeof(int));

    // An n*n matrix, where the element in the ith row and jth column
    // is a list of vertices w for which w -> u -Shortest-Path-> v
    // is known to be a shortest path
    std::vector<int> *L = new std::vector<int>[n*n];
    
    // An n*n matrix, where the element in the ith row and jth column
    // is a list of vertices w for which u -Shortest-Path-> v -> w
    // is known to be a shortest path
    std::vector<int> *R = new std::vector<int>[n*n];

    // An n*n+1 matrix, where each element holds a list of vertex pairs.
    // This is the core data structure for our bucket based heap.
    std::list<int> *bucket_heap = new std::list<int>[n*n + 1];

    // An n*n matrix, where the element in the ith row and jth column
    // is the iterator/pointer to the linked list element holding
    // the vertex pair (i,j) in bucket_heap.
    std::list<int>::iterator *iters = new std::list<int>::iterator[n*n];
    
    // An n*n matrix, where the element in the ith row and jth column
    // is the index of the bucket that holds the vertex pair (i,j) in bucket_heap.
    int *b_num = (int*) malloc(n * n * sizeof(int));
    
    // Parent and dist arrays for floyd warshall
    float *fw_dist = (float*) malloc( n * n * sizeof(float));
    int *fw_par = (int*) malloc( n * n * sizeof(int));

    // Dist array for DI
    float *di_dist = (float*) malloc( n * n * sizeof(float));
 
    /*
     * Initializing values.
     */

    srand48(1337);
    // We set a minimum value to avoid the overflow bucket scenario.
    float min_allowable_value = (1.0/(n*n));
    
    // Initialize every edge to have a weight between min_allowable_value  and 1.
    for (int i = 0; i < n * n; i++) {
        float temp;
        //no edge between an edge and itself.
        if (i%n == i/n) {
            graph[i] = INF;
        } else {
            temp = (float)drand48();
            if (temp < min_allowable_value) temp += min_allowable_value;
            if (temp < min_edge) min_edge = temp;
            graph[i] = temp;
        }
    }
   
    //Initialize dist arrays.
    for (int i = 0; i < n*n; i++) {
        fw_dist[i] = graph[i];
        di_dist[i] = graph[i];
        b_num[i] = 0;
    }

    /*
     * Executing and timing algorithms
     */
    
    // Running Demetrescu Italiano.
    di_time = read_timer();
    di_apsp(n, di_dist, graph, p, q, L, R, bucket_heap, b_num, iters);
    di_time = read_timer() - di_time;

    //Running Floyd Warshall as a standard implementation.
    floyd_time = read_timer();
    floyd_warshall(n, fw_par, fw_dist);
    floyd_time = read_timer() - floyd_time;

    /*
     * Validating DI results against reference Floyd Warshall
     */

    if( find_option( argc, argv, "-no" ) == -1 ) {
        
        //Report a failure if anything varies by more than 0.0001
        for (int i = 0; i < n*n; i++) {
            if ((di_dist[i] - fw_dist[i] > 0.0001) || (fw_dist[i] - di_dist[i] > 0.0001) ) {
                printf("\n\nFAILURE at %d\n\n", i);
                break;
            }
        }

        //Print out matrices if n is small enough.
        if (n < 10) {

            printf("\n---Our Graph---\n");
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    printf("%.4f\t", graph[i*n + j]);
                }
                printf("\n");
            }
            printf("\n");
     
            printf("\n---Floyd Warshall Dist---\n");
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    printf("%.4f\t", fw_dist[i*n + j]);
                }
                printf("\n");
            }
            printf("\n");
            printf("\n---Floyd Warshall Par---\n");
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    printf("%d\t", fw_par[i*n + j]);
                }
                printf("\n");
            }
            printf("\n");

            printf("\n---Demetrescu Italiano Dist---\n");
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    printf("%.4f\t", di_dist[i*n + j]);
                }
                printf("\n");
            }
            printf("\n");
        }

    }

    /*
     * Print out results
     */

    if( find_option( argc, argv, "-csv" ) == -1 ) {
        printf("\nTimes:\n");
        printf("Floyd Warshall: %f\n", floyd_time);
        printf("Demetrescu Italiano: %f\n", di_time);
    } else {
        printf("%d\t%f\t%f\n", n, floyd_time, di_time);
    }

    /*
     * Free up manually allocated memory.
     */

    free(graph);
    free(fw_dist);
    free(fw_par);
    free(di_dist);
    free(p);
    free(q);
    free(b_num);
    
    return 0;
}