// 1 color a 3 node, 2 edge graph // the node with the most edges should be spilled void test_chaitin_spill() { DEBUG_PRINT("\ntest_chaitin_spill:\n"); DEBUG_PRINT(" creating graph...\n"); graph* g = create_graph(); vertex* a = graph_add_vertex(g, 'a'); vertex* b = graph_add_vertex(g, 'b'); vertex* c = graph_add_vertex(g, 'c'); graph_add_edge(a, b); graph_add_edge(a, c); assert(a->color == -1); assert(b->color == -1); assert(c->color == -1); DEBUG_PRINT(" coloring graph...\n"); color_graph(g, 1); #ifdef DEBUG print_graph(g); #endif assert(a->color == -1); // spilled node assert(b->color == 0); assert(c->color == 0); destroy_graph(g); printf("+ algorithm test (spill) passed!\n"); }
int main(int argc,char *argv[]) { int num_houses,num_schools; int u,v,weight; if(scanf("%d %d",&num_houses,&num_schools) != 2) { printError(); } Graph *g = graph_new(num_houses+num_schools); g->num_houses = num_houses; g->num_schools = num_schools; g->number_of_vertices = num_houses+num_schools; while(scanf("%d %d %d",&u,&v,&weight) == 3) { if(u < 0 || v < 0 || u>=(g->number_of_vertices) || v>=(g->number_of_vertices) || weight < 0){ printError(); } else { // the 0 represents unvisted graph_add_edge(g,u,v,0); graph_add_edge(g,v,u,0); //adding weights g->vertices[u].edges[g->vertices[u].num_edges-1].weight = weight; g->vertices[v].edges[g->vertices[v].num_edges-1].weight = weight; } } // checking if graph is connected if(!graph_check_connected(g,0)) { fprintf(stderr, "Graph is not connected\n"); exit(EXIT_FAILURE); } Universe *Uni = create_all_sets(g->num_schools,g->num_houses); //running Dijkstra on each school vertex for(int i=num_houses;i<g->number_of_vertices;i++) { Dijkstra(g,i,Uni,min_func); } setCover(Uni,g->num_houses); free_graph(g); return 0; }
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); }
static void connect_cg(cgraph cg, struct endp from, struct endp to) { gnode gfrom = endpoint_lookup(cg, &from), gto = endpoint_lookup(cg, &to); graph_add_edge(gfrom, gto, NULL); /* If an endpoint has args, we must also connect the node w/o args */ if (from.args_node) graph_add_edge(fn_lookup(cg, from.function), gfrom, NULL); if (to.args_node) graph_add_edge(gto, fn_lookup(cg, to.function), NULL); }
void graph_get_circle(graph *g, int vertices) { graph_init(g, vertices); graph_add_edge(g, vertices - 1, vertices - 1, 1.0); graph_add_sym_edges(g, 0, vertices - 1, 1.0); for (int u = 0; u < vertices - 1; ++u) { graph_add_edge(g, u, u, 1.0); graph_add_sym_edges(g, u, u + 1, 1.0); } }
struct GRAPH *graph_prim(struct GRAPH *g) { struct EDGE *e; struct GRAPH *tree=NULL; struct EDGE_LIST *el=NULL, **tmp, **insert, *ne; struct VERTEX *v1, *v2; int a; if(!g) return; graph_add_vertex(&tree, g->vertex->point); for(; g; g=g->next) for(e=g->vertex->neighbour; e; e=e->next) { for(tmp=⪙ *tmp; tmp=&((*tmp)->next)) if((*tmp)->weight>e->weight) break; ne=malloc(sizeof(struct EDGE_LIST)); ne->next=*tmp; ne->weight=e->weight; ne->v1=g->vertex; ne->v2=e->vertex; *tmp=ne; } do { for(tmp=⪙ *tmp; tmp=&(*tmp)->next) { ne=*tmp; for(g=tree, a=0; g; g=g->next) { if(g->vertex->point.x==ne->v1->point.x&&g->vertex->point.y==ne->v1->point.y) { v1=g->vertex; a++; } if(g->vertex->point.x==ne->v2->point.x&&g->vertex->point.y==ne->v2->point.y) { v2=g->vertex; a+=2; } } if(!a) continue; else if(a==1) graph_add_edge(v1, graph_add_vertex(&tree, ne->v2->point), ne->weight, DIRECTION_SINGLE); else if(a==2) graph_add_edge(v2, graph_add_vertex(&tree, ne->v1->point), ne->weight, DIRECTION_SINGLE); *tmp=ne->next; free(ne); break; } } while(el); return tree; }
static uint8_t _copy_edges( graph_t *gin, graph_t *gout, uint32_t *nodemap, uint32_t nnodes) { uint64_t nidx; uint64_t nbridx; uint64_t nnbrs; uint32_t *nbrs; for (nidx = 0; nidx < nnodes; nidx++) { nnbrs = graph_num_neighbours(gin, nidx); nbrs = graph_get_neighbours(gin, nidx); for (nbridx = 0; nbridx < nnbrs; nbridx++) { if (nodemap[nidx] == nodemap[nbrs[nbridx]]) continue; if (graph_add_edge(gout, nodemap[nidx], nodemap[nbrs[nbridx]], 1)) goto fail; } } return 0; fail: return 1; }
void graph_get_llrgg(graph *g, int vertices, double r, double *x, double *y, well1024 *rng) { graph_init(g, vertices); for (int i = 0; i < vertices; ++i) { x[i] = well1024_next_double(rng); y[i] = well1024_next_double(rng); } double d; for (int i = 0; i < vertices; ++i) { for (int j = 0; j < vertices; ++j) { if (i != j) { const double a = x[i] - x[j]; const double b = y[i] - y[j]; d = hypot(a, b); if (d < r) { graph_add_edge(g, i, j, r - d); } } } } }
void create_edges( const pgrouting::DirectedGraph& digraph) { V_i vertexIt, vertexEnd; EO_i e_outIt, e_outEnd; EI_i e_inIt, e_inEnd; /* for (each vertex v in original graph) */ for (boost::tie(vertexIt, vertexEnd) = boost::vertices(digraph.graph); vertexIt != vertexEnd; vertexIt++) { auto vertex = *vertexIt; /* for( all incoming edges in to vertex v) */ for (boost::tie(e_outIt, e_outEnd) = boost::out_edges(vertex, digraph.graph); e_outIt != e_outEnd; e_outIt++) { /* for( all outgoing edges out from vertex v) */ for (boost::tie(e_inIt, e_inEnd) = boost::in_edges(vertex, digraph.graph); e_inIt != e_inEnd; e_inIt++) { /* Prevent self-edges from being created in the Line Graph */ graph_add_edge( (digraph.graph[*e_inIt]).id, (digraph.graph[*e_outIt]).id); } } } }
void graph_get_rec_rgg(graph *g, int vertices, double width, double r, double *x, double *y, well1024 *rng) { graph_init(g, vertices); const double length = 1.0 / width; // A = l * w so l = 1 / w for (int i = 0; i < vertices; ++i) { x[i] = well1024_next_double(rng) * length; y[i] = well1024_next_double(rng) * width; } double d; for (int i = 0; i < vertices; ++i) { for (int j = 0; j < vertices; ++j) { const double a = x[i] - x[j]; const double b = y[i] - y[j]; d = hypot(a, b); if (d < r) { graph_add_edge(g, i, j, r - d); } } } }
static int bmz8_gen_edges(cmph_config_t *mph) { cmph_uint8 e; bmz8_config_data_t *bmz8 = (bmz8_config_data_t *)mph->data; cmph_uint8 multiple_edges = 0; DEBUGP("Generating edges for %u vertices\n", bmz8->n); graph_clear_edges(bmz8->graph); mph->key_source->rewind(mph->key_source->data); for (e = 0; e < mph->key_source->nkeys; ++e) { cmph_uint8 h1, h2; cmph_uint32 keylen; char *key = NULL; mph->key_source->read(mph->key_source->data, &key, &keylen); // if (key == NULL)fprintf(stderr, "key = %s -- read BMZ\n", key); h1 = (cmph_uint8)(hash(bmz8->hashes[0], key, keylen) % bmz8->n); h2 = (cmph_uint8)(hash(bmz8->hashes[1], key, keylen) % bmz8->n); if (h1 == h2) if (++h2 >= bmz8->n) h2 = 0; if (h1 == h2) { if (mph->verbosity) fprintf(stderr, "Self loop for key %u\n", e); mph->key_source->dispose(mph->key_source->data, key, keylen); return 0; } //DEBUGP("Adding edge: %u -> %u for key %s\n", h1, h2, key); mph->key_source->dispose(mph->key_source->data, key, keylen); // fprintf(stderr, "key = %s -- dispose BMZ\n", key); multiple_edges = graph_contains_edge(bmz8->graph, h1, h2); if (mph->verbosity && multiple_edges) fprintf(stderr, "A non simple graph was generated\n"); if (multiple_edges) return 0; // checking multiple edge restriction. graph_add_edge(bmz8->graph, h1, h2); } return !multiple_edges; }
static void read_case_file (Graph *graph, const char *filename) { /* open file for reading */ FILE *file = fopen (filename, "r"); size_t bufsize = 1024; char buf[bufsize]; while(fgets (buf, bufsize, file) != NULL){ char *ptr1 = &buf[0]; char *machine,*c1,*c2,*price; machine = nextnum (&ptr1); c1 = nextnum (&ptr1); c2 = nextnum (&ptr1); price = nextnum (&ptr1); GraphNode *node1 = graph_lookup_node (graph, c1); GraphNode *node2 = graph_lookup_node (graph, c2); unsigned int price_val = (unsigned int)strtoul (price, NULL, 10); unsigned int machine_num = (unsigned int)strtoul (machine, NULL, 10); graph_add_edge (node1, node2, machine_num, price_val); } fclose (file); }
static int chm_gen_edges(cmph_config_t *mph) { cmph_uint32 e; chm_config_data_t *chm = (chm_config_data_t *)mph->data; int cycles = 0; DEBUGP("Generating edges for %u vertices with hash functions %s and %s\n", chm->n, cmph_hash_names[chm->hashfuncs[0]], cmph_hash_names[chm->hashfuncs[1]]); graph_clear_edges(chm->graph); mph->key_source->rewind(mph->key_source->data); for (e = 0; e < mph->key_source->nkeys; ++e) { cmph_uint32 h1, h2; cmph_uint32 keylen; char *key; mph->key_source->read(mph->key_source->data, &key, &keylen); h1 = hash(chm->hashes[0], key, keylen) % chm->n; h2 = hash(chm->hashes[1], key, keylen) % chm->n; if (h1 == h2) if (++h2 >= chm->n) h2 = 0; if (h1 == h2) { if (mph->verbosity) fprintf(stderr, "Self loop for key %u\n", e); mph->key_source->dispose(mph->key_source->data, key, keylen); return 0; } DEBUGP("Adding edge: %u -> %u for key %s\n", h1, h2, key); mph->key_source->dispose(mph->key_source->data, key, keylen); graph_add_edge(chm->graph, h1, h2); } cycles = graph_is_cyclic(chm->graph); if (mph->verbosity && cycles) fprintf(stderr, "Cyclic graph generated\n"); DEBUGP("Looking for cycles: %u\n", cycles); return ! cycles; }
void graph_add_edges(graph *g) { node *n1, *n2; int i, j; for (i = 0; i < g->ntemplates; i++) { n1 = g->nodes->node[i]; for (j = i+1; j < g->ntemplates; j++) { int count; double score; n2 = g->nodes->node[j]; score = calc_edge_score(n1->matrix, n2->matrix, g->snp_scores, g->nsnps, &count, g->correlation_offset); if (count) { graph_add_edge(g, g->nodes->node[i], g->nodes->node[j], score); } } } /* Sort edges-out for each node by node number */ for (i = 0; i < g->ntemplates; i++) { node_sort_edges(g->nodes->node[i]); } }
//! \brief Inserts *count* edges of type *pgr_edge_t* into the graph void graph_insert_data(const pgr_edge_t *data_edges, int64_t count) { for (unsigned int i = 0; i < count; ++i) { graph_add_edge(data_edges[i]); } adjust_vertices(); for ( int64_t i = 0; (unsigned int) i < gVertices_map.size(); ++i ) graph[i].id = gVertices_map.find(i)->second; }
void graph_insert_data( const std::vector <pgr_edge_t > &data_edges) { for (const auto edge : data_edges) { graph_add_edge(edge); } adjust_vertices(); for ( int64_t i = 0; (unsigned int) i < gVertices_map.size(); ++i ) graph[i].id = gVertices_map.find(i)->second; }
/* * In this pass, we are fixing the edges from jmp-like instructions and their * targets */ void x8664_graph_1 (struct _graph * graph, uint64_t address) { struct _graph_it * it; ud_t ud_obj; for (it = graph_iterator(graph); it != NULL; it = graph_it_next(it)) { struct _list * ins_list = graph_it_data(it); struct _ins * ins = list_first(ins_list); ud_init (&ud_obj); ud_set_mode (&ud_obj, 64); ud_set_input_buffer(&ud_obj, ins->bytes, ins->size); ud_disassemble(&ud_obj); struct ud_operand * operand; switch (ud_obj.mnemonic) { case UD_Ijmp : case UD_Ijo : case UD_Ijno : case UD_Ijb : case UD_Ijae : case UD_Ijz : case UD_Ijnz : case UD_Ijbe : case UD_Ija : case UD_Ijs : case UD_Ijns : case UD_Ijp : case UD_Ijnp : case UD_Ijl : case UD_Ijge : case UD_Ijle : case UD_Ijg : operand = &(ud_obj.operand[0]); if (operand->type != UD_OP_JIMM) break; uint64_t head = graph_it_index(it); uint64_t tail = head + ud_insn_len(&ud_obj) + udis86_sign_extend_lval(operand); int type = INS_EDGE_JCC_TRUE; if (ud_obj.mnemonic == UD_Ijmp) type = INS_EDGE_JUMP; struct _ins_edge * ins_edge = ins_edge_create(type); graph_add_edge(graph, head, tail, ins_edge); object_delete(ins_edge); break; default : break; } } }
struct edge * graph_join(struct graph * g, int v1, int v2) { struct vertex *a = graph_make_vertex(g, v1); struct vertex *b = graph_make_vertex(g, v2); if (a != NULL && b != NULL) { return graph_add_edge(g, a, b); } return NULL; }
void graph_get_star(graph *g, int vertices) { graph_init(g, vertices); for (int u = 0; u < vertices; ++u) { graph_add_edge(g, u, u, 1.0); graph_add_sym_edges(g, u, 0, 1.0); } }
graph_t kruskal(graph_t graph) { graph_t result = graph_empty(graph_vertices_count(graph)); unsigned int L, R, num_edges = graph_edges_count(graph); vertex_t l = NULL, r = NULL; pqueue_t Q = pqueue_empty(num_edges); union_find_t C = union_find_create(graph_vertices_count(graph)); edge_t E = NULL, *edges = graph_edges(graph); for (unsigned int i = 0; i < num_edges; i++) { pqueue_enqueue(Q, edges[i]); } free(edges); edges = NULL; while (!pqueue_is_empty(Q) && union_find_count(C) > 1) { E = edge_copy(pqueue_fst(Q)); l = edge_left_vertex(E); r = edge_right_vertex(E); L = union_find_find(C, vertex_label(l)); R = union_find_find(C, vertex_label(r)); if (L != R) { union_find_union(C, L, R); E = edge_set_primary(E, true); } else { E = edge_set_primary(E, false); } result = graph_add_edge(result, E); pqueue_dequeue(Q); } while (!pqueue_is_empty(Q)) { E = edge_copy(pqueue_fst(Q)); pqueue_dequeue(Q); E = edge_set_primary(E, false); result = graph_add_edge(result, E); } Q = pqueue_destroy(Q); C = union_find_destroy(C); return result; }
uint8_t _update_avg_graph( graph_t *gin, graph_t *gavg, array_t *nodemap, edge_weight_t edgeweight, uint16_t ninputs) { uint64_t i; uint64_t j; uint32_t ginnodes; uint32_t *nbrs; uint32_t nnbrs; uint32_t outi; uint32_t outj; float inwt; float outwt; ginnodes = graph_num_nodes(gin); for (i = 0; i < ginnodes; i++) { outi = *(uint32_t *)array_getd(nodemap, i); nnbrs = graph_num_neighbours(gin, i); nbrs = graph_get_neighbours(gin, i); for (j = 0; j < nnbrs; j++) { if (i >= nbrs[j]) continue; outj = *(uint32_t *)array_getd(nodemap, nbrs[j]); /*will have no effect if edge already exists*/ graph_add_edge(gavg, outi, outj, 0.0); inwt = graph_get_weight(gin, i, nbrs[j]); outwt = graph_get_weight(gavg, outi, outj); switch (edgeweight) { case SUM_WEIGHTS: outwt = outwt + inwt; break; case COUNT_EDGES: outwt = outwt + 1; break; case AVG_WEIGHTS: outwt = outwt + (inwt/ninputs); break; default: goto fail; } if (graph_set_weight(gavg, outi, outj, outwt)) goto fail; } } return 0; fail: return 1; }
/* creates graph structure from a file*/ graph_t * graph_create_file (const char *filename) { int i, j, c; FILE *file; graph_t *g; if (!filename) { fprintf (stderr, "file name is null \n"); _FLINE_; exit (0); } file = fopen (filename, "r"); if (!file) { fprintf (stderr, "file %s can not open\n", filename); _FLINE_; exit (0); } c = fscanf (file, "%d %d", &i, &j); if (!(i > 0 && j > 0)) { fprintf (stderr, "Node number and Edge number should be positive \n"); _FLINE_; exit (0); } g = graph_create (i, j); if (!g) { fprintf (stderr, "graph creation failed for nodes %2d and edges %2d \n", i, j); _FLINE_; exit (0); } c = fscanf (file, "%d %d", &i, &j); while (c != EOF) { if ((i < 0 || j < 0)) { fprintf (stderr, "Nodes should be positive \n"); _FLINE_; exit (0); } graph_add_edge (g, i, j); c = fscanf (file, "%d %d", &i, &j); } (void)fclose (file); return g; }
void graph_get_complete(graph *g, int vertices) { graph_init(g, vertices); for (int i = 0; i < vertices; ++i) { for (int j = 0; j < vertices; ++j) { graph_add_edge(g, i, j, 1.0); } } }
void testFINDPATH() { graph_t *g = mkGraphABCDE(); graph_add_edge(g, "A", "B", NULL); graph_add_edge(g, "B", "C", NULL); graph_add_edge(g, "C", "D", NULL); graph_add_edge(g, "A", "E", NULL); list_t *path = graph_find_path(g, "A", "D"); void *n0, *n1, *n2; CU_ASSERT(list_nth(path, 0, &n0) && streq(n0, "B")); CU_ASSERT(list_nth(path, 1, &n1) && streq(n1, "C")); CU_ASSERT(list_nth(path, 2, &n2) && streq(n2, "D")); list_free(path); // now we add a shortcut and try again: graph_add_edge(g, "A", "D", NULL); path = graph_find_path(g, "A", "D"); CU_ASSERT(list_nth(path, 0, &n0) && streq(n0, "D") && list_len(path) == 1); list_free(path); // now we add a cycle and try again: graph_add_edge(g, "D", "A", NULL); path = graph_find_path(g, "A", "D"); CU_ASSERT(list_nth(path, 0, &n0) && streq(n0, "D") && list_len(path) == 1); list_free(path); freeGraphABCDE(g); }
int main(void) { int d = 0; int i = 0; int x = 0; graph my_graph = NULL; if (1 == scanf("%d", &d)) { my_graph = graph_new(d); } while (2 == scanf("%d%d", &i, &x)) { graph_add_edge(my_graph, i, x); } /* graph my_graph = graph_new(8); graph_bi_add_edge(my_graph, 0, 1); graph_bi_add_edge(my_graph, 0, 4); graph_bi_add_edge(my_graph, 1, 0); graph_bi_add_edge(my_graph, 1, 5); graph_bi_add_edge(my_graph, 2, 3); graph_bi_add_edge(my_graph, 2, 5); graph_bi_add_edge(my_graph, 2, 6); graph_bi_add_edge(my_graph, 3, 2); graph_bi_add_edge(my_graph, 3, 6); graph_bi_add_edge(my_graph, 3, 7); graph_bi_add_edge(my_graph, 4, 0); graph_bi_add_edge(my_graph, 5, 1); graph_bi_add_edge(my_graph, 5, 2); graph_bi_add_edge(my_graph, 5, 6); graph_bi_add_edge(my_graph, 6, 2); graph_bi_add_edge(my_graph, 6, 3); graph_bi_add_edge(my_graph, 6, 5); graph_bi_add_edge(my_graph, 6, 7); graph_bi_add_edge(my_graph, 7, 3); graph_bi_add_edge(my_graph, 7, 6); */ graph_dfs(my_graph); graph_print(my_graph); graph_free(my_graph); return EXIT_SUCCESS; }
void testFINDNEIGHBORS() { graph_t *g = mkGraphABCDE(); graph_add_edge(g, "A", "B", NULL); list_t *neighs = graph_find_neighbors(g, "A"); CU_ASSERT(list_has(neighs, streq, "B")) CU_ASSERT(list_len(neighs) == 1); list_free(neighs); // adding an additional neighbor: graph_add_edge(g, "A", "C", NULL); neighs = graph_find_neighbors(g, "A"); CU_ASSERT(list_has(neighs, streq, "B")); CU_ASSERT(list_has(neighs, streq, "C")); CU_ASSERT(list_len(neighs) == 2); list_free(neighs); // the graph is directed: graph_add_edge(g, "C", "A", NULL); neighs = graph_find_neighbors(g, "A"); CU_ASSERT(list_has(neighs, streq, "B")); CU_ASSERT(list_has(neighs, streq, "C")); CU_ASSERT(list_len(neighs) == 2); list_free(neighs); // add an unrelated edge graph_add_edge(g, "D", "E", NULL); neighs = graph_find_neighbors(g, "A"); CU_ASSERT(list_has(neighs, streq, "B")); CU_ASSERT(list_has(neighs, streq, "C")); CU_ASSERT(list_len(neighs) == 2); list_free(neighs); freeGraphABCDE(g); }
void add_edge(char *s1, char *s2) { int i, v1=-1, v2=-1; for(i=0; i<ARRAY_SIZE; i++) { if(!vertex[i]) continue; if(!strcmp(s2, vertex[i])) v1=i; if(!strcmp(s1, vertex[i])) v2=i; } if(!(v1==-1||v2==-1)) { graph_add_edge(v1, v2, 10, DIRECTION_SINGLE); } }
int main() { int t; int s; for(s=0;s<10;s++) { int width = (lrand48()%8)+1; graph_t*g = graph_new(width*width); for(t=0;t<width*width;t++) { int x = t%width; int y = t/width; int w = 1; #define R (lrand48()%32) if(x>0) graph_add_edge(&g->nodes[t], &g->nodes[t-1], R, R); if(x<width-1) graph_add_edge(&g->nodes[t], &g->nodes[t+1], R, R); if(y>0) graph_add_edge(&g->nodes[t], &g->nodes[t-width], R, R); if(y<width-1) graph_add_edge(&g->nodes[t], &g->nodes[t+width], R, R); } int x = graph_maxflow(g, &g->nodes[0], &g->nodes[width*width-1]); printf("max flow: %d\n", x); graph_delete(g); } }
int main(int argc, char **argv) { int i, j; struct GRAPH *g, *tree=NULL; struct VERTEX *v; struct POINT p; DARNIT_KEYS keys; srand(time(NULL)); d_init("Graphs", "uppg8", NULL); for(i=0; i<256; i++) { circle[i]=d_render_circle_new(32, 1); line[i]=d_render_line_new(1, 1); } for(j=0; j<4; j++) for(i=0; i<7; i++) { p.x=i*100+50;//(rand()%80)*10; p.y=j*100+50;//(rand()%48)*10; v=graph_add_vertex(&graph, p); for(g=graph; g; g=g->next) if(!(rand()%6)) graph_add_edge(v, g->vertex, rand()%100, DIRECTION_DOUBLE); } tree=graph_prim(graph); draw_graph(graph); for(g=graph;;) { keys=d_keys_get(); if(keys.start) { g=g==graph?tree:graph; draw_graph(g); } d_keys_set(keys); d_render_begin(); d_render_tint(0xFF, 0xFF, 0xFF, 0xFF); for(i=0; i<vertices; i++) d_render_circle_draw(circle[i]); for(i=0; i<edges; i++) { d_render_tint(length[i], 0x7F, 0x0, 0xFF); d_render_line_draw(line[i], 1); } d_render_end(); d_loop(); } d_quit(); return 0; }
graph_t *graph_plant_path(index_t n, index_t idx) { graph_t *g = graph_alloc(n); index_t last = -1; index_t t[128]; index_t k = 0; for(index_t i = 0; i < n; i++) { if((idx >> i)&1) { if(last >= 0) graph_add_edge(g, last, i); last = i; t[k++] = i; graph_set_color(g, i, 1); } else { graph_set_color(g, i, 0); } }