int main (void){ read(); print_list_graph(); int *Ts = topo_sort(); print_int_array(Ts,0,n-1); return 0; }
struct copy_graph_node * permute_copies( struct copy_graph_node **copy_graph_head, struct add_list * add_list) { int count; struct copy_graph_node * topo_list_head; struct copy_graph_node ** node_array; if(do_stats) { timing(TIMING_START); } node_array = build_edges(*copy_graph_head,&count); if(do_stats) { rprintf(FINFO, "Build graph: %s\n", timing(TIMING_END)); } if(do_stats) { timing(TIMING_START); } topo_list_head = topo_sort(node_array,count, add_list); if(do_stats) { rprintf(FINFO, "Topological sort: %s\n", timing(TIMING_END)); } update_extra_memory(-(count * sizeof(struct copy_graph_node * ))); if(do_stats) { rprintf(FINFO, "Extra memory: %d Extra bytes sent: %d\n", max_extra_memory,extra_bytes); rprintf(FINFO, "Broken copies without delta comp: %d\n", broken_copies); rprintf(FINFO, "Cycles broken: %d Bytes trimmed: %d\n", cycles_broken, bytes_trimmed); } free(node_array); return topo_list_head; }
void randomize() { Timer t; for(int i = 1;i < 20;i++) { cout << "\nFor operation : " << i; nodes = i; //general initializations visited = new int [nodes]; *edges = new int [nodes]; for(int i = 0;i < nodes;i++) edges[i] = new int [nodes]; for(int row = 0;row < nodes;row++) for(int col = 0;col < nodes;col++) { visited[row] = 0; edges[row][col] = -1; } //----------------------- for(int k = 0;k < nodes;k++) for(int l = 0;l < nodes;l++) { if(edges[k][l] != -1) continue; edges[k][l] = rand() % 2; edges[l][k] = 0; } t.start();topo_sort();t.stop();stck.clear(); cout << " time taken is : " << t.time() << " seconds"; } }
int main() { int mat[101][101]={0}; int i,j,k; int V,E; int r,c; while((scanf("%d%d",&V,&E)==2) && (V || E)) { for(i=0;i<E;i++) { k=scanf("%d%d",&r,&c); mat[r-1][c-1] =1; } #if 0 for(i=0;i<V;i++) { for(j=0;j<V;j++) printf("%d ",mat[i][j]); printf("\n"); } #endif topo_sort(mat,V); for(i=0;i<V;i++) for(j=0;j<V;j++) mat[i][j] = 0; printf("\n"); } return(0); }
void RectCluster::sequential_partition() { SequentialWSPD seq_wspd(curve1_, curve2_, 1 / eps_); std::vector<IndexSegment> segs1 = seq_wspd.segs1(); std::vector<IndexSegment> segs2 = seq_wspd.segs2(); gen_rect_from_pair(segs1, segs2); build_rect_graph(); topo_sort(); }
/* * Given a graph, do a recursive topological sort into the given array. This is * really just a depth first search, so that the deepest nodes appear first. * hijack the 'zv_visited' marker to avoid visiting the same vertex twice. */ static int topo_sort(libzfs_handle_t *hdl, boolean_t allowrecursion, char **result, size_t *idx, zfs_vertex_t *zgv) { int i; if (zgv->zv_visited == VISIT_SORT_PRE && !allowrecursion) { /* * If we've already seen this vertex as part of our depth-first * search, then we have a cyclic dependency, and we must return * an error. */ zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "recursive dependency at '%s'"), zgv->zv_dataset); return (zfs_error(hdl, EZFS_RECURSIVE, dgettext(TEXT_DOMAIN, "cannot determine dependent datasets"))); } else if (zgv->zv_visited >= VISIT_SORT_PRE) { /* * If we've already processed this as part of the topological * sort, then don't bother doing so again. */ return (0); } zgv->zv_visited = VISIT_SORT_PRE; /* avoid doing a search if we don't have to */ zfs_vertex_sort_edges(zgv); for (i = 0; i < zgv->zv_edgecount; i++) { if (topo_sort(hdl, allowrecursion, result, idx, zgv->zv_edges[i]->ze_dest) != 0) return (-1); } /* we may have visited this in the course of the above */ if (zgv->zv_visited == VISIT_SORT_POST) return (0); if ((result[*idx] = zfs_alloc(hdl, strlen(zgv->zv_dataset) + 1)) == NULL) return (-1); (void) strcpy(result[*idx], zgv->zv_dataset); *idx += 1; zgv->zv_visited = VISIT_SORT_POST; return (0); }
void sssp_dag (void) { topo_sort(); memset(dis, 0xff, sizeof(dis)); dis[s] = 0; for (int i = cnt_topo_list; i >= 1; --i) { int node = topo_list[i]; for (int j = 1; j <= n; ++j) { if (map[node][j]) { if (dis[node] >= 0) { if (dis[node] + map[node][j] > dis[j]) { dis[j] = dis[node] + map[node][j]; } } } } } }
void RectCluster::partition() { VLOG(6) << "Grid side length: " << len_cell_; // random shift unsigned seed = std::chrono::system_clock::now().time_since_epoch().count(); std::default_random_engine generator(seed); std::uniform_real_distribution<double> distribution(0.0, (double) len_cell_); double rand_shift_x = distribution(generator); double rand_shift_y = distribution(generator); Vector_2 vec(rand_shift_x, rand_shift_y); LOG(INFO) << "Random shift: " << vec; // Build grid grid_ = new Grid(curve1_, curve2_, lb_, ub_, len_cell_); grid_->init(vec); for (auto it = grid_->begin(); it != grid_->end(); it++) { // quad-tree from containing points from curve1 QuadTree* curr_qt = it->second.first; // check if the node contains points from curve 1 if (curr_qt->is_empty()) { continue; } // find the neighboring nodes that contain points from curve 2 vector<QuadTree*> nbrs = grid_->neighbors(it->first, 1); //VLOG(7) << it->second.first->to_string() << " ---------- "; for (auto& qt : nbrs) { WSPD wspd(curr_qt, qt, 1 / eps_, lb_ / max(curve1_.size(), curve2_.size())); for (auto it = wspd.begin(); it != wspd.end(); it++) { gen_rect(it->first->idx_segments(), it->second->idx_segments()); } } } // after generating all rectangles, build a dependency graph of them and topologically sort them build_rect_graph(); topo_sort(); }
/* * The only public interface for this file. Do the dirty work of constructing a * child list for the given object. Construct the graph, do the toplogical * sort, and then return the array of strings to the caller. * * The 'allowrecursion' parameter controls behavior when cycles are found. If * it is set, the the cycle is ignored and the results returned as if the cycle * did not exist. If it is not set, then the routine will generate an error if * a cycle is found. */ int get_dependents(libzfs_handle_t *hdl, boolean_t allowrecursion, const char *dataset, char ***result, size_t *count) { zfs_graph_t *zgp; zfs_vertex_t *zvp; if ((zgp = construct_graph(hdl, dataset)) == NULL) return (-1); if ((*result = zfs_alloc(hdl, zgp->zg_nvertex * sizeof (char *))) == NULL) { zfs_graph_destroy(zgp); return (-1); } if ((zvp = zfs_graph_lookup(hdl, zgp, dataset, 0)) == NULL) { free(*result); zfs_graph_destroy(zgp); return (-1); } *count = 0; if (topo_sort(hdl, allowrecursion, *result, count, zvp) != 0) { free(*result); zfs_graph_destroy(zgp); return (-1); } /* * Get rid of the last entry, which is our starting vertex and not * strictly a dependent. */ assert(*count > 0); free((*result)[*count - 1]); (*count)--; zfs_graph_destroy(zgp); return (0); }
int main() { BORDER b[201]={0}; char tmp[52]={0}; int mat[101][101]={0}; int i,j,k; int V,E; int r,c; int t=1; while((scanf("%d",&V)==1)) { for(i=0;i<V;i++) { k = scanf("%s",tmp); strcpy(bevarages[i],tmp); } k = scanf("%d",&E); for(i=0;i<E;i++) { k = scanf("%s%s",b[i].B1,b[i].B2); for(j=0;j<V;j++) { if(strcmp(b[i].B1,bevarages[j])==0) { r = j; break; }; } for(j=0;j<V;j++) { if(strcmp(b[i].B2,bevarages[j])==0) { c = j; break; }; } mat[r][c] =1; } #if 0 for(i=0;i<V;i++) { for(j=0;j<V;j++) printf("%d ",mat[i][j]); //printf("[%s,%s] ",bevarages[i],bevarages[j]); printf("\n"); } for(i=0;i<V;i++) printf("%d %s\n",i,bevarages[i]); #endif topo_sort(mat,V); printf("Case #%d: Dilbert should drink beverages in this order: ",t++); for(i=0;i<V-1;i++) printf("%s ",bevarages[topo_order[i]-1]); printf("%s.",bevarages[topo_order[i]-1]); for(i=0;i<V;i++) { for(j=0;j<V;j++) mat[i][j] = 0; topo_order[i]=0; } getchar(); printf("\n\n"); } return(0); }