uvalive 2957 Bring Them There(最大流)

题目大意：

n个星球，编号为1~n，m条双向通道，任意两个星期之间最多只有一条通道。现有k个计算机从S送往T，每条通道每次只能送一台计算机，花费1天。问最少需要多少天才能把k个计算机全部从S送到T。题目保证有解。

一、建图：

1、将N个星球作为点，拆为T+1个点，u0,u1,u2,……uT，ui表示在第i天时的星球u

2、ui到ui+1连一条边，容量为无穷。这样可以使前一天没有从i点运输出去的计算机(流量)保留下来，在该天运输出去。

3、对于原图中的边(a,b)，ai到bi+1，bi到ai+1连一条边(因为是双向的)，容量为1。

4、T从1开始递增，每次新加一层结点，在原最大流基础上继续增广，直到流量为k。

二、输出：

用一个pos数组记录前一天第i个计算机所在星球，初始化为S。

对于第i(i>=1)天，看该天对应的流量。将有流量的边的两个顶点ai,bi+1记录下来。注意ai到bi+1，bi到ai+1不能同时有流量！

然后枚举当天有流量的边，为计算机分配运输并输出即可，并修改pos值。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstdlib>
#include<cstring>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef unsigned int uI;
typedef double db;
#define maxn 5005
#define inf 0x3f3f3f3f
struct Edge
{
    int to,cap,next;
}edge[1000005];

int cnt,head[maxn],d[maxn],s,t;

inline void add(int u,int v,int w)
{
    edge[cnt].to=v;
    edge[cnt].cap=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    edge[cnt].to=u;
    edge[cnt].cap=0;
    edge[cnt].next=head[v];
    head[v]=cnt++;
}

inline bool bfs()   //BFS构造层次图
{
    int u,i;
    queue<int> q;
    q.push(s);
    memset(d,0,sizeof(d));
    d[s]=1;
    while(!q.empty())
    {
        u=q.front();q.pop();
        if(u==t) return true;   //汇点的层次被算出即可停止，因为根据DFS的规则，和汇点同层或更下一层的结点是不可能走到汇点的。
        for(i=head[u];~i;i=edge[i].next){
            int v=edge[i].to;
            if(!d[v]&&edge[i].cap)
            {
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return false;
}

int dfs(int u,int a)  //当前结点、目前为止所有弧的最小残量
{
    int flow=0,f,i;
    if(u==t||a==0) return a;
    for(i=head[u];~i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(edge[i].cap&&d[v]==d[u]+1)   //满足容量不为0且另一端是下一层次
        {
            f=dfs(v,min(a,edge[i].cap));
            edge[i].cap-=f; //削减路径上各边的容量
            edge[i^1].cap+=f;//添加反向边
            flow+=f;    //增加总流量
            a-=f;   //该结点之前的弧的最小残量削减f后的值
            if(!a) break;   //若为0，则无需再从该结点寻找增广路，因为位于该结点之前的某条弧削减f后会为0，导致无法从源点经过该结点再增广到汇点
        }
    }
    if(flow==0) d[u]=0; //从该点出发找不到增广路，则将该点从层次图中去掉
    return flow;
}

int dinic(int need)
{
    int flow=0;
    while(bfs())
    {
        flow+=dfs(s,need-flow);//这里必须是need-flow，inf会WA，暂时不明白为什么。
        if(flow>=need) return flow;
    }
    return flow;
}

int a[205],b[205],pos[55];
int main()
{
    int i,j,k,m,n;
    while(~scanf("%d%d%d%d%d",&n,&m,&k,&s,&t))
    {
        cnt=0;
        memset(head,-1,sizeof(head));
        for(i=0;i<m;++i) scanf("%d%d",&a[i],&b[i]);
        int T=0,max_flow=0;
        while(max_flow<k)
        {
            ++T;
            for(i=1;i<=n;++i) add(i+(T-1)*n,i+T*n,inf);
            for(i=0;i<m;++i)
            {
                add(a[i]+(T-1)*n,b[i]+T*n,1);
                add(b[i]+(T-1)*n,a[i]+T*n,1);
            }
            t+=n;
            max_flow+=dinic(k-max_flow);
        }
        printf("%d\n",T);
        for(i=1;i<=k;++i) pos[i]=s;
        for(i=1;i<=T;++i)
        {
            vector<int>u,v;
            bool vis[55];
            memset(vis,0,sizeof(vis));
            for(j=0;j<4*m;j+=4)
            {
                int p=j+(i-1)*4*m+n*i*2;//第i天的边对应编号
                if(edge[p].cap==0&&edge[p+2].cap!=0)
                {
                    u.push_back(edge[p^1].to-(i-1)*n);
                    v.push_back(edge[p].to-i*n);
                }
                else if(edge[p].cap!=0&&edge[p+2].cap==0)
                {
                    u.push_back(edge[(p+2)^1].to-(i-1)*n);
                    v.push_back(edge[p+2].to-i*n);
                }
            }
            printf("%d",u.size());
            for(int p=0;p<(int)u.size();++p)
                for(j=1;j<=k;++j)
                    if(!vis[j]&&pos[j]==u[p])
                    {
                        vis[j]=1;
                        printf(" %d %d",j,v[p]);
                        pos[j]=v[p];
                        break;
                    }
            puts("");
        }
    }
    return 0;
}