SGU 185 Two shortest 最短路+最大流

题目链接：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=21068

Yesterday Vasya and Petya quarreled badly, and now they don't want to see each other on their way to school. The problem is that they live in one and the same house, leave the house at the same time and go at the same speed by the shortest road. Neither of them wants to change their principles, that is why they want to find two separate shortest routes, which won't make them go along one road, but still they can meet at any junction. They ask you to help them. They number all the junctions with numbers from 1 to N (home and school are also considered as junctions). So their house has the number 1 and the school has the number N, each road connects two junctions exactly, and there cannot be several roads between any two junctions.

题意描述：有n个节点，找出1～n的两条不相交的最短路（两条路径可以共点不能共边）。

算法分析：用spfa求出点1到各个点的最短路径，然后再if(d[j]==d[i]+dis[i][j]) 来判断边dis[i][j]是否是在最短路径上，如果是就加到图里，结果就得到以1为顶点的最短路径树，1到树中任意一点的连线都是最短路径，首先把这些边加到网络流的边集中，容量为1。跑一遍1到n的最大流，如果流量>=2则有解，再从原点深搜路径即可。

说明：这道题很卡内存和时间，MLE！MLE！MLE！M出翔了。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #define inf 10737418
 using namespace std;
 typedef long long ll;
 const int maxn=+;
 const int M = +;

 int n,m,from,to;
 struct Edge
 {
     int to,cap;
     int next;
 }edge[M*];
 int head[maxn],edgenum;

 void add(int u,int v,int cap)
 {
     Edge E={v,cap,head[u]};
     edge[edgenum]=E;
     head[u]=edgenum++;

     Edge E2={u,,head[v]};
     edge[edgenum]=E2;
     head[v]=edgenum++;
 }

 int d[maxn];
 bool BFS()
 {
     memset(d,-,sizeof(d));
     d[from]=;
     queue<int> Q;
     Q.push(from);
     while (!Q.empty() ){
         int u=Q.front(); Q.pop();
         for (int i=head[u] ;i!=- ;i=edge[i].next)
         {
             int v=edge[i].to;
             if (d[v]==- && edge[i].cap)
             {
                 d[v]=d[u]+,Q.push(v);
                 if (d[to] != -) return true;
             }
         }
     }
     return false;
 }
 int Stack[maxn], top, cur[maxn];
 int Dinic(){
     int ans=;
     while(BFS())
     {
         memcpy(cur, head, sizeof(head));
         int u = from;      top = ;
         while()
         {
             if(u == to)
             {
                 int flow = inf, loc;//loc 表示 Stack 中 cap 最小的边
                 for(int i = ; i < top; i++)
                     if(flow > edge[ Stack[i] ].cap)
                     {
                         flow = edge[Stack[i]].cap;
                         loc = i;
                     }

                     for(int i = ; i < top; i++)
                     {
                         edge[ Stack[i] ].cap -= flow;
                         edge[Stack[i]^].cap += flow;
                     }
                     ans += flow;
                     top = loc;
                     u = edge[Stack[top]^].to;
             }
             for(int i = cur[u]; i!=-; cur[u] = i = edge[i].next)//cur[u] 表示u所在能增广的边的下标
                 if(edge[i].cap && (d[u] +  == d[ edge[i].to ]))break;
             if(cur[u] != -)
             {
                 Stack[top++] = cur[u];
                 u = edge[ cur[u] ].to;
             }
             else
             {
                 if( top ==  )break;
                 d[u] = -;
                 u = edge[ Stack[--top]^ ].to;
             }
         }
     }
     return ans;
 }
 int dis[maxn][maxn];
 int vis[maxn];
 void spfa()
 {
     for (int i= ;i<=n ;i++) d[i]=inf;
     d[]=;
     memset(vis,,sizeof(vis));
     queue<int> Q;
     Q.push();
     vis[]=;
     while (!Q.empty())
     {
         int u=Q.front() ;Q.pop() ;
         vis[u]=;
         for (int v= ;v<=n ;v++)
         {
             if (d[v]>d[u]+dis[u][v])
             {
                 d[v]=d[u]+dis[u][v];
                 if (!vis[v])
                 {
                     vis[v]=;
                     Q.push(v);
                 }
             }
         }
     }
 }
 void dfs(int u, int fa)
 {
     if (u == n){printf("%d\n",u);return ;}
     else printf("%d ",u);
     for (int i = head[u] ;i!=- ;i=edge[i].next)
     {
         if (edge[i^].cap !=  || (i&)) continue;
         int v=edge[i].to;
         if (v == fa) continue;
         edge[i^].cap=;
         dfs(v, u);
         return;
     }
 }

 int main()
 {
     while (scanf("%d%d",&n,&m)!=EOF)
     {
         memset(head,-,sizeof(head));
         edgenum=;
         int a,b,c;
         for (int i= ;i<=n ;i++)
             for (int j= ;j<=n ;j++)
                 dis[i][j]=inf;
         for (int i= ;i<m ;i++)
         {
             scanf("%d%d%d",&a,&b,&c);
             dis[a][b] = dis[b][a] = min(dis[a][b], c);
         }
         spfa();
         if (d[n]==inf) {printf("No solution\n");continue; }
         from=;
         to=n+;
         for (int i= ;i<=n ;i++)
         {
             for (int j= ;j<=n ;j++)
             {
                 if(dis[i][j]!=inf && d[j] == dis[i][j] + d[i])
                     add(i,j,);
             }
         }
         add(n,to,);
         int sum=Dinic();
         if (sum<) {printf("No solution\n");continue; }
         dfs(,);
         dfs(,);
     }
     return ;
 }