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 = 5000+10;
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,0});
        edges.push_back((Edge){to,from,0,0});
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

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

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

    int Maxflow(int s,int t,int limit) {
        this->s = s;
        this->t = t;
        int flow = 0;
        while(BFS()) {
            memset(cur,0,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=0;i<m;i++) {
            scanf("%d%d",&u[i],&v[i]);
        }
        g.init();
        int day = 1;
        g.clearNodes(0,n-1);
        int flow = 0;
        for(;;) {
            g.clearNodes(day*n,day*n+n-1);
            for(int i=0;i<n;i++)
                g.AddEdge((day-1)*n+i,day*n+i,INF);
            for(int i=0;i<m;i++) {
                g.AddEdge((day-1)*n+u[i]-1,day*n+v[i]-1,1);
                g.AddEdge((day-1)*n+v[i]-1,day*n+u[i]-1,1);
            }
            flow+=g.Maxflow(s-1,day*n+t-1,k-flow);
            if(flow==k) break;
            day++;
        }

        printf("%d
",day);

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

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

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

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

        }

    }

    return 0;
}