LA 2957 最大流，最短时间，输出路径

题目链接：https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&category=159&page=show_problem&problem=958

题意：n个星球，用最短的时间把k个超级计算机从s运到t；

其中，每个隧道是双向的，一个隧道里面只能有一个飞船在使用，一个飞船上只有一台计算机。

分析：

一个隧道只能给一个飞船用，那么假设需要t天，那么可以这样建图:

u结点，拆成t+1个，分别是 u0,u1,u2,...,ut;

u0是u的初始状态，ui是u在第i天的状态，那么建图就是:

a结点到b结点，ai 到 bi+1 一条容量为1的边，bi 到 ai+1 的容量为1的一条边。

对于每个结点，都有ui到ui+1 的容量是无穷大，因为可以停留。

一天一天增加结点，终点也发生变化，流量直到为k，就结束了。

然后输出路径：

遍历原图的上的每一条边，注意edges是残余网络，idx+=2;这才加了一条边。

问题问的路径是（A,B）编号为A的飞机，到达行星 B，行星B就是有流量的那一条边都后面那个结点。那么，编号A怎么求呢？

可以遍历一下这k个飞机，如果 j 所在的位置location[j] = a[i] 的话，就ok了。

 #include <bits/stdc++.h>

 using namespace std;

 const int maxn = +;
 const int INF = 0x3f3f3f3f;

 struct Edge{
     int from,to,cap,flow;
 };

 bool operator < (const Edge& a,const Edge& b) {
     return a.from < b.from||(a.from==b.from&&a.to<b.to);
 }

 struct Dinic {
     int n,m,s,t;
     vector<Edge> edges;
     vector<int> G[maxn];
     bool vis[maxn];
     int d[maxn];
     int cur[maxn];

     void init() {
         edges.clear();
     }

     void clearNodes(int a,int b) {
         for(int i=a;i<=b;i++)
             G[i].clear();
     }

     void AddEdge(int from,int to,int cap) {
         edges.push_back((Edge){from,to,cap,});
         edges.push_back((Edge){to,from,,});
         m = edges.size();
         G[from].push_back(m-);
         G[to].push_back(m-);
     }

     bool BFS() {
         memset(vis,,sizeof(vis));
         queue<int> Q;
         Q.push(s);
         vis[s] = ;
         d[s] = ;
         while(!Q.empty()) {
             int x = Q.front();  Q.pop();
             for(int i=;i<G[x].size();i++) {
                 Edge& e = edges[G[x][i]];
                 if(!vis[e.to]&&e.cap>e.flow) {
                     vis[e.to] = ;
                     d[e.to] = d[x] + ;
                     Q.push(e.to);
                 }
             }
         }
         return vis[t];
     }

     int DFS(int x,int a) {
         if(x==t||a==) return a;
         int flow = ,f;
         for(int& i=cur[x];i<G[x].size();i++) {
             Edge& e = edges[G[x][i]];
             if(d[x]+==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>) {
                 e.flow +=f;
                 edges[G[x][i]^].flow-=f;
                 flow+=f;
                 a-=f;
                 if(a==) break;
             }
         }
         return flow;
     }

     int Maxflow(int s,int t,int limit) {
         this->s = s;
         this->t = t;
         int flow = ;
         while(BFS()) {
             memset(cur,,sizeof(cur));
             flow +=DFS(s,limit-flow);
             if(flow==limit) break;
         }
         return flow;
     }
 };

 Dinic g;

 int main()
 {
     int n,m,k,s,t;
     int u[maxn],v[maxn];

     while(~scanf("%d%d%d%d%d",&n,&m,&k,&s,&t)) {
         for(int i=;i<m;i++) {
             scanf("%d%d",&u[i],&v[i]);
         }
         g.init();
         int day = ;
         g.clearNodes(,n-);
         int flow = ;
         for(;;) {
             g.clearNodes(day*n,day*n+n-);
             for(int i=;i<n;i++)
                 g.AddEdge((day-)*n+i,day*n+i,INF);
             for(int i=;i<m;i++) {
                 g.AddEdge((day-)*n+u[i]-,day*n+v[i]-,);
                 g.AddEdge((day-)*n+v[i]-,day*n+u[i]-,);
             }
             flow+=g.Maxflow(s-,day*n+t-,k-flow);
             if(flow==k) break;
             day++;
         }

         printf("%d\n",day);

         int idx = ;
         vector<int> location(k,s);

         for(int d=;d<=day;d++) {
             idx +=n*;
             vector<int> moved(k,);
             vector<int> a,b;

             for(int i=;i<m;i++) {
                 int f1 = g.edges[idx].flow; idx+=;
                 int f2 = g.edges[idx].flow; idx+=;
                 if(f1==&&f2==) {
                     a.push_back(u[i]);
                     b.push_back(v[i]);
                 }
                 if(f1==&&f2==) {
                     a.push_back(v[i]);
                     b.push_back(u[i]);
                 }
             }

             printf("%d",a.size());
             for(int i=;i<a.size();i++) {
                 for(int j=;j<k;j++) {  //找到具体是哪一个飞船
                     if(!moved[j]&&location[j]==a[i]) {
                         printf(" %d %d",j+,b[i]);
                         moved[j] = ;
                         location[j] = b[i];
                         break;
                     }
                 }
             }
             printf("\n");

         }

     }

     return ;
 }