拓扑排序关键路径

 输入数据，输出拓扑排序，关键路径(如果有多组解，分情况输出)，一直都是尽量不用STL的，不过有写时候不用确实很麻烦。。

 

输入

9 11
a b c d e f g h i
a b 6
a c 4
a d 5
b e 1
c e 1
d f 2
e g 9
e h 7
f h 4
g i 2
h i 4

输出
a b c e g d f h i
Case #1:
a b e h i

 

Case #2:
a b e g i

 

28. #include<iostream>
29. #include<stdlib.h>
30. #include<list>
31. using namespace std;
32. #define OVERFLOW -2
33. #define OK 1 
34. #define ERROR 0
35. #define N 100
36. typedef int InfoType;
37. typedef char VertexType;
38. typedef int Status;
40. typedef struct ArcNode{
41.         int adjvex;
42.         ArcNode *nextarc;
43.         InfoType info;}ArcNode;
44. typedef struct{
45.         VertexType data;
46.         ArcNode *firstarc;}VNode,*AdjList;
47. typedef struct{
48.         AdjList vertices;
49.         int vexnum,arcnum;}Graph;
50. int LocateGraph(Graph G,VertexType v) 
51. { 
52.     for(int i=0;i<G.vexnum;i++) 
53.             if(G.vertices[i].data==v) return i; 
54.     return G.vexnum;
55. }
56.     
57.     
58. Status CreateGraph(Graph &G)
59. {
60.        cin>>G.vexnum>>G.arcnum;
61.        if(!(G.vertices=new VNode[G.vexnum])) exit(OVERFLOW);
62.        int i,j,k;
63.        for(i=0;i<G.vexnum;i++)
64.        {
65.               cin>>G.vertices[i].data;
66.               G.vertices[i].firstarc=NULL;
67.        }
68.        VertexType v1,v2;
69.        int value;
70.        ArcNode *p,*q;
71.        for(k=0;k<G.arcnum;k++)
72.        {
73.               do{
74.                  cin>>v1>>v2>>value;
75.                  i=LocateGraph(G,v1);
76.                  j=LocateGraph(G,v2);
77.                  }while(i==G.vexnum||j==G.vexnum);
78.               if(!(p=new ArcNode)) exit(OVERFLOW);
79.               p->adjvex=j; p->info=value;p->nextarc=G.vertices[i].firstarc;
80.               G.vertices[i].firstarc=p;
81.        } 
82.        return OK; 
83. }
85. void FindInDegree(Graph G,int *indegree)
86. {
87.         for(int i=0;i<G.vexnum;i++)
88.                 for(ArcNode *p=G.vertices[i].firstarc;p;p=p->nextarc)
89.                             ++indegree[p->adjvex];
90. }
92. Status TopologicalOrder(Graph G,int *&T,int *&ve,int *&indegree_0)
93. {
94.        int *indegree=new int[G.vexnum],i,k=0,top=-1;
95.        ve=new int[G.vexnum];
96.        T=new int[G.vexnum];
97.        if(!ve||!T||!indegree) exit(OVERFLOW);
98.        for(i=0;i<G.vexnum;i++)
99.              indegree[i]=ve[i]=T[i]=0,indegree_0[i]=-1;   
100.        FindInDegree(G,indegree);
101.        for(i=0;i<G.vexnum;i++)
102.        {      if(!indegree[i]) 
103.               {
104.                   indegree[i]=top,top=i;
105.                   indegree_0[k++]=i;
106.               }
107.        }          
108.        for(k=i=0;i<G.vexnum;i++)
109.        {
110.              if(top==-1) return ERROR;
111.              int cur=top;
112.              T[k++]=cur;
113.              cout<<G.vertices[cur].data<<" ";
114.              top=indegree[top];
115.              for(ArcNode *p=G.vertices[cur].firstarc;p;p=p->nextarc)
116.              {           if(!--indegree[p->adjvex]) indegree[p->adjvex]=top,top=p->adjvex;
117.                          if(ve[cur]+p->info>ve[p->adjvex]) ve[p->adjvex]=ve[cur]+p->info;             
118.              }
119.       
120.        }
121.        cout<<endl;
122.        return OK;
123. }
124. list<int> vlist[N];
126. void Output(Graph G,int a)
127. {
128.      static int res[N],idx=0,n=1;
129.      if(vlist[a].empty())
130.      {
131.             if(idx)
132.             {
133.                    cout<<"Case #"<<n<<":"<<endl;
134.                    for (int i = 0; i < idx; ++i) 
135.                        cout<<G.vertices[res[i]].data<<" ";
136.                    cout<<G.vertices[a].data<<endl<<endl;
137.                    n++;
138.             }
139.      }
140.     res[idx++]=a; 
141.     for(list<int>::const_iterator iter = vlist[a].begin();iter != vlist[a].end(); ++iter) 
142.         Output(G,*iter); 
143.     --idx; 
144. } 
146. Status CriticalPath(Graph G){
147.        int i,j,*T,*ve,*indegree_0,*vl=new int[G.vexnum];
148.        indegree_0=new int[G.vexnum];
149.        if(!vl||!indegree_0) exit(OVERFLOW);
150.        if(!(TopologicalOrder(G,T,ve,indegree_0))) return ERROR;
151.        for(i=0;i<G.vexnum;i++)    
152.               vl[i]=INT_MAX;
153.        i=T[G.vexnum-1];
154.        vl[i]=ve[i];
155.        for(j=G.vexnum-1;j>=0;j--)
156.        {      
157.              i=T[j];
158.              for(ArcNode *p=G.vertices[i].firstarc;p;p=p->nextarc)
159.                          if(vl[p->adjvex]-p->info<vl[i]) vl[i]=vl[p->adjvex]-p->info;
160.        }
161.        for(j=0;j<G.vexnum;j++)
162.               for(ArcNode *p=G.vertices[j].firstarc;p;p=p->nextarc)
163.                    if(ve[j]==vl[p->adjvex]-p->info)
164.                           vlist[j].push_back(p->adjvex);         
165.        for(j=0;indegree_0[j]!=-1;j++)
166.             Output(G,indegree_0[j]);
167. } 
168.        
169. int main(){
170.     Graph G;
171.     CreateGraph(G);
172.     CriticalPath(G);
173.     return 0;}