main(){ graph **adj_list; int n, m, n1, n2; //Creating the adjacency list scanf("%d %d", &n, &m); adj_list=create_empty_list(adj_list, n); //Creating edges int i; for(i=0;i<m;++i){ scanf("%d %d", &n1, &n2); create_edge(n1,n2,adj_list,n); create_edge(n2,n1,adj_list,n); } print_list(adj_list, n); //Marking elements as visited int *visited; visited=(int *)malloc(n*sizeof(int)); for(i=0;i<n;++i){ visited[i]=0; } //Printing the connected componenets printf("\n\nThe connected components are: \n"); for(i=0;i<n;++i){ if(visited[i]==0){ printf("{"); dfs_connected(adj_list,i,visited); printf("\b} "); } } }
struct NodeStorage* new_from_file( FILE* in,unsigned edge_stride ) { struct NodeStorage* result = malloc( sizeof (struct NodeStorage) ); result->n_nodes = 0; result->edge_stride = edge_stride; result->nodes = malloc( 0 ); char* line = NULL; unsigned row_no = 0; size_t n = 0; while( getline( &line,&n,in )!=-1 ) { char* field; unsigned field_no = 0; field = strtok( line," \t\n" ); while( field ) { if( result->n_nodes<field_no + 1 ) { result->nodes = realloc( result->nodes,( field_no + 1 )*sizeof (Node) ); result->nodes[ field_no ].out.n_edges = 0; result->nodes[ field_no ].out.first.data = malloc( edge_stride*sizeof (Edge) ); result->nodes[ field_no ].out.first.next = NULL; result->n_nodes++; } if( strcmp( field,"0" )&& strcmp( field,"0.0" )&& strcmp( field,"." ) ) { create_edge( result,row_no,field_no ); } field_no++; field = strtok( NULL," \t\n" ); } } free( line ); return result; }
int main(void) { int T; scanf("%d", &T); int i; for(i = 0; i < T; i++) { Graph *graph = (Graph *)malloc(sizeof(Graph)); int vertex_num, edge_num; scanf("%d %d", &vertex_num, &edge_num); graph->vertex_num = vertex_num; graph->in_degrees = (int *)malloc(sizeof(int) * graph->vertex_num); memset(graph->in_degrees, 0, sizeof(int) * graph->vertex_num); graph->adj_lists = (Edge **)malloc(sizeof(Edge *) * graph->vertex_num); memset(graph->adj_lists, 0, sizeof(Edge *) * graph->vertex_num); int k; for(k = 0; k < edge_num; k++) { int from, to; scanf("%d %d", &from, &to); from--; to--; Edge *edge = create_edge(to, graph->adj_lists[from]); graph->adj_lists[from] = edge; graph->in_degrees[to] += 1; } if(is_dag(graph)) { printf("Correct\n"); } else { printf("Wrong\n"); } destroy_graph(graph); } return 0; }
void recv_create_edge(void) { int i = recv_index(); int j = recv_index(); create_edge(i, j); }
void add_vertex_to_edge(half_edge e1, void* v3) { assert(e1->next == NULL); assert(e1->opp->prev == NULL); half_edge e2 = create_edge(e1->opp->vertex, v3); half_edge e3 = create_edge(v3, e1->vertex); half_edge ne1 = e3->opp; half_edge ne2 = e1->opp; half_edge ne3 = e2->opp; e1->next = ne1; ne1->prev = e1; e2->next = ne2; ne2->prev = e2; e3->next = ne3; ne3->prev = e3; }
half_edge create_triangle(void* v1, void* v2, void* v3) { half_edge e1 = create_edge(v1,v2); half_edge e2 = create_edge(v2,v3); half_edge e3 = create_edge(v3,v1); half_edge ne1 = e3->opp; half_edge ne2 = e1->opp; half_edge ne3 = e2->opp; e1->next = ne1; ne1->prev = e1; e2->next = ne2; ne2->prev = e2; e3->next = ne3; ne3->prev = e3; return e1; }
int send_create_edge(int i, int j) { send_event(EVENT_CREATE_EDGE); send_index(i); send_index(j); return create_edge(i, j); }
void add_connection(t_graph graph, int orig_node_id, int dest_node_id) { t_edge target_list = graph->vertexs[orig_node_id]->edges; t_edge new_edge = create_edge(dest_node_id); new_edge->next = target_list; graph->vertexs[orig_node_id]->edges = new_edge; }
void graphNodelist :: create_edge_from_container_to_fluid(void* x1, void* x2) { Container* f1 = (Container*)x1; Fluid* f2 = (Fluid*)x2; // create nodes if needed if (f1->node == NULL) { f1->node = create_node_with_type(f1->name, f1->type); } if (f2->node == NULL) { f2->node = create_node_with_type(f2->original_name, f2->type); } // connect the nodes create_edge(f1->node, f2->node); }
void MxPropSlim::collect_edges() { MxVertexList star; for(MxVertexID i=0; i<m->vert_count(); i++) { star.reset(); m->collect_vertex_star(i, star); for(unsigned int j=0; j<(unsigned int)star.length(); j++) if( i < star(j) ) // Only add particular edge once create_edge(i, star(j)); } }
void close_triangle(half_edge e1, half_edge e2) { assert(e1->next == NULL); assert(e1->opp->prev == NULL); assert(e2->next == NULL); assert(e2->opp->prev == NULL); assert(e2->vertex == e1 -> opp -> vertex); half_edge e3 = create_edge(e2->opp->vertex,e1->vertex); half_edge ne1 = e3->opp; half_edge ne2 = e1->opp; half_edge ne3 = e2->opp; e1->next = ne1; ne1->prev = e1; e2->next = ne2; ne2->prev = e2; e3->next = ne3; ne3->prev = e3; }
void Search::readStrGraph(Patterns &patterns,StrGraph &desc) { clear(); map<StrGraph::Node*,Node*> recollect; for(StrGraph::node_iter ni = desc.nodes().begin(); ni!=desc.nodes().end(); ++ni) { Node *n = create_node(gd<Name>(*ni)); recollect[*ni] = n; SearchStage &stage = gd<SearchStage>(n); DString limit = gd<StrAttrs>(*ni).look("limit","50"); stage.limit = atoi(limit.c_str()); DString action = gd<StrAttrs>(*ni).look("action","union"); if(action=="union") stage.type = UnionInquiry; else if(action=="intersection") stage.type = IntersectionInquiry; else if(action=="pattern") { stage.type = PatternInquiry; DString pattern = gd<StrAttrs>(*ni).look("pattern",""); Patterns::iterator pi = patterns.find(pattern); if(pi==patterns.end()) throw UndefinedPattern(pattern); stage.pattern = &pi->second; } else if(action=="path") { stage.type = PathInquiry; DString ways = gd<StrAttrs>(*ni)["ways"]; if(ways=="in") stage.goIn = true, stage.goOut = false; else if(ways=="both") stage.goIn = stage.goOut = true; else // ways=="out" default stage.goIn = false, stage.goOut = true; stage.firstOnly = gd<StrAttrs>(*ni)["firstonly"]=="true"; stage.shortest = gd<StrAttrs>(*ni)["shortest"]=="true"; stage.weightattr = gd<StrAttrs>(*ni).look("weightattr","weight"); } else throw UnknownAction(action); } for(StrGraph::graphedge_iter ei = desc.edges().begin(); ei!=desc.edges().end(); ++ei) { Edge *e = create_edge(recollect[(*ei)->tail],recollect[(*ei)->head]).first; DString input = gd<StrAttrs>(*ei).look("input",""); gd<Name>(e) = input; } }
//-------------------------------------------------------------------------- int callgraph_t::walk_func(func_t *func, funcs_walk_options_t *opt, int level) { // add a node for this function ea_t func_start = func->startEA; int id = add(func_start); func_item_iterator_t fii; for ( bool fi_ok=fii.set(func); fi_ok; fi_ok=fii.next_code() ) { xrefblk_t xb; for ( bool xb_ok = xb.first_from(fii.current(), XREF_FAR); xb_ok && xb.iscode; xb_ok = xb.next_from() ) { func_t *f = get_func(xb.to); if ( f == NULL ) continue; int id2; if ( !visited(f->startEA, &id2) ) { if ( func_contains(func, xb.to) ) continue; bool skip = false; if ( opt != NULL ) { skip = // skip lib funcs? (((f->flags & FUNC_LIB) != 0) && ((opt->flags & FWO_SKIPLIB) != 0)) // max recursion is off, and limit is reached? || ( ((opt->flags & FWO_RECURSE_UNLIM) == 0) && (level > opt->recurse_limit) ); } if ( skip ) id2 = add(f->startEA); else id2 = walk_func(f, opt, level+1); } create_edge(id, id2); } } return id; }
/* Read a graph from file "filename" */ void readgraph(char *filename) { FILE *fp; char buf[MAXLEN]; /* Buffer for a line from the text file */ char *tmp[MAXNODE*2]; /* Pointers to the names of nodes, and lengths if available */ char sep_ch[]=" \n"; /* names and nodes are separated by space and newline */ char nodename; /* name of the node */ int ni; /* index to the node */ int desti; /* the destination index */ edge_t *ep, *ep1; /* pointer to the edge structure */ int i, j; fp = fopen(filename, "r"); if (fp==NULL) {printf("File %s does not exist!\n", filename); exit(1); } num_of_nodes = 0; while ( fgets (buf, MAXLEN, fp) != NULL ) { /* read from the file until the end */ j=0; tmp[j] = strtok(buf, sep_ch); /* separate line by space and new line */ while (tmp[j] != NULL) { j++; tmp[j] = strtok(NULL, (char *) sep_ch); } if (j>0) {nodename = tmp[0][0]; /* get the name of the node */ ni=nodename - 'A'; /* get the index of the node */ if (num_of_nodes < ni + 1) num_of_nodes = ni+1; /* set the number of nodes */ graph[ni].name = nodename; graph[ni].edge_list = NULL; ep = NULL; for (i=1; i<j; i++) { /* process each edge from the node */ desti=tmp[i][0] - 'A'; /* get the destination node index */ ep1 = create_edge(desti); /* allocate an edge */ if (ep==NULL) graph[ni].edge_list = ep1; else ep->next = ep1; /* put the edge to the link list */ ep = ep1; /* ep points to the end of the list */ } } } fclose(fp); }
void subdivide_element(Element *e, long process_id) { float quarter_area ; ElemVertex *ev_12, *ev_23, *ev_31 ; Edge *e_12_23, *e_23_31, *e_31_12 ; Element *enew, *ecenter ; long rev_12, rev_23, rev_31 ; /* Lock the element before checking the value */ LOCK(e->elem_lock->lock); /* Check if the element already has children */ if( ! _LEAF_ELEMENT(e) ) { UNLOCK(e->elem_lock->lock); return ; } /* Subdivide edge structures */ subdivide_edge( e->e12, (float)0.5, process_id ) ; subdivide_edge( e->e23, (float)0.5, process_id ) ; subdivide_edge( e->e31, (float)0.5, process_id ) ; ev_12 = e->e12->ea->pb ; ev_23 = e->e23->ea->pb ; ev_31 = e->e31->ea->pb ; /* Then create new edges */ e_12_23 = create_edge( ev_12, ev_23, process_id ) ; e_23_31 = create_edge( ev_23, ev_31, process_id ) ; e_31_12 = create_edge( ev_31, ev_12, process_id ) ; /* Area parameters */ quarter_area = e->area * (float)0.25 ; /* (1) Create the center patch */ enew = get_element(process_id) ; ecenter = enew ; enew->parent= e ; enew->patch = e->patch ; enew->ev1 = ev_23 ; enew->ev2 = ev_31 ; enew->ev3 = ev_12 ; enew->e12 = e_23_31 ; enew->e23 = e_31_12 ; enew->e31 = e_12_23 ; enew->area = quarter_area ; enew->rad = e->rad ; /* (2) Create the top patch */ rev_12 = EDGE_REVERSE( e->e12, e->ev1, e->ev2 ) ; rev_23 = EDGE_REVERSE( e->e23, e->ev2, e->ev3 ) ; rev_31 = EDGE_REVERSE( e->e31, e->ev3, e->ev1 ) ; enew = get_element(process_id) ; e->top = enew ; enew->parent= e ; enew->patch = e->patch ; enew->ev1 = e->ev1 ; enew->ev2 = ev_12 ; enew->ev3 = ev_31 ; enew->e12 = (!rev_12)? e->e12->ea : e->e12->eb ; enew->e23 = e_31_12 ; enew->e31 = (!rev_31)? e->e31->eb : e->e31->ea ; enew->area = quarter_area ; enew->rad = e->rad ; /* (3) Create the left patch */ enew = get_element(process_id) ; e->left = enew ; enew->parent= e ; enew->patch = e->patch ; enew->ev1 = ev_12 ; enew->ev2 = e->ev2 ; enew->ev3 = ev_23 ; enew->e12 = (!rev_12)? e->e12->eb : e->e12->ea ; enew->e23 = (!rev_23)? e->e23->ea : e->e23->eb ; enew->e31 = e_12_23 ; enew->area = quarter_area ; enew->rad = e->rad ; /* (4) Create the right patch */ enew = get_element(process_id) ; e->right = enew ; enew->parent= e ; enew->patch = e->patch ; enew->ev1 = ev_31 ; enew->ev2 = ev_23 ; enew->ev3 = e->ev3 ; enew->e12 = e_23_31 ; enew->e23 = (!rev_23)? e->e23->eb : e->e23->ea ; enew->e31 = (!rev_31)? e->e31->ea : e->e31->eb ; enew->area = quarter_area ; enew->rad = e->rad ; /* Finally, set e->center */ e->center = ecenter ; /* Unlock the element */ UNLOCK(e->elem_lock->lock); }
Mesh marching_cubes(Grid& grid, double isovalue, SurfaceType surface_type) { Mesh mesh; int offset[8]; Vertex* vertices[12]; unordered_set<Vertex*, vertex_hash, vertex_equals> vertex_set; compute_offset(grid, offset); for(int z = 0; z < grid.get_axis(2)-1; z++) { for(int y = 0; y < grid.get_axis(1)-1; y++) { for(int x = 0; x < grid.get_axis(0)-1; x++) { int ic = grid.index(x,y,z); int table_index = get_index(grid, ic, offset, isovalue); for(int i = 0; i < 12; i++) { if(edge_table[table_index] & (1 << i)) { int v[3], u[3]; get_grid_edge(x, y, z, i, v, u); double sv = grid[grid.index(v[0],v[1],v[2])]; double su = grid[grid.index(u[0],u[1],u[2])]; double vc[3] = {(v[0]-grid.get_axis(0)/2.0)*grid.get_spacing(0), (v[1]-grid.get_axis(1)/2.0)*grid.get_spacing(1), (v[2]-grid.get_axis(2)/2.0)*grid.get_spacing(2)}; double uc[3] = {(u[0]-grid.get_axis(0)/2.0)*grid.get_spacing(0), (u[1]-grid.get_axis(1)/2.0)*grid.get_spacing(1), (u[2]-grid.get_axis(2)/2.0)*grid.get_spacing(2)}; if(surface_type == NO_SURFACE) { vertices[i] = lerp(vc, sv, uc, su, isovalue); } else { vertices[i] = find_cut_point(vc, sv, uc, su, isovalue, surface_type); } vertices[i] = merge_vertex(vertices[i], vertex_set, mesh); } } for(int i = 0; triangle_table[table_index][i] != -1; i += 3) { Vertex *v0, *v1, *v2; v0 = vertices[triangle_table[table_index][i]]; v1 = vertices[triangle_table[table_index][i+1]]; v2 = vertices[triangle_table[table_index][i+2]]; if(!is_degenerate(v0, v1, v2)) { Face* f = new Face; f->v.push_back(v0); f->v.push_back(v1); f->v.push_back(v2); v0->f.push_back(f); v1->f.push_back(f); v2->f.push_back(f); Edge* e0 = create_edge(v0, v1, f, mesh); Edge* e1 = create_edge(v1, v2, f, mesh); Edge* e2 = create_edge(v2, v0, f, mesh); f->e.push_back(e0); f->e.push_back(e1); f->e.push_back(e2); mesh.add(f); } } } } } compute_normals(mesh); return mesh; }
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; }