poj 1149 PIGS 最大流模型

题目链接

http://poj.org/problem?id=1149

题意

某个牧场主手上有一张顾客来访表，按照时间的先后顺序来到他的牧场采购猪。每个顾客手上有A把钥匙，对应的能够打开A间猪养殖室，每间养殖室初始有一定数量的猪，每个顾客只会在他有钥匙的那些养殖室买猪，然后买一定数量。牧场主为了使卖出的猪尽量多，他根据来访表安排每间猪的数量，安排的时间只能是门被顾客打开时。

思路

首先确定超级源点与超级汇点，分别在0和n+1.对于每一间养殖室如果I号顾客第一次来，那么从源点到i建立一条边，容量为养殖室猪的数量，如果后面还有其他顾客再次打开同一间养殖室，那么从上次打开这间养殖室的顾客到当前的顾客建立一条容量无限大的边。比如养殖室先后有x，y访问，那么建立0->x，x->y的边。
dinic可以处理重边，重边我并没有合并

#include<cstdio>
#include<queue>
#include<iostream>
#include<vector>
#include<map>
#include<cstring>
#include<string>
#include<set>
#include<stack>
#include<algorithm>
#define cle(a) memset(a,0,sizeof(a))
#define inf(a) memset(a,0x3f,sizeof(a))
#define ll long long
#define Rep(i,a,n) for(int i=a;i<=n;i++)
using namespace std;
const int INF = ( 2e9 ) + 2;
const ll maxn =  1e3+10;
const int maxm = maxn;
int p[maxn],l[maxn];
struct Dinic
{
    struct edge
    {
        int from,to,c;
        edge(int getu,int getv,int getc)
        {
            from=getu;
            to=getv;
            c=getc;
        }
    };
    int s,t,n;
    int d[maxn];
    int cur[maxn];
    vector<edge> e;
    vector<int> g[maxn];
    void addedge(int u,int v,int c)
    {
        e.push_back(edge(u,v,c));
        e.push_back(edge(v,u,0));
        int m=e.size();
        g[u].push_back(m-2);
        g[v].push_back(m-1);
    }
    void init()
    {
        e.clear();
        for(int i=0; i<=maxn; i++)
            g[i].clear();
    }
    bool bfs()
    {
        queue<int> q;
        q.push(s);
        memset(d,0,sizeof(d));
        d[s]=1;
        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            for(int i=0; i<g[u].size(); i++)
            {
                int v=e[g[u][i]].to;
                int c=e[g[u][i]].c;
                if(!d[v]&&c)
                {
                    d[v]=d[u]+1;
                    q.push(v);
                }
            }
        }
        return d[t];
    }
    int dfs(int u,int maxf,int t)
    {
        if(u==t)return maxf;
        int ret=0;
        for(int &i=cur[u]; i<g[u].size(); i++)
        {
            int c=e[g[u][i]].c;
            int v=e[g[u][i]].to;
            int f;
            if(d[u]+1==d[v]&&c)
            {
                f=dfs(v,min(maxf-ret,c),t);
                e[g[u][i]].c-=f;
                e[g[u][i]^1].c+=f;
                ret+=f;
                if(ret==maxf)return ret;
            }
        }
        return ret;
    }
    int maxflow(int s,int t)
    {
        this->s=s;
        this->t=t;
        int flow=0;
        while(bfs())
        {
            memset(cur,0,sizeof(cur));
            int temp=dfs(s,INF,t);
            flow+=temp;
        }
        return flow;
    }
} dinic;
int main()
{
    int n,m;
    while(~scanf("%d%d",&m,&n))
    {
        dinic.init();
        memset(l,0,sizeof(l));
        for(int i=1;i<=m;i++)
            scanf("%d",&p[i]);
        for(int i=1;i<=n;i++)
        {
            int t,v,nd;
            scanf("%d",&t);
            while(t--)
            {
                scanf("%d",&v);
                if(l[v]==0)
                dinic.addedge(l[v],i,p[v]);
                else
                dinic.addedge(l[v],i,INF);
                l[v]=i;
            }
            scanf("%d",&nd);
            dinic.addedge(i,n+1,nd);
        }
        int ans=dinic.maxflow(0,n+1);
        printf("%d\n",ans);
    }
}