Persistent::Base::Error BayesNet::read(StreamIO &sio, int, int) { bool err = !sio.read( &nextNodeId ); int numNodes = 0; int numSVals; if ( !err && sio.read( &numSVals ) ) for ( int i=0; i<numSVals; i++ ) { float val; err = !sio.read(&val); statePointer->push_back( new StateValue(val) ); } if ( !err ) err = !sio.read( &numNodes ); Error error=Ok; for ( int i=0; !err && !error && i<numNodes; i++ ) { Persistent::Base *base = Persistent::Base::load( sio, &error ); BayesNode *pBN = dynamic_cast<BayesNode *>(base); if ( pBN && (error == Ok) ) { addNode( pBN ); pBN->resolveParents(); } } TopologicalSort(); return ((!err)? Persistent::Base::Ok : Persistent::Base::ReadError); }
void TGraphCascade::PruneGraph() { // iterate over nodes int Nodes = NodeNmIdH.Len(); TIntV NodeIdV; NodeNmIdH.GetDatV(NodeIdV); TStrV NodeNmV; NodeNmIdH.GetKeyV(NodeNmV); for (int NodeN = 0; NodeN < Nodes; NodeN++) { int NodeId = NodeIdV[NodeN]; if (!EnabledNodeIdH.IsKey(NodeId)) { // if a node is not enabled: // - connect its parents to its children TNGraph::TNodeI NI = Graph.GetNI(NodeId); for (int ParentN = 0; ParentN < NI.GetInDeg(); ParentN++) { for (int ChildN = 0; ChildN < NI.GetOutDeg(); ChildN++) { if (!Graph.IsEdge(NI.GetInNId(ParentN), NI.GetOutNId(ChildN))) { Graph.AddEdge(NI.GetInNId(ParentN), NI.GetOutNId(ChildN)); } } } //printf("deleting node %s %d\n", NodeNmV[NodeN].CStr(), NodeId); // - delete it (deletes edges) Graph.DelNode(NodeId); } } // generate search sequence from sinks to sources TopologicalSort(NIdSweep); //Print(NIdSweep); }
void main() { ALGraph f; printf("请选择有向图\n"); CreateGraph(&f); Display(f); TopologicalSort(f); }
int main(void) { MGraph G; GraphAdjList GL; int result; CreateMGraph(&G); CreateALGraph(G,&GL); result=TopologicalSort(GL); printf("result:%d",result); return 0; }
void calculate_topological_sort_result_index(GRAPHIC_TYPE graphic,int* topological_sort_result_index) { ElementType *topological_sort_result; TopologicalSort(graphic, &topological_sort_result); int i = 0; for (i = 0; i < graphic -> vertex_count; i++) { int vertex_value = topological_sort_result[i]; AdjacentMatrixGraphicVertex *vertex = GetVertex(graphic, vertex_value); topological_sort_result_index[i] = vertex - graphic -> vertex_list; } free(topological_sort_result); }
/* 求关键路径,GL为有向网,输出G的各项关键活动 */ void CriticalPath(GraphAdjList GL) { EdgeNode *e; int i,gettop,k,j; int ete,lte; /* 声明活动最早发生时间和最迟发生时间变量 */ TopologicalSort(GL); /* 求拓扑序列,计算数组etv和stack2的值 */ ltv=(int *)malloc(GL->numVertexes*sizeof(int));/* 事件最早发生时间数组 */ for(i=0; i<GL->numVertexes; i++) ltv[i]=etv[GL->numVertexes-1]; /* 初始化 */ printf("etv:\t"); for(i=0; i<GL->numVertexes; i++) printf("%d -> ",etv[i]); printf("\n"); while(top2!=0) /* 出栈是求ltv */ { gettop=stack2[top2--]; for(e = GL->adjList[gettop].firstedge; e; e = e->next) /* 求各顶点事件的最迟发生时间ltv值 */ { k=e->adjvex; if(ltv[k] - e->weight < ltv[gettop]) ltv[gettop] = ltv[k] - e->weight; } } printf("ltv:\t"); for(i=0; i<GL->numVertexes; i++) printf("%d -> ",ltv[i]); printf("\n"); for(j=0; j<GL->numVertexes; j++) /* 求ete,lte和关键活动 */ { for(e = GL->adjList[j].firstedge; e; e = e->next) { k=e->adjvex; ete = etv[j]; /* 活动最早发生时间 */ lte = ltv[k] - e->weight; /* 活动最迟发生时间 */ if(ete == lte) /* 两者相等即在关键路径上 */ printf("<v%d - v%d> length: %d \n",GL->adjList[j].data,GL->adjList[k].data,e->weight); } } }
int main() { int T; scanf("%d", &T); for (int t = 0; t < T; ++t) { std::vector<std::string> words; scanf("%d", &N); for (int i = 0; i < N; ++i) { char buf[128]; scanf("%s", buf); words.push_back(buf); } MakeGraph(words); std::vector<int> r = TopologicalSort(); PrintVInt(r); } // return 0; }
/** * 算法7.14,G为有向网,输出G的各项关键活动 * 栈T中保存图G的拓补序列,ve数组中为各顶点的最早开始时间 */ Status CriticalPath(ALGraph G, SqStack &T, int ve[]) { int i, j, k, dut, ee ,el; ArcNode *p; int vl[MAX_VERTEX_NUM]; if (ERROR == TopologicalSort(G, T, ve)) { return ERROR; } for (i = 0; i < G.vexnum; i++) { //初始化顶点的最迟发生时间 vl[i] = ve[G.vexnum-1]; } while (!StackEmpty(T)) { //按拓补逆序求各顶点的最晚开始时间vl值 Pop(T, j); for (p = G.vertices[j].firstarc; p != NULL; p = p->nextarc) { k = p->adjvex; dut = atoi(p->info); //活动时间 if (vl[k] - dut < vl[j]) { vl[j] = vl[k] - dut; } } } printf("关键活动:"); for (j = 0; j < G.vexnum; j++) { //求活动的最早开始时间和最晚开始时间,并求出关键活动 for (p = G.vertices[j].firstarc; p != NULL; p = p->nextarc) { k = p->adjvex; dut = atoi(p->info); ee = ve[j]; //活动的最早开始时间 el = vl[k]-dut; //活动的最晚开始时间 if (ee == el) { //关键活动 printf("%c%c ", G.vertices[j].data, G.vertices[k].data); } } } printf("\n"); }
bool CriticalGraph::ComputeCriticalPath( const CriticalNode* from, const CriticalNode* to, const std::unordered_set<uint32_t>& tids, CriticalPath* path) const { assert(from != nullptr); assert(to != nullptr); assert(path != nullptr); // Topological sort. std::vector<const CriticalNode*> topological; if (!TopologicalSort(from, to, &topological)) { tberror() << "Destination node wasn't found in topological sort." << tbendl(); return false; } // Compute maximum distance from destination for each node. std::unordered_map<const CriticalNode*, NodeDistance> distances; for (auto it = topological.rbegin(); it != topological.rend(); ++it) { // If the node is the destination, the distance is zero. if (*it == to) { distances[*it] = NodeDistance(0, kInvalidCriticalEdgeId); continue; } // Compute the 2 possible distances. size_t horizontal_distance = kHugeDistance; CriticalEdgeId horizontal_edge_id = (*it)->edge(kCriticalEdgeOutHorizontal); if (horizontal_edge_id != kInvalidCriticalEdgeId) { const auto& edge = GetEdge(horizontal_edge_id); auto distance_look = distances.find(edge.to()); if (distance_look != distances.end()) { horizontal_distance = distance_look->second.distance; if (horizontal_distance != kHugeDistance) { if (tids.find((*it)->tid()) == tids.end()) { // Reduce the cost of edges that are on other threads. horizontal_distance = std::min(horizontal_distance, static_cast<size_t>(1)); } horizontal_distance += edge.Cost(); } } } size_t vertical_distance = kHugeDistance; CriticalEdgeId vertical_edge_id = (*it)->edge(kCriticalEdgeOutVertical); if (vertical_edge_id != kInvalidCriticalEdgeId) { const auto& edge = GetEdge(vertical_edge_id); auto distance_look = distances.find(edge.to()); if (distance_look != distances.end()) { vertical_distance = distance_look->second.distance; if (vertical_distance != kHugeDistance) vertical_distance += edge.Cost(); } } // Keep the maximum distance which is not invalid. if (horizontal_distance != kHugeDistance && (vertical_distance == kHugeDistance || horizontal_distance >= vertical_distance)) { distances[*it] = NodeDistance(horizontal_distance, horizontal_edge_id); } else if (vertical_distance != kHugeDistance && (horizontal_distance == kHugeDistance || vertical_distance >= horizontal_distance)) { distances[*it] = NodeDistance(vertical_distance, vertical_edge_id); } } // Retrieve the critical path. const CriticalNode* cur = from; while (cur != to) { const NodeDistance& distance = distances[cur]; const CriticalEdge& edge = GetEdge(distance.edge); if (edge.type() != CriticalEdgeType::kVertical) { path->Push(CriticalPathSegment( edge.from()->ts(), edge.from()->tid(), edge.type())); } cur = GetEdge(distance.edge).to(); } // Restrict the critical path to the autorized threads. path->RestrictToThreads(tids); return true; }