POJ 1149 PIGS

        题目传送门：POJ 1149 PIGS

        题目大意是说有 m 个猪圈，每个猪圈中有一定数量的猪。有 n 个人，分别在不同的日子里来买猪，每个人买猪的时候指定买哪些猪圈中的猪，在卖猪这天，主人可以随意的调整猪圈中的猪的数量，然后关上猪圈，等待下一个买猪的人到来，每个顾客分别有个买猪数量的上限。问主人通过合理的安排之后，最多能卖多少猪？

        网络流，建图方法：

            1、增加源点（source）和汇点（sink）

            2、每个人向汇点连一条容量为买猪上限的边

            3、对于每个人买猪所指定的猪圈

                1）、如果这个猪圈从未打开过，连一条从源点到这个人的边，容量为该猪圈中猪的数量

                2）、如果这个猪圈被打开过，连一条从最后一次打开这个猪圈的人到现在这个人的边，容量为无穷大

        这样，对建好的图跑一遍最大流，就是最多能够卖出的猪的数量了

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <cmath>

#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <list>
#include <algorithm>

using namespace std;

typedef long long LL;
typedef double DB;
typedef unsigned long long ULL;
typedef unsigned int Uint;

const int INT_INF=0x3fffffff;
const LL LL_INF=0x3fffffffffffffff;
const DB EPS=1e-9;
const DB PI=3.14159265358979323846;
const int N=110;
const int E=10010;

#define PB push_back
#define MP make_pair
#define MH make_heap
#define PH push

struct Edge
{
    int en,cap,flow,next;
} edge[E];
int head[N] , tot , now[N];
int source,sink,tot_num;
int pre[N] , dis[N] , gap[N];
queue<int> q;

void add_edge(int st,int en,int cap)
{
    edge[tot].en=en;
    edge[tot].cap=cap;
    edge[tot].flow=0;
    edge[tot].next=head[st];
    head[st]=tot++;

    edge[tot].en=st;
    edge[tot].cap=0;
    edge[tot].flow=0;
    edge[tot].next=head[en];
    head[en]=tot++;
}

void bfs()
{
    memset(dis,-1,sizeof(dis));
    memset(gap,0,sizeof(gap));
    while(!q.empty()) q.pop();
    gap[dis[sink]=0]=1; q.push(sink);
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        for(int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].en;
            if(edge[i].cap!=0 || dis[v]!=-1) continue;
            q.push(v);
            ++gap[dis[v]=dis[u]+1];
        }
    }
}

int sap()
{
    memset(pre,-1,sizeof(pre));
    bfs();
    memcpy(now,head,sizeof(head));
    int point=source , flow=0 , min_flow=INT_INF;
    while(dis[source]<tot_num)
    {
        bool fg=false;
        for(int i=now[point]; i!=-1; i=edge[i].next)
            if(edge[i].cap-edge[i].flow>0 && dis[point]==dis[edge[i].en]+1)
            {
                min_flow=min(min_flow,edge[i].cap-edge[i].flow);
                now[point]=i;
                pre[edge[i].en]=point;
                point=edge[i].en;
                if(point==sink)
                {
                    flow+=min_flow;
                    for(int u=source; u!=sink; u=edge[now[u]].en)
                    {
                        edge[now[u]].flow+=min_flow;
                        edge[now[u]^1].flow-=min_flow;
                    }
                    point=source;
                    min_flow=INT_INF;
                }
                fg=true;
                break;
            }
        if(fg) continue;
        if(--gap[dis[point]]==0) break;
        int Min=tot_num;
        for(int i=head[point]; i!=-1; i=edge[i].next)
            if(edge[i].cap-edge[i].flow>0 && Min>dis[edge[i].en])
            {
                Min=dis[edge[i].en];
                now[point]=i;
            }
        gap[dis[point]=Min+1]++;
        if(point!=source) point=pre[point];
    }
    return flow;
}

int val[1010];
int last[1010];
int IN[N];
void build(int n,int m)
{
    memset(head,-1,sizeof(head));
    memset(last,-1,sizeof(last));
    memset(IN,0,sizeof(IN));
    tot=0;
    source=0, sink=n+1, tot_num=n+2;
    for(int i=1; i<=m; i++)
        scanf("%d", val+i);
    for(int i=1, A, B; i<=n; i++)
    {
        scanf("%d", &A);
        for(int j=0, k; j<A; j++)
        {
            scanf("%d", &k);
            if(last[k]==-1) IN[i]+=val[k];
            else add_edge(last[k], i, INT_INF);
            last[k]=i;
        }
        scanf("%d", &B);
        add_edge(i, sink, B);
        add_edge(source, i, IN[i]);
    }
}

int main()
{
    int n, m;
    while(~scanf("%d%d", &m, &n))
    {
        build(n, m);
        int ans=sap();
        printf("%d\n", ans);
    }
    return 0;
}