poj 1149 PIGS （网络流 ）网络流建模文库

题目链接：哆啦A梦传送门

题意：

有N个顾客，有M个猪圈，每个猪圈有一定的猪，在开始的时候猪圈都是关闭的，
顾客来买书，顾客打开某个猪圈，可以在其中挑选一定的猪的数量，在这个顾客走后，可以在打开的
猪圈中将某个猪圈的一些猪牵到另外一个打开的猪圈，然后所有的猪圈会关闭，这样下一个顾客来了继续上面的工作

 

第一行是两个整数：M和N（1≤M≤1000，1≤N≤100）
M是猪圈的数目，N是顾客的数目
第二行是M个整数，为每个猪圈中初始猪的数目，范围是[0，1000]
第三行接下来有N行，每行第一个数A代表第几个顾客会依次打开A个猪圈，
然后跟着有A个数，代表顾客打开的是哪个猪圈，最后有一个数代表这个顾客可以买多少只猪

 

求：最多能售出多少只猪？

题解：

参考网络流建模文库：https://wenku.baidu.com/view/0ad00abec77da26925c5b01c.html

网络流。

建模：

1，每个顾客分别用一个节点来表示。

2，对于每个猪圈的第一位客人，我们将他连向源点，权值为该猪圈的初始容量值。

3，对于每个猪圈，如果有多个顾客打开它，那么我们将他们建边，权值为INF。例如对于猪圈1，我们有客人i先打开，紧接着就被客人j打开，那么我们将客人i与客人j建边。（我们可以这么想，客人i打开后的猪圈，会影响到客人j打开）

4，对于每个客人，我们将他与汇点相连，权值为每位顾客初始期望买猪的头数。

 

建完模，就是裸的dinic。

 

 

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int N=400000;
const int INF=0x3f3f3f3f;

struct edge{
    int from,to,w,next;
}e[200010];
int cnt;

int a[300][300],dep[N],head[N];
queue<int> que;

int dir[4][2]={{0,1},{0,-1},{-1,0},{1,0}};

void init(){
    memset(head,-1,sizeof(head));
    cnt=0;
}
void add(int u,int v,int w)
{
    e[cnt].from=u;
    e[cnt].to=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt++;

     e[cnt].from=v;
    e[cnt].to=u;
    e[cnt].w=0;
    e[cnt].next=head[v];
    head[v]=cnt++;
}

int bfs(int s,int t)
{
    while(!que.empty()) que.pop();

    memset(dep,-1,sizeof(dep));

    dep[s]=0;
    que.push(s);

    while(!que.empty()){
        int u=que.front();
        que.pop();
        if(u==t) return 1;
            for(int i=head[u];i!=-1;i=e[i].next){
                int w=e[i].w;
                int v=e[i].to;
            if(w&&dep[v]==-1){
                dep[v]=dep[u]+1;
                que.push(v);
            }
        }

    }
    return 0;
}

int dfs(int u,int mi,int t){
    if(u==t) return mi;
    int tmp;
    int ret=0;
//    for(int v=1;v<=t;v++){
        for(int i=head[u];i!=-1;i=e[i].next){
            int w=e[i].w;
            int v=e[i].to;
        if(w&&dep[v]==dep[u]+1){
           tmp=dfs(v,min(mi-ret,w),t) ;
           e[i].w-=tmp;
            e[i^1].w+=tmp;
            ret+=tmp;
            if(ret==mi) return ret;
        }
    }
    return ret;
}

int dinic(int s,int t)
{
    int ans=0;
    while(bfs(s,t)){
            ans+=dfs(s,INF,t);

    }
    return ans;
}

int pig[1010],num[1010];
int main()
{

    int n,m;
    int T=0;
    scanf("%d%d",&m,&n);


        init();


        int s=0,t=n*m+1;

        for(int i=1;i<=m;i++)
            scanf("%d",&pig[i]);

        for(int i=1;i<=n;i++)
        {
            int A,k;
            scanf("%d",&A);

            while(A--)
            {
                scanf("%d",&k);
                if(!num[k]){///该猪圈被首次被打开
                    add(s,i,pig[k]);///源点到客人i建边
                    num[k]=i;///标记此猪圈最后被谁打开
                }
                else{///该猪圈不是首次被打开
                    add(num[k],i,INF);///将前一位客人与此时的客人建边
                    num[k]=i;
                }
            }
            scanf("%d",&k);
            add(i,t,k);///将客人i与汇点建边，权值为客人期望购买的值

        }
        printf("%d\n",dinic(s,t));

    return 0;
}