void test_graph_search_sccs() { GRAPH* graph = graph_create(); graph_add_edge(graph, 6, 0); graph_add_edge(graph, 3, 6); graph_add_edge(graph, 0, 3); graph_add_edge(graph, 8, 6); graph_add_edge(graph, 5, 8); graph_add_edge(graph, 2, 5); graph_add_edge(graph, 8, 2); graph_add_edge(graph, 7, 5); graph_add_edge(graph, 1, 7); graph_add_edge(graph, 4, 1); graph_add_edge(graph, 7, 4); GRAPH* reverse = graph_reverse(graph); GRAPH_SEARCH* graph_search1 = graph_search_create(reverse); graph_search_finish_times(reverse, graph_search1); graph_destroy(reverse); GRAPH_SEARCH* graph_search2 = graph_search_create(graph); graph_search_sccs(graph, graph_search2, graph_search1->finish_times); graph_search_destroy(graph_search1); graph_search_destroy(graph_search2); graph_destroy(graph); }
graph_t *graph_new_dims(graph_type_t type, uint32_t m, uint32_t n, size_t nnz, bool fixed_rows) { graph_t *graph = malloc(sizeof(graph_t)); graph->m = m; graph->fixed_rows = fixed_rows; graph->n = n; graph->type = type; graph->indptr = uint32_array_new_size(m + 1); if (graph->indptr == NULL) { graph_destroy(graph); return NULL; } if (!fixed_rows) { uint32_array_push(graph->indptr, 0); } if (nnz > 0) { graph->indices = uint32_array_new_size(nnz); } else { graph->indices = uint32_array_new(); } if (graph->indices == NULL) { graph_destroy(graph); return NULL; } return graph; }
int main() { srandom(time(0)); graph_t a; vector_int v1; vector_int_init_value_end(&v1, -1, 1,5, 2,5, 1,2, 2,1, 0,3, 0,2, 3,4, 3,6, 4,6, 6,4, -1,7, -1); new_graph(&a, &v1, 0, GRAPH_DIRECTED); print_graph_vectors(&a, stdout); printf("ec=%d\t",graph_edges_count(&a)); printf("vc=%d\n",graph_vertices_count(&a)); int vc = graph_vertices_count(&a); vector_int mem; vector_int_init(&mem, vc); vector_int_fill(&mem, -1); vector_int cs; vector_int_init(&cs, 0); int cc; graph_clusters_strong(&a,&mem,&cs,&cc); printf("mem:"); print_vector_int(&mem, stdout); printf("<<<combine vertices\n"); graph_t b; graph_combine_vertices(&a, &mem, &b); print_graph_vectors(&b, stdout); printf("ec=%d\t",graph_edges_count(&b)); printf("vc=%d\n",graph_vertices_count(&b)); double re; printf(">>>>randomly attack\n"); re = graph_fault_propagation(&b, 0.3, 0.2, GRAPH_ATK_RANDOM); printf("random re=%f\n",re); printf(">>>>outgoing based attack\n"); re = graph_fault_propagation(&b, 0.3, 0.2, GRAPH_ATK_OUTGOING); printf("outgoing re=%f\n",re); printf(">>>>incoming based attack\n"); re = graph_fault_propagation(&b, 0.3, 0.2, GRAPH_ATK_INCOMING); printf("incoming re=%f\n",re); vector_int inf; vector_int_init(&inf, 0); int cascading_nodes_count = graph_cascading_nodes_count(&b, &inf, 0.3, 0.2, GRAPH_ATK_RANDOM); assert(cascading_nodes_count == vector_int_sum(&inf)); vector_int_destroy(&inf); vector_int_destroy(&mem); vector_int_destroy(&cs); vector_int_destroy(&v1); graph_destroy(&b); graph_destroy(&a); return 0; }
int main(void) { /* read graph from stdin */ graph_t graph = graph_from_file(stdin); assert(graph != NULL); /* run kruskal */ graph_t mst = kruskal(graph); /* dump graph */ graph_dump(mst, stdout); /* dump total weight */ printf("\n# MST : %u\n", mst_total_weight(mst)); /* destroy both graphs */ graph = graph_destroy(graph); mst = graph_destroy(mst); }
graph_t *graph_read(FILE *f) { graph_t *g = malloc(sizeof(graph_t)); if (g == NULL) return NULL; g->indptr = NULL; g->indices = NULL; if (!file_read_uint32(f, &g->m) || !file_read_uint32(f, &g->n) || !file_read_uint8(f, (uint8_t *)&g->fixed_rows)) { goto exit_graph_allocated; } uint64_t len_indptr; if (!file_read_uint64(f, &len_indptr)) { goto exit_graph_allocated; } uint32_array *indptr = uint32_array_new_size(len_indptr); if (indptr == NULL) { goto exit_graph_allocated; } for (int i = 0; i < len_indptr; i++) { if (!file_read_uint32(f, indptr->a + i)) { goto exit_graph_allocated; } } indptr->n = (size_t)len_indptr; g->indptr = indptr; uint64_t len_indices; if (!file_read_uint64(f, &len_indices)) { goto exit_graph_allocated; } uint32_array *indices = uint32_array_new_size(len_indices); if (indices == NULL) { goto exit_graph_allocated; } for (int i = 0; i < len_indices; i++) { if (!file_read_uint32(f, indices->a + i)) { goto exit_graph_allocated; } } indices->n = (size_t)len_indices; g->indices = indices; return g; exit_graph_allocated: graph_destroy(g); return NULL; }
int main(int argc, char **args) { s_graph graph; graph_init(&graph, 5); for (int i = 0; i < 5; i++) { graph_set_vertex(&graph, i, i); } graph_set_arccell(&graph, 0, 1, 15); graph_set_arccell(&graph, 1, 4, 71); graph_set_arccell(&graph, 1, 3, 23); graph_set_arccell(&graph, 3, 4, 42); graph_set_arccell(&graph, 2, 4, 36); graph_set_arccell(&graph, 2, 0, 27); graph_set_arccell(&graph, 3, 3, 61); graph_set_arccell(&graph, 2, 1, 92); graph_display(&graph); graph_destroy(&graph); return 0; }
int main(int argc, char **args) { s_graph graph; graph_init(&graph, 6); for (int i = 0; i < 6; i++) { graph_set_vertex(&graph, i, i); } graph_set_arccell(&graph, 0, 2, 10); graph_set_arccell(&graph, 0, 4, 30); graph_set_arccell(&graph, 0, 5, 100); graph_set_arccell(&graph, 1, 2, 5); graph_set_arccell(&graph, 2, 3, 50); graph_set_arccell(&graph, 3, 5, 10); graph_set_arccell(&graph, 4, 3, 20); graph_set_arccell(&graph, 4, 5, 60); graph_display(&graph); graph_shortest_path(&graph); graph_destroy(&graph); return 0; }
void test_graph_search_finish_times() { GRAPH* graph = graph_create(); graph_add_edge(graph, 0, 6); graph_add_edge(graph, 6, 3); graph_add_edge(graph, 3, 0); graph_add_edge(graph, 6, 8); graph_add_edge(graph, 8, 5); graph_add_edge(graph, 5, 2); graph_add_edge(graph, 2, 8); graph_add_edge(graph, 5, 7); graph_add_edge(graph, 7, 1); graph_add_edge(graph, 1, 4); graph_add_edge(graph, 4, 7); GRAPH_SEARCH* graph_search = graph_search_create(graph); graph_search_finish_times(graph, graph_search); assert(6 == graph_search->finish_times[0]); assert(3 == graph_search->finish_times[1]); assert(0 == graph_search->finish_times[2]); assert(8 == graph_search->finish_times[3]); assert(5 == graph_search->finish_times[4]); assert(7 == graph_search->finish_times[5]); assert(1 == graph_search->finish_times[6]); assert(4 == graph_search->finish_times[7]); assert(2 == graph_search->finish_times[8]); graph_destroy(graph); graph_search_destroy(graph_search); }
int g_main(int argc, char ** argv) { graph_t * g = adj_list_read<vex_t, weight_t>(cin, DINET); cout << g << endl; floyd(g); graph_destroy(g); return 0; }
int g_main(int argc, char ** argv) { graph_t * g = adj_list_read<char>(cin, UNDIGRAPH); cout << g << endl; cout << "dfs: " << endl; dfs(g); graph_destroy(g); return 0; }
int g_main(int argc, char ** argv) { graph_t * g = adj_list_read<char,weight_t>(cin, UNDINET); cout << g << endl; kruskal(g); graph_destroy(g); return 0; }
int main () { int i, data; int v_id[V_COUNT]; DfsVertex *dfs_vs[V_COUNT]; Graph graph; DfsVertex *dfs_vertex; List ordered; ListElmt *element; graph_init (&graph, &match, NULL); for (i = 0; i < V_COUNT; i++) { v_id[i] = i; if ((dfs_vertex = (DfsVertex *) malloc (sizeof(DfsVertex))) == NULL) return -1; dfs_vertex->data = &v_id[i]; dfs_vertex->color = white; dfs_vs[i] = dfs_vertex; graph_ins_vertex (&graph, (void *) dfs_vertex); /* printf ("vertex[%d] addr=%d\n", i, (void *) &vertex[i]); */ } printf ("graph vcount=%d\n", graph_vcount (&graph)); /* Graph as in figure 11.8 Network hops. */ /* graph_ins_edge (&graph, (void *) dfs_vs[0], (void *) dfs_vs[1]); */ graph_ins_edge (&graph, (void *) dfs_vs[0], (void *) dfs_vs[2]); graph_ins_edge (&graph, (void *) dfs_vs[2], (void *) dfs_vs[1]); graph_ins_edge (&graph, (void *) dfs_vs[1], (void *) dfs_vs[3]); /* graph_ins_edge (&graph, (void *) dfs_vs[2], (void *) dfs_vs[4]); */ graph_ins_edge (&graph, (void *) dfs_vs[3], (void *) dfs_vs[4]); graph_ins_edge (&graph, (void *) dfs_vs[4], (void *) dfs_vs[5]); graph_ins_edge (&graph, (void *) dfs_vs[1], (void *) dfs_vs[6]); printf ("graph ecount=%d\n", graph_ecount (&graph)); dfs (&graph, &ordered); printf ("size of ordered list=%d\n", list_size (&ordered)); for (element = list_head (&ordered); element != NULL; element = list_next (element)) { dfs_vertex = (list_data (element)); printf ("vertex id=%d,\tcolour=%d\n", *(int *) dfs_vertex->data, (int) dfs_vertex->color); } list_destroy (&ordered); graph_destroy (&graph); return 0; }
int main(){ /*初始化*/ Graph *graph = graph_init(); /*struct Path *add_edge(struct Graph *graph, int from, int to, int dut); *from&to:一条边的两个顶点。from为起点,to为终点。from和to可为任意整数. *dut:边的权值,不可大于INF即16777216。 */ add_edge(graph, 1, 2, 7); add_edge(graph, 2, 1, 7); add_edge(graph, 1, 3, 9); add_edge(graph, 3, 1, 9); add_edge(graph, 1, 6, 14); add_edge(graph, 6, 1, 14); add_edge(graph, 2, 3, 10); add_edge(graph, 3, 2, 10); add_edge(graph, 3, 6, 2); add_edge(graph, 6, 3, 2); add_edge(graph, 3, 4, 11); add_edge(graph, 4, 3, 11); add_edge(graph, 5, 6, 9); add_edge(graph, 6, 5, 9); add_edge(graph, 4, 5, 6); add_edge(graph, 5, 4, 6); add_edge(graph, 4, 7, 8); add_edge(graph, 7, 4, 8); add_edge(graph, 6, 7, 4); add_edge(graph, 7, 6, 4); add_edge(graph, 5, 7, 2); add_edge(graph, 7, 5, 2); /* *road_min(struct Graph *grap, int from, int to); *返回from--->to之间的最短路径————一个单向链表。 */ int from = 1; int to = 5; Path *path = road_min(graph, from, to); Path *tmp; while(path){ tmp = path->next; if(tmp) printf("%d->", path->node->id); else printf("%d->", path->node->id); path = tmp; } printf("%d\n", to); /*销毁*/ graph_destroy(graph); return 0; }
void enddown(){ graph_destroy(gp); free(gp); gp = NULL; for(int i=0; i<10; i++){ free(u[i]); u[i] = NULL; } }
void test_graph_search_create() { GRAPH* graph = graph_create(); graph_add_edge(graph, 0, 1); graph_add_edge(graph, 0, 2); graph_add_edge(graph, 1, 2); graph_add_edge(graph, 2, 1); GRAPH_SEARCH* graph_search = graph_search_create(graph); graph_destroy(graph); }
int main(void) { /* read graph from stdin */ graph_t graph = graph_from_file(stdin); assert(graph != NULL); /* run kruskal */ graph_t mst = kruskal(graph); /* dump graph */ graph_dump(mst, stdout); /* dump total weight */ printf("\n# MST : %u\n", mst_total_weight(mst)); /* dump whether has a cycle */ if (graph_has_cycle(mst)) { printf("# Has a cycle: YES\n"); } else { printf("# Has a cycle: NO\n"); } /* dump total connected components */ printf("# Connected components: %u\n", graph_connected_components(mst)); /* destroy both graphs */ graph = graph_destroy(graph); mst = graph_destroy(mst); }
int main(int argc, char *argv[]) { struct graph *g = graph_new(); if (g) { graph_join(g, 12, 34); graph_join(g, 34, 12); graph_join(g, 11, 9); graph_join(g, 9, 100); graph_join(g, 25, 89); graph_join(g, 100, 100); graph_dump(g); graph_destroy(g); } return 0; }
int main() { unsigned int iseed = (unsigned int)time(NULL); srand(iseed); graph g1; graph_init(&g1); graph_init_infectious(&g1); graph_init_ring(&g1, 1); graph_rewire(&g1, 0.05); //graph_print_adjacency(&g1); graph_destroy(&g1); return 0; }
int main(int argc, char **argv) { int width, height; double colour[3]; struct wav_file *wav; float samples[CHUNK_SIZE]; int sample_count; struct graph *gr; cairo_surface_t *surface; /* Validate and parse command-line arguments */ if(parse_arguments(argc, argv, &width, &height, colour) != 0) return 1; /* Open input file */ if( !(wav = wav_open(argv[1]))) { fprintf(stderr, "Unable to open input audio file %s\n", argv[1]); return 1; } /* Buffer all samples from input file. */ gr = graph_init(); while((sample_count = wav_read_samples(wav, samples, CHUNK_SIZE)) > 0) graph_buffer_samples(gr, samples, sample_count); /* Close input file */ wav_close(wav); /* Draw graph and output to PNG file using Cairo */ surface = graph_draw(gr, width, height, colour); if(cairo_surface_write_to_png(surface, argv[2]) != CAIRO_STATUS_SUCCESS) { fprintf(stderr, "Error writing graph to PNG file\n"); return 1; } graph_surface_destroy(surface); graph_destroy(gr); return 0; }
int main(int argc, char **argv){ Graph g; int i; int j; g = graph_create(TEST_SIZE); assert(graph_vertex_count(g) == TEST_SIZE); for (i = 0; i < TEST_SIZE; i++){ for (j = 0; j < TEST_SIZE; j++){ assert(graph_has_edge(g, i, j) == 0); } } for (i = 0; i < TEST_SIZE; i++){ assert(graph_out_degree(g, i) == 0); graph_foreach(g, i, match_sink, 0); } assert(graph_edge_count(g) == 0); for (i = 0; i < TEST_SIZE; i++){ for (j = 0; j < TEST_SIZE; j++){ if (i < j){ graph_add_edge(g, i, j); } } } for (i = 0; i < TEST_SIZE; i++){ for (j = 0; j < TEST_SIZE; j++){ assert(graph_has_edge(g, i, j) == (i < j)); } } assert(graph_edge_count(g) == (TEST_SIZE*(TEST_SIZE-1)/2)); graph2dot(g); graph_destroy(g); return 0; }
int main() { struct graph *g = graph_create(); if (g == NULL) { printf("malloc error\n"); return 1; } int values[] = {0, 1, 2, 3, 4, 5, 6, 7}; int len = sizeof(values)/sizeof(values[0]); struct vertex *vertices[len]; for (int i = 0; i < len; ++i) { vertices[i] = graph_vertex_add(g, values[i]); assert(vertices[i]); printf("Added vertex %p\n", vertices[i]); } graph_edge_add(g, vertices[0], vertices[7], 7); graph_edge_add(g, vertices[0], vertices[5], 5); graph_edge_add(g, vertices[0], vertices[3], 3); graph_edge_add(g, vertices[2], vertices[6], 8); graph_edge_add(g, vertices[5], vertices[4], 9); graph_edge_remove(g, vertices[0], vertices[7]); graph_edge_remove(g, vertices[0], vertices[5]); graph_edge_remove(g, vertices[2], vertices[6]); graph_edge_remove(g, vertices[5], vertices[4]); graph_edge_add(g, vertices[0], vertices[7], 7); graph_vertex_remove(g, vertices[0]); graph_print(g); graph_vertex_remove(g, vertices[1]); graph_vertex_remove(g, vertices[2]); graph_vertex_remove(g, vertices[3]); graph_vertex_remove(g, vertices[4]); graph_vertex_remove(g, vertices[5]); graph_vertex_remove(g, vertices[6]); graph_vertex_remove(g, vertices[7]); assert(graph_vertex_num(g) == 0); graph_destroy(g); return 0; }
int tnd(TMatrix_DCSR *matr, real threshold) { TWGraph gr; int *perm, *invp; int err = 0; #ifdef _DEBUG_LEVEL_0 printf("[debug(0)]{tnd}: graph_builder\n"); #endif err = build_graph(&gr, matr); if ( err != ERROR_NO_ERROR ) ERROR_MESSAGE("tnd: graph_builder failed", err); #ifdef _DEBUG_LEVEL_0 printf("[debug(0)]{tnd}: find_permutation\n"); #endif err = find_permutation(&gr,&perm, &invp, threshold); // !!!REORDERING!!! if ( err != ERROR_NO_ERROR ) ERROR_MESSAGE("tnd: find_permutation failed", err); #ifdef _DEBUG_LEVEL_0 printf("[debug(0)]{tnd}: graph_reoder\n"); #endif err = graph_reorder(&gr, perm, invp); if ( err != ERROR_NO_ERROR ) ERROR_MESSAGE("tnd: graph_reorder failed", err); if (perm) free(perm); if (invp) free(invp); err = graph_last_stage_reorder(&gr, threshold); if ( err != ERROR_NO_ERROR ) ERROR_MESSAGE("tnd: graph_last_stage_reorder failed", err); #ifdef _DEBUG_LEVEL_0 printf("[debug(0)]{tnd}: matrix_builder\n"); #endif err = build_matrix(&gr, matr, 0); if ( err != ERROR_NO_ERROR ) ERROR_MESSAGE("tnd: matrix_builder failed", err); graph_destroy(&gr); return ERROR_NO_ERROR; }
int main(int argc, char *argv[]) { graph_t *graph; int i, n, *dist, *parent; graph = graph_create(NUM_ELEM); graph_add_weighted_edge(graph, 0, 9, 200); graph_add_edge(graph, 0, 2); graph_add_edge(graph, 0, 4); graph_add_edge(graph, 0, 6); graph_add_edge(graph, 2, 4); graph_add_edge(graph, 2, 7); graph_add_edge(graph, 7, 9); printf("\nAll edges: \n"); graph_print_edges(graph); printf("\nAll edges from 0: \n"); graph_foreach_weighted(graph, 0, &graph_print_edge_weight, NULL); printf("\nDijkstra: \n"); n = graph_vertex_count(graph); dist = malloc(sizeof(int) * n); parent = malloc(sizeof(int) * n); dijkstra(graph, 0, dist, parent); for (i=0; i<n; i++) if (dist[i] == INT_MAX) printf(" no "); else printf("%3d ", dist[i]); printf("\n"); for (i=0; i<n; i++) printf("%3d ", parent[i]); printf("\n"); graph_destroy(graph); return EXIT_SUCCESS; }
int main(int argc, char** argv) { graph_p g = graph_init(8); edge_t e; e.v = 1; e.w = 3; printf("inserting edge\n"); graph_insert_edge(g, e); graph_print(g); /* edge_t edges[8 * 7 / 2]; printf("edges %d\n", graph_edges(g, edges)); */ printf("removing edge\n"); graph_remove_edge(g, e); graph_print(g); graph_destroy(g); return EXIT_SUCCESS; }
static void gl_destroy (graph_config_t ***gl_array, /* {{{ */ size_t *gl_array_num) { size_t i; if ((gl_array == NULL) || (gl_array_num == NULL)) return; #define ARRAY_PTR (*gl_array) #define ARRAY_SIZE (*gl_array_num) for (i = 0; i < ARRAY_SIZE; i++) { graph_destroy (ARRAY_PTR[i]); ARRAY_PTR[i] = NULL; } free (ARRAY_PTR); ARRAY_PTR = NULL; ARRAY_SIZE = 0; #undef ARRAY_SIZE #undef ARRAY_PTR } /* }}} void gl_destroy */
/* * Take a grid graph and make it into a maze. */ void mazeify(grid_t *grid) { graph_t *subgraph; int num_additional_edges = grid->graph->num_edges / 100; int i, e; /* Construct minimum spanning tree */ prim(grid->graph); /* Select additional edges at random to create imperfect maze */ for (i = 0; i < num_additional_edges; ++i) { e = rand() % grid->graph->num_edges; grid->graph->edges[e].selected = 1; } /* Select both directions of each undirected edge */ /* (Note: Parallelization of this step requires some thought.) */ graph_select_reverse_edges(grid->graph); /* Replace the graph with the maze */ subgraph = graph_subgraph(grid->graph); graph_destroy(grid->graph); grid->graph = subgraph; }
cmph_t *bmz8_new(cmph_config_t *mph, double c) { cmph_t *mphf = NULL; bmz8_data_t *bmz8f = NULL; cmph_uint8 i; cmph_uint8 iterations; cmph_uint8 iterations_map = 20; cmph_uint8 *used_edges = NULL; cmph_uint8 restart_mapping = 0; cmph_uint8 * visited = NULL; bmz8_config_data_t *bmz8 = (bmz8_config_data_t *)mph->data; if (mph->key_source->nkeys >= 256) { if (mph->verbosity) fprintf(stderr, "The number of keys in BMZ8 must be lower than 256.\n"); return NULL; } if (c == 0) c = 1.15; // validating restrictions over parameter c. DEBUGP("c: %f\n", c); bmz8->m = (cmph_uint8) mph->key_source->nkeys; bmz8->n = (cmph_uint8) ceil(c * mph->key_source->nkeys); DEBUGP("m (edges): %u n (vertices): %u c: %f\n", bmz8->m, bmz8->n, c); bmz8->graph = graph_new(bmz8->n, bmz8->m); DEBUGP("Created graph\n"); bmz8->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*3); for(i = 0; i < 3; ++i) bmz8->hashes[i] = NULL; do { // Mapping step cmph_uint8 biggest_g_value = 0; cmph_uint8 biggest_edge_value = 1; iterations = 100; if (mph->verbosity) { fprintf(stderr, "Entering mapping step for mph creation of %u keys with graph sized %u\n", bmz8->m, bmz8->n); } while(1) { int ok; DEBUGP("hash function 1\n"); bmz8->hashes[0] = hash_state_new(bmz8->hashfuncs[0], bmz8->n); DEBUGP("hash function 2\n"); bmz8->hashes[1] = hash_state_new(bmz8->hashfuncs[1], bmz8->n); DEBUGP("Generating edges\n"); ok = bmz8_gen_edges(mph); if (!ok) { --iterations; hash_state_destroy(bmz8->hashes[0]); bmz8->hashes[0] = NULL; hash_state_destroy(bmz8->hashes[1]); bmz8->hashes[1] = NULL; DEBUGP("%u iterations remaining\n", iterations); if (mph->verbosity) { fprintf(stderr, "simple graph creation failure - %u iterations remaining\n", iterations); } if (iterations == 0) break; } else break; } if (iterations == 0) { graph_destroy(bmz8->graph); return NULL; } // Ordering step if (mph->verbosity) { fprintf(stderr, "Starting ordering step\n"); } graph_obtain_critical_nodes(bmz8->graph); // Searching step if (mph->verbosity) { fprintf(stderr, "Starting Searching step.\n"); fprintf(stderr, "\tTraversing critical vertices.\n"); } DEBUGP("Searching step\n"); visited = (cmph_uint8 *)malloc((size_t)bmz8->n/8 + 1); memset(visited, 0, (size_t)bmz8->n/8 + 1); used_edges = (cmph_uint8 *)malloc((size_t)bmz8->m/8 + 1); memset(used_edges, 0, (size_t)bmz8->m/8 + 1); free(bmz8->g); bmz8->g = (cmph_uint8 *)calloc((size_t)bmz8->n, sizeof(cmph_uint8)); assert(bmz8->g); for (i = 0; i < bmz8->n; ++i) // critical nodes { if (graph_node_is_critical(bmz8->graph, i) && (!GETBIT(visited,i))) { if(c > 1.14) restart_mapping = bmz8_traverse_critical_nodes(bmz8, i, &biggest_g_value, &biggest_edge_value, used_edges, visited); else restart_mapping = bmz8_traverse_critical_nodes_heuristic(bmz8, i, &biggest_g_value, &biggest_edge_value, used_edges, visited); if(restart_mapping) break; } } if(!restart_mapping) { if (mph->verbosity) { fprintf(stderr, "\tTraversing non critical vertices.\n"); } bmz8_traverse_non_critical_nodes(bmz8, used_edges, visited); // non_critical_nodes } else { iterations_map--; if (mph->verbosity) fprintf(stderr, "Restarting mapping step. %u iterations remaining.\n", iterations_map); } free(used_edges); free(visited); }while(restart_mapping && iterations_map > 0); graph_destroy(bmz8->graph); bmz8->graph = NULL; if (iterations_map == 0) { return NULL; } mphf = (cmph_t *)malloc(sizeof(cmph_t)); mphf->algo = mph->algo; bmz8f = (bmz8_data_t *)malloc(sizeof(bmz8_data_t)); bmz8f->g = bmz8->g; bmz8->g = NULL; //transfer memory ownership bmz8f->hashes = bmz8->hashes; bmz8->hashes = NULL; //transfer memory ownership bmz8f->n = bmz8->n; bmz8f->m = bmz8->m; mphf->data = bmz8f; mphf->size = bmz8->m; DEBUGP("Successfully generated minimal perfect hash\n"); if (mph->verbosity) { fprintf(stderr, "Successfully generated minimal perfect hash function\n"); } return mphf; }
int main(int argc, char **argv) { int n, a, b, choice, ris, i, j; int *path; char tmp1[MAX_STR], tmp2[MAX_STR]; Hash_table ht; Graph g; FILE *fp; if(argc < 2){ fprintf(stderr, "Parameters error!\nUsage: %s <input file>\n", argv[0]); return -1; } if((fp=fopen(argv[1], "r")) == NULL){ fprintf(stderr, "Can't open file %s\n", argv[1]); return -2; } fscanf(fp, "%d", &n); ht = hash_table_init(n); g = graph_init(n); while(fscanf(fp, "%s %s", tmp1, tmp2) == 2) { if((a = hash_table_get(ht, tmp1)) == -1) a = hash_table_insert(ht, tmp1); if((b = hash_table_get(ht, tmp2)) == -1) b = hash_table_insert(ht, tmp2); graph_insert(g, create_edge(a,b)); } fclose(fp); printf( "===== G R A P H =====\n" "1 - Shortest simple path between two nodes\n" "2 - Longest simple path between two nodes\n" "3 - Number of all simple paths between two nodes\n" "4 - Show strong connected nodes\n" "5 - Show edges to strong connect the graph\n" "6 - Exit\n"); do{ printf("\nChoice: "); scanf("%d", &choice); switch(choice) { case 1: printf("Start node: "); scanf("%s", tmp1); printf("End node: "); scanf("%s", tmp2); if(hash_table_get(ht, tmp1) != -1 && hash_table_get(ht, tmp2) != -1) { ris = graph_get_shortest_path(g, hash_table_get(ht, tmp1), hash_table_get(ht, tmp2), &path); if(ris > 0) { printf("\nDistance = %d\n\nPath:\n", ris); for(i=0; i<=ris; i++) printf("%s\n", hash_table_get_name(ht, path[i])); free(path); } else printf("There is no path between these two nodes\n"); } else printf("Error, inexistent nodes\n"); break; case 2: printf("Start node: "); scanf("%s", tmp1); printf("End node: "); scanf("%s", tmp2); if(hash_table_get(ht, tmp1) != -1 && hash_table_get(ht, tmp2) != -1) { ris = graph_get_longest_path(g, hash_table_get(ht, tmp1), hash_table_get(ht, tmp2), &path); if(ris > 0) { printf("\nDistance = %d\n\nPath:\n", ris); for(i=0; i<=ris; i++) printf("%s\n", hash_table_get_name(ht, path[i])); free(path); } else printf("There is no path between these two nodes\n"); } else printf("Error, inexistent nodes\n"); break; case 3: printf("Start node: "); scanf("%s", tmp1); printf("End node: "); scanf("%s", tmp2); if(hash_table_get(ht, tmp1) != -1 && hash_table_get(ht, tmp2) != -1) printf("Number of simple paths: %d\n", graph_number_of_simple_path(g, hash_table_get(ht, tmp1), hash_table_get(ht, tmp2))); else printf("Error, inexistent nodes\n"); break; case 4: path = graph_get_scc(g); //for every scc group for(i=0; i<n; i++) { a = 0; //counter for(j=0; j<n; j++) if(path[j] == i) { printf("%s\n", hash_table_get_name(ht, j)); a++; } if(a != 0) printf("============\n"); else break; } break; } }while(choice != 6); hash_table_destroy(ht); graph_destroy(g); return 0; }
int main(int argc, char **args) { //邻接表 s_graph graph; graph_init(&graph, 13, &visit_int, &visit_int); //顶点数据项 int *t0 = (int *) malloc(sizeof(int)); int *t1 = (int *) malloc(sizeof(int)); int *t2 = (int *) malloc(sizeof(int)); int *t3 = (int *) malloc(sizeof(int)); int *t4 = (int *) malloc(sizeof(int)); int *t5 = (int *) malloc(sizeof(int)); int *t6 = (int *) malloc(sizeof(int)); int *t7 = (int *) malloc(sizeof(int)); int *t8 = (int *) malloc(sizeof(int)); int *t9 = (int *) malloc(sizeof(int)); int *t10 = (int *) malloc(sizeof(int)); int *t11 = (int *) malloc(sizeof(int)); int *t12 = (int *) malloc(sizeof(int)); //顶点数据 *t0 = 0; *t1 = 1; *t2 = 2; *t3 = 3; *t4 = 4; *t5 = 5; *t6 = 6; *t7 = 7; *t8 = 8; *t9 = 9; *t10 = 10; *t11 = 11; *t12 = 12; //设置顶点数据 graph_set_vertex(&graph, 0, t0); graph_set_vertex(&graph, 1, t1); graph_set_vertex(&graph, 2, t2); graph_set_vertex(&graph, 3, t3); graph_set_vertex(&graph, 4, t4); graph_set_vertex(&graph, 5, t5); graph_set_vertex(&graph, 6, t6); graph_set_vertex(&graph, 7, t7); graph_set_vertex(&graph, 8, t8); graph_set_vertex(&graph, 9, t9); graph_set_vertex(&graph, 10, t10); graph_set_vertex(&graph, 11, t11); graph_set_vertex(&graph, 12, t12); //插入边数据 graph_insert_arccell(&graph, 0, 1, 0, null); graph_insert_arccell(&graph, 0, 2, 0, null); graph_insert_arccell(&graph, 1, 3, 0, null); graph_insert_arccell(&graph, 1, 4, 0, null); graph_insert_arccell(&graph, 2, 5, 0, null); graph_insert_arccell(&graph, 2, 6, 0, null); graph_insert_arccell(&graph, 3, 4, 0, null); graph_insert_arccell(&graph, 3, 7, 0, null); graph_insert_arccell(&graph, 5, 8, 0, null); graph_insert_arccell(&graph, 6, 9, 0, null); graph_insert_arccell(&graph, 6, 10, 0, null); graph_insert_arccell(&graph, 8, 11, 0, null); graph_insert_arccell(&graph, 10, 11, 0, null); graph_insert_arccell(&graph, 10, 12, 0, null); //显示顶点和边的关系 graph_visit(&graph); //深度优先遍历图 graph_depth_first_search(&graph); //销毁邻接表 graph_destroy(&graph); return 0; }
int main(int argc, char *argv[]) { /* setup */ char *path = "./data/ct/"; char *path2 = "/home/gyc/Sources/linux.doc/kernel/"; vector_char str; vector_char_init(&str,100); VECTOR(str)[0] = '\0'; SetupLexer(); dic_setup(); struct dictionary *dict = new_dictionary(10000); graph_t lkn; vector_int edges; catch_function_call_dir(path, dict, &edges); printf("capacity=%d,size=%d\n",dict_capacity(dict), dict_size(dict)); new_graph(&lkn, &edges, 0, GRAPH_DIRECTED); struct dictionary *filedict = new_dictionary(4); vector_funcP flist; vector_funcP_init_(&flist, dict_size(dict)); get_function_filename(path2, dict, filedict, &flist); printf("filedict: capacity=%d,size=%d\n",dict_capacity(filedict), dict_size(filedict)); /* reciprocal */ printf("reciprocal = %f \n", graph_reciprocal(&lkn)); vector_double res; vector_double_init(&res, 0); graph_betweenness(&lkn, &res, graph_vss_all(), GRAPH_DIRECTED); printf("betweenness directed:"); print_vector_double(&(res),stdout); vector_double_destroy(&res); /* degree */ graph_degree(&lkn, &edges, graph_vss_all(), GRAPH_OUT, GRAPH_NO_LOOPS); printf(">>>out, no loops"); int min, max, sum; double ave; graph_degree_minmax_avesum(&lkn, &min, &max, &ave, &sum, GRAPH_OUT, GRAPH_NO_LOOPS); printf("minout=%d\nmaxout=%d\nsumout=%d\naveout=%f\n",min,max,sum,ave); graph_degree_minmax_avesum(&lkn, &min, &max, &ave, &sum, GRAPH_IN, GRAPH_NO_LOOPS); printf("minin=%d\nmaxin=%d\nsumin=%d\navein=%f\n",min,max,sum,ave); /* fast community */ graph_reverse(&lkn); vector_int v1; vector_int_init(&v1,0); int ncom = 0; double modularity = graph_community_fastgreedy(&lkn, &v1, &ncom); printf("modularity = %f,ncom = %d\n",modularity,ncom); FILE *f = fopen("funccom.fc.xlsx","w"); fprintf(f, "comID\tname\n"); for (int i = 0; i < dict_size(dict);i++) { fprintf(f, "%d\t", VECTOR(v1)[i]); struct rb_node* e = dict_ele(dict, i); dic_traceback_string(e, &str); fprintf(f, "%s\n",VECTOR(str)); } fclose(f); f = fopen("comID.fc.xlsx","w"); output_com_filename(&flist, &v1, graph_vertices_count(&lkn), ncom, filedict, f); fclose(f); //print_vector_int(&v1, stdout); print_communities(&lkn, &v1, "community.fc.xlsx", "comedge.fc.xlsx"); vector_funcP_destroy(&flist); vector_int_destroy(&v1); vector_char_destroy(&str); vector_int_destroy(&edges); graph_destroy(&lkn); return 0; }