sgu185Two shortest 最短路+网络流+输出路径

1. 其实就是先最短路，把所有最短路的边保存下来，之后求网络流
2. 如果网络流>=2,我们就dfs输出所有的路径即可。
3. 
   
4. 
   
5. #include<iostream>  
6. #include<cstdio>  
7. #include<cstring>  
8. #include<algorithm>  
9. #include<queue>  
10. using namespace std;  
11.   
12. const int MAXN = 410;  
13. const int MAXM = 260100;  
14. const int INF = 0x3f3f3f3f;  
15.   
16. struct Edge  
17. {  
18.     int to, next, cap;  
19. };  
20.   
21. Edge edge[MAXM];  
22. int level[MAXN];  
23. int head[MAXN];  
24. int dist[MAXN];  
25. int map[MAXN][MAXN];  
26. int src, des, cnt, flag;  
27.   
28. void SPFA(int n)  
29. {  
30.     int inqueue[MAXN];  
31.     memset( dist, INF, sizeof dist );  
32.     memset( inqueue, 0, sizeof inqueue );  
33.     dist[1] = 0;      
34.     deque<int> dq;  
35.     dq.push_back( 1 );  
36.     inqueue[1] = 1;  
37.   
38.     while(!dq.empty())  
39.     {  
40.         int next = dq.front();  
41.         dq.pop_front();  
42.         inqueue[next] = 0;  
43.         for(int i = 1; i <= n; i++)  
44.         {  
45.             if(dist[i] > dist[next] + map[next][i])  
46.             {  
47.                 dist[i] = dist[next] + map[next][i];  
48.                 if(!inqueue[i])  
49.                 {  
50.                     if(!dq.empty() && dist[i] > dist[dq.front()])  
51.                         dq.push_front( i );  
52.                     else  
53.                         dq.push_back( i );  
54.                 }  
55.             }  
56.         }  
57.     }  
58. }  
59.   
60. void addedge( int from, int to, int cap )  
61. {  
62.     edge[cnt].to = to;  
63.     edge[cnt].cap = cap;  
64.     edge[cnt].next = head[from];  
65.     head[from] = cnt++;  
66.   
67.     swap( from, to );  
68.   
69.     edge[cnt].to = to;  
70.     edge[cnt].cap = 0;  
71.     edge[cnt].next = head[from];  
72.     head[from] = cnt++;  
73. }  
74.   
75. int bfs()  
76. {  
77.     memset( level, -1, sizeof level );  
78.     cnt = 0;  
79.     queue<int> q;  
80.     while (!q.empty())  
81.         q.pop();  
82.     level[src] = 0;  
83.     q.push( src );  
84.   
85.     while (!q.empty())  
86.     {  
87.         int u = q.front();  
88.         q.pop();  
89.   
90.         for (int i = head[u]; i != -1; i = edge[i].next)  
91.         {  
92.             int v = edge[i].to;  
93.             if (edge[i].cap > 0 && level[v] == -1)  
94.             {  
95.                 level[v] = level[u] + 1;  
96.                 q.push( v );  
97.             }  
98.         }  
99.     }  
100.     return level[des] != -1;  
101. }  
102.   
103. int dfs( int u, int f )  
104. {  
105.     if (u == des) return f;  
106.     int tem;  
107.   
108.     for (int i = head[u]; i != -1; i = edge[i].next)  
109.     {  
110.         int v = edge[i].to;  
111.         if (edge[i].cap > 0 && level[v] == level[u] + 1)  
112.         {  
113.             tem = dfs( v, min( f, edge[i].cap ) );  
114.             if (tem > 0)  
115.             {  
116.                 edge[i].cap -= tem;  
117.                 edge[i^1].cap += tem;  
118.                 return tem;  
119.             }  
120.         }  
121.     }  
122.     level[u] = -1;  
123.     return 0;  
124. }  
125.   
126. int Dinic()  
127. {  
128.     int ans = 0, tem;  
129.     while (bfs())  
130.     {  
131.         while ((tem = dfs( src, INF )) > 0)  
132.         {  
133.             ans += tem;  
134.         }  
135.     }  
136.     return ans;  
137. }  
138.   
139. void print( int n, int u )  
140. {  
141.     if(u != n)  
142.     {  
143.         printf( "%d ", u );  
144.     }  
145.     else  
146.     {  
147.         printf( "%d\n", u );  
148.         flag = true;  
149.         return;  
150.     }  
151.   
152.     for(int i = head[u]; i != -1&&!flag; i = edge[i].next)  
153.     {  
154.         int v = edge[i].to;  
155.         if(edge[i].cap == 0 && i % 2 == 0)  
156.         {  
157.             edge[i].cap = -1;  
158.             print( n, v );  
159.         }  
160.     }  
161. }  
162.   
163. int main()  
164. {  
165.     int n,m;  
166.     while(cin >> n >> m)  
167.     {  
168.         src = 1, des = n;  
169.         memset( head, -1, sizeof head );  
170.         memset( map, INF, sizeof map );  
171.         for(int i = 1; i <= n; i++)  
172.             map[i][i] = 0;  
173.         cnt = 0;  
174.   
175.         int a, b, c;  
176.         for(int i = 1; i <= m; i++)  
177.         {  
178.             cin >> a >> b >> c;  
179.             map[a][b] = map[b][a] = c;  
180.         }  
181.         SPFA( n );  
182.   
183.         for(int i = 1; i <= n; i++)  
184.         {  
185.             for(int j = 1; j <= n; j++)  
186.             {  
187.                 if(dist[i] + map[i][j] == dist[j])  
188.                 {  
189.                     addedge( i, j, 1 );  
190.                 }  
191.             }  
192.         }  
193.         int ans = Dinic();  
194.         if(ans < 2)  
195.             cout << "No solution" << endl;  
196.         else  
197.         {  
198.             print( n,src );  
199.             flag = false;  
200.             print( n, src );  
201.         }  
202.     }  
203.     return 0;  
204. }