poj1149PIGS(最大流)

题目请戳这里

题目大意：养猪场有许多猪，关在m个猪圈里，有n个顾客要来买猪，一个一个的来。每个顾客有一些猪圈的钥匙，这个顾客只会买这些猪圈里的猪。顾客买完猪后，养猪场老板可以将这个顾客打开的猪圈里的猪重新分配。求老板能卖出最大数量的猪。

题目分析：网络流。对于菜鸟来说，此题的建图比较难。因为某个顾客打开一些猪圈买完猪后，老板可以将这些打开的猪圈的猪重新分配。所以每个猪圈的猪的数量是动态的，随着顾客买猪的过程不断变化的。所以要使卖猪量尽量大，建图的时候要加一些贪心的策略。以每个顾客为点，再加一个源点和汇点。对于第一个打开某猪圈的顾客，源点与之连一条边，边权为初始猪圈的猪的数量。表示第一个人可以尽量多的买猪。有重边合并之。如果顾客i打开了某猪圈，那么顾客i向下一个打开此猪圈的人建边，边权无穷大。因为顾客i得到满足后，可以通过调整猪圈的猪的数量，尽可能的满足下一个打开此猪圈的顾客，顾客i买完猪后，他所打开的猪圈就是一个整体了，这个整体由第i个顾客代表。最后每个顾客向汇点连一条边，边权为顾客要买的猪的数量。

详情请见代码：

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 110;
const int M = 100005;
const int inf = 0x3f3f3f3f;

struct node
{
    int c,f,pre,next,to;
}arc[M];
int head[N],que[N],cnt[N],dis[N];
int num;
int sta[N],rpath[N];
int pig[1010],last[1010];
bool flag[N][N];
int m,n;
void build(int s,int e,int cap)
{
    arc[num].to = e;
    arc[num].c = cap;
    arc[num].f = 0;
    arc[num].next = head[s];
    head[s] = num ++;
    arc[num - 1].pre = num;
    arc[num].pre = num - 1;
    arc[num].to = s;
    arc[num].c = arc[num].f = 0;
    arc[num].next = head[e];
    head[e] = num ++;
}
void init()
{
    //memset(head,-1,sizeof(head));
    num = 0;
    memset(last,0,sizeof(last));
    memset(flag,false,sizeof(flag));
    int i,a,b,k;
    for(i = 0;i <= n + 1;i ++)
        head[i] = -1;
    for(i = 1;i <= n;i ++)
    {
        scanf("%d",&a);
        while(a --)
        {
            scanf("%d",&k);
            if(last[k] == 0)
            {
                if(flag[0][i] == false)
                {
                    build(0,i,pig[k]);
                    flag[0][i] == true;
                }
                else
                {
                    for(b = head[0];b != -1;b = arc[b].next)
                        if(arc[b].to == i)
                        {
                            arc[b].c += pig[k];
                            break;
                        }
                }
            }
            else
            {
                if(flag[last[k]][i] == false)
                {
                    flag[last[k]][i] = true;
                    build(last[k],i,inf);
                }    
            }    
            last[k] = i;
        }
        scanf("%d",&b);
        build(i,n + 1,b);
    }
}

void re_Bfs()
{
    int i,front,rear;
    for(i = 0;i <= n + 1;i ++)
    {
        dis[i] = n + 2;
        cnt[i] = 0;
    }
    front = rear = 0;
    que[rear ++] = n + 1;
    dis[n + 1] = 0;
    cnt[0] = 1;
    while(front != rear)
    {
        int u = que[front ++];
        for(i = head[u];i != -1;i = arc[i].next)
        {
            if(arc[arc[i].pre].c == 0 || dis[arc[i].to] < n + 2)
                continue;
            dis[arc[i].to] = dis[u] + 1;
            cnt[dis[arc[i].to]] ++;
            que[rear ++] = arc[i].to;
        }
    }
}
void ISAP()
{
    re_Bfs();
    int i,u,v,ret = 0;
    u = 0;
    for(i = 0;i <= n + 1;i ++)
        sta[i] = head[i];
    while(dis[0] < n + 2)
    {
        if(u == n + 1)
        {
            int curflow = inf;
            for(i = 0;i != n + 1;i = arc[sta[i]].to)
                curflow = min(curflow,arc[sta[i]].c);
            for(i = 0;i != n + 1;i = arc[sta[i]].to)
            {
                arc[sta[i]].c -= curflow;
                arc[arc[sta[i]].pre].c += curflow;
                arc[sta[i]].f += curflow;
                arc[arc[sta[i]].pre].f -= curflow;
            }
            ret += curflow;
            u = 0;
        }
        for(i = sta[u];i != -1;i = arc[i].next)
            if(arc[i].c > 0 && dis[u] == dis[arc[i].to] + 1)
                break;
        if(i != -1)
        {
            sta[u] = i;
            rpath[arc[i].to] = arc[i].pre;
            u = arc[i].to;
        }
        else
        {
            if((--cnt[dis[u]]) == 0)
                break;
            sta[u] = head[u];
            int Min = inf;
            for(i = head[u];i != -1;i = arc[i].next)
                if(arc[i].c > 0)
                    Min = min(Min,dis[arc[i].to]);
            dis[u] = Min + 1;
            cnt[dis[u]] ++;
            if(u != 0)
                u = arc[rpath[u]].to;
        }
    }
    printf("%d\n",ret);
}

int main()
{
    int i;
    while(~scanf("%d%d",&m,&n))
    {
        for(i = 1;i <= m;i ++)
            scanf("%d",&pig[i]);
        init();
        ISAP();
    }
    return 0;
}
//224K	0MS