题目大意：

有1000个猪舍，每个猪舍里装了一些猪，这些猪舍都被锁上了，你没有钥匙。接下来会每天来一个顾客（一共来100天），这个顾客有某几个猪舍的钥匙，然后他还想买几头猪。你可以办到的就是，把这些猪舍里的猪卖若干头给这个顾客，然后把剩下的猪合理的安放到这些打开着的笼子里面，然后再次锁上，等待下一个顾客的到来。问你如何合理安排，才能让这些猪被卖出去的最多。

注：这里题意描述的有一个不明确的地方，就是，第一天把这些笼子打开，我可不可以把当天剩下的猪装到其中几个打开的笼子中，然后剩几个笼子开着不关，把下一天剩下的猪关进去。

下面我是按照不能这样做来分析的：

分析：

首先，对于每一个顾客，我尽量多卖给他猪，这个策略是没问题的，因为猪卖一个就少一个，与其留着它卖给之后的顾客，还不如当场卖出去（如果能卖出去的话）。所以我把这个问题看成一个顾客一个顾客地接待，每个顾客都要尽量让他们多买，也就是每个顾客跑一次最大流。

网络流建图：

对于一个顾客，超级源点连到每个猪笼，容量为每个猪笼猪的数量；然后该顾客所能打开的猪笼连到该顾客，容量为无限大，同时对于该顾客的上一个顾客所能打开的所有猪笼，这些猪笼相连成环，容积无限大；该顾客连到超级汇点，容量为他准备购买的猪的数量。建图完毕之后，跑一次最大流，跑完之后，更新每个猪笼剩下的猪的数量。继续处理下一个顾客。

这样代码实现是有一点麻烦的，我实在懒得写，可能也不会写，因为我之前都是套的魔板，所以想到寻求一种更巧妙的建图方法：

网络流建图进阶：

超级源点连到每个猪笼，容量为每个猪笼里猪的个数；每个顾客连到超级汇点，容量为他所要购买的猪的个数；每个顾客能打开的所有猪笼都连接到该顾客，容量无限大；对于每一个猪笼，能打开它的顾客按照来的先后顺序顺次相连，容量无限大。

代码：

/* ╭︿︿︿╮ {/ o o /} ( (oo) ) ︶︶︶ */
#include<iostream>
#include<string.h>
#include<stdio.h>
#include<queue>
#include<vector>
#define inf 0x3f3f3f
#define maxn 3000
using namespace std;

struct Edge
{
    int from,to,cap,flow;
    Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
};

int n;int m;
vector<Edge>edge;
vector<int>G[maxn];
int map[maxn][500]={0};
int a[maxn];
int p[maxn];
bool con[500][500];
void init(int n)
{
    for(int i=0;i<n;i++)G[i].clear();
    edge.clear();
}
void add_edge(int from,int to,int cap)
{
    edge.push_back(Edge(from,to,cap,0));
    edge.push_back(Edge(to,from,0,0));
    int lm=edge.size();
    G[from].push_back(lm-2);
    G[to].push_back(lm-1);
}
int maxflow(int s,int t)
{
    int flow=0;
    while(1)
    {
        memset(a,0,sizeof(a));
        queue<int>Q;
        Q.push(s);
        a[s]=inf;
        while(!Q.empty())
        {
            int x=Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++)
            {
                Edge& e=edge[G[x][i]];
                if(!a[e.to]&&e.cap>e.flow)
                {
                    p[e.to]=G[x][i];
                    a[e.to]=min(a[x],e.cap-e.flow);
                    Q.push(e.to);
                }
            }
            if(a[t])break;
        }
        if(!a[t])break;
        for(int u=t;u!=s;u=edge[p[u]].from)
        {
            edge[p[u]].flow+=a[t];
            edge[p[u]^1].flow-=a[t];
        }
        flow+=a[t];
    }
    return flow;
}

int main()
{
    cin>>m>>n;//超级源点0，猪笼1-m，顾客m+1 - m+n，超级汇点m+n+1 
    init(maxn);
    memset(p,0,sizeof(p));
    memset(con,0,sizeof(con));
    int ls,x;
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&ls);
        add_edge(0,i,ls);
    }
    for(int i=1;i<=n;i++)//每个顾客 
    {
        scanf("%d",&ls);
        for(int j=1;j<=ls;j++)
        {
            scanf("%d",&x);
            add_edge(x,i+m,inf);
            map[x][i]=1;
        }
        scanf("%d",&x);
        add_edge(i+m,m+n+1,x);
    }
    for(int i=1;i<=m;i++)
    {
        x=0;
        for(int j=1;j<=n;j++)
        {
            if(map[i][j]==1)
            {
                if(x!=0&&con[j][x]==0)
                {
                    add_edge(x+m,j+m,inf);
                    con[j][x]=1;
                }
                x=j;
            }
        }
    }
    cout<<maxflow(0,m+n+1);
}