POJ 1149 PIGS(最大流)

题意：有m个猪圈，初始值为ai头，有n个人来买猪。第i个人他可能打开某些猪圈，并且他最多买num个，他买后，他打开的猪圈里的猪可以随意的移动到打开的猪圈，然后猪圈关闭，第i+1个人又来买。问这n个人最多能买多少头猪。

分析：建图：源点到猪圈建边容量为猪的初始头数，人到汇点 建边容量为人最多买的猪的头数。

第i个人买猪的时候，再建边（他能打开的猪圈id到他，容量为INF），同时这些能打开的猪圈可能也能被（1~i-1人打开过），所以id能被之前的人打开，就建条边（之前的人到i，容量为INF）。

#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
#define MAXN 11005
#define MAXM 1000005*2
#define LL long long
#define INF 0x3f7f7f7f
const double eps = 1e-10;
struct Edge
{
    int from,to,cap,flow;
    Edge(int from=0,int to=0,int cap=0,int flow=0):from(from),to(to),cap(cap),flow(flow){}
};
vector<Edge>edges;
vector<int>g[MAXN];
bool vis[MAXN];
int d[MAXN];
int cur[MAXN];
int s,t;
void init()
{
    for(int i=0;i<MAXN;i++)
    {
        g[i].clear();
    }
    edges.clear();
}
void add(int from,int to,int cap)
{
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    int 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);
    d[s]=0;
    vis[s]=1;
    while(!q.empty())
    {
        int tx=q.front();
        q.pop();
       int sz=g[tx].size();
        for(int i=0;i<sz;i++)
        {
            Edge e=edges[g[tx][i]];
            if(!vis[e.to]&&e.cap>e.flow)
            {
                vis[e.to]=1;
                d[e.to]=d[tx]+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;
    int sz=g[x].size();
    for(int &i=cur[x];i<sz;i++)
    {
        Edge &e=edges[g[x][i]];
        if(d[x]+1==d[e.to])
        {
            f=dfs(e.to,min(a,e.cap-e.flow));
            if(f>0)
            {
                e.flow+=f;
                edges[g[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0)break;
            }
        }
    }
    return flow;
}
int maxFlow()
{
    int flow=0;

    while(bfs())
    {
        memset(cur,0,sizeof(cur));
        flow+=dfs(s,INF);
    }
    return flow;
}
int cnt[MAXN],m,n;
bool flag[101];
vector<int>man[104];
vector<int>pig[MAXN];
void solve()
{
    int i,j;
    for(i=1;i<=m;i++)
    {
        add(0,i,cnt[i]);//源点到猪圈建边
    }
    for(i=1;i<=n;i++)
    {
        int sz=man[i].size();
        add(i+m,m+n+1,man[i][sz-1]);//人到汇点建边
    }
    s=0,t=n+m+1;
    int ans=0;
    for(i=1;i<=n;i++)
    {
        int sz=man[i].size();
        for(j=0;j<sz-1;j++)
        {
            add(man[i][j],i+m,INF);//当前人能打开的猪圈建边
        }
        int temp=maxFlow();//最大流
        ans+=temp;
        if(i!=n)
       {
            int len=man[i+1].size();
            for(j=0;j<len-1;j++)
            {
                int siz=pig[man[i+1][j]].size();
                for(int k=0;k<siz;k++)
                {//之前打开过此猪圈的人到本次将要买猪的人建边
                    if(pig[man[i+1][j]][k]<=i)
                        add(pig[man[i+1][j]][k]+m,i+1+m,INF);
                }
            }
       }
    }
    printf("%d\n",ans);
}
int main()
{
     int id,num;
    int i,j;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        for(i=0;i<=n;i++)
            man[i].clear();
        for(i=0;i<=m;i++)
            pig[i].clear();
        init();
         for(i=1;i<=m;i++)
            scanf("%d",&cnt[i]);
         for(i=1;i<=n;i++)
         {
             scanf("%d",&num);
             for(j=1;j<=num;j++)
             {

                 scanf("%d",&id);
                man[i].push_back(id);//人能打开的猪圈编号
                pig[id].push_back(i);//猪圈id能被哪些人打开
             }
            scanf("%d",&num);
            man[i].push_back(num);
         }

         solve();
    }
    return 0;
}