网络流(最大流)：POJ 1149 PIGS

PIGS

Time Limit: 1000ms

Memory Limit: 10000KB

This problem will be judged on PKU.
64-bit integer(整数) IO format: %lld      Java class name: Main

 

Mirko works on a pig farm that consists of M locked pig-houses and Mirko
can't unlock any pighouse because he doesn't have the keys. Customers
come to the farm one after another. Each of them has keys to some
pig-houses and wants to buy a certain number of pigs.

All data concerning(关于)
customers planning to visit the farm on that particular day are
available to Mirko early in the morning so that he can make a sales-plan
in order to maximize(取…最大值) the number of pigs sold.

More precisely(精确地), the procedure(程序)
is as following: the customer arives, opens all pig-houses to which he
has the key, Mirko sells a certain number of pigs from all the unlocked
pig-houses to him, and, if Mirko wants, he can redistribute(重新分配) the remaining pigs across the unlocked pig-houses.

An unlimited number of pigs can be placed in every pig-house.

Write a program that will find the maximum number of pigs that he can sell on that day.

Input

The first line of input(投入) contains two integers(整数)
M and N, 1 <= M <= 1000, 1 <= N <= 100, number of pighouses
and number of customers. Pig houses are numbered from 1 to M and
customers are numbered from 1 to N.

The next line contains M integeres, for each pig-house initial
number of pigs. The number of pigs in each pig-house is greater or equal
to 0 and less or equal to 1000.

The next N lines contains records about the customers in the
following form ( record about the i-th customer is written in the
(i+2)-th line):

A K1 K2 ... KA B It means that this customer has key to the pig-houses marked with the numbers K1, K2, ..., KA (sorted nondecreasingly(不减少的) ) and that he wants to buy B pigs. Numbers A and B can be equal to 0.

Output

The first and only line of the output(输出) should contain the number of sold pigs.

Sample Input

3 3
3 1 10
2 1 2 2
2 1 3 3
1 2 6

Sample Output

7
　　
　　建模题，这里需要注意对空间的优化。
　　题意：迈克有个养猪场，养猪场里有M个猪圈，每个猪圈都上了锁。迈克没有钥匙，而要买猪的顾客一个接一个来到养猪场，每个顾客有一些猪圈的钥匙，要买一定数量的猪。当每个顾客来时，将有钥匙的猪圈全部打开，从中挑出一些买走，然后迈克可以重新分配这些猪圈里面的猪。当顾客离开后，门又被锁上。问迈克最多可以卖多少猪。
　　建模：先从源点给每个猪圈连一条边，容量是猪圈中猪的头数。这时再添加顾客，对于每一个顾客，查找他要开的每一个猪圈，如果他要开猪圈A，那么现在分情况讨论：
　　<1>若以前(先后顺序，时间上的)没有顾客开过A猪圈，那么就连一条A到这个顾客的边，容量为INF，同时标记这个人为这个猪圈的“开启者”
　　<2>若有，则将A的“开启者”连到这个人，容量为INF
　　最后每个顾客连边到汇点，容量为各自的需求，接着跑一遍最大流就可以啦，这里我用了ISAP算法

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <queue>
 
 using namespace std;
 const int INF=;
 const int maxn=,maxm=;
 int cnt,fir[maxn],nxt[maxm],cap[maxm],to[maxm],dis[maxn],gap[maxn],path[maxn],used[maxn];
 
 void addedge(int a,int b,int c)
 {
     nxt[++cnt]=fir[a];
     to[cnt]=b;
     cap[cnt]=c;
     fir[a]=cnt;
 }
 
 bool BFS(int S,int T)
 {
     memset(dis,,sizeof(dis));
     dis[T]=;
     queue<int>q;q.push(T);
     while(!q.empty())
     {
         int node=q.front();q.pop();
         for(int i=fir[node];i;i=nxt[i])
         {
             if(dis[to[i]])continue;
             dis[to[i]]=dis[node]+;
             q.push(to[i]);
         }
     }
     return dis[S];
 }
 int fron[maxn];
 int ISAP(int S,int T)
 {
     if(!BFS(S,T))
         return ;
     for(int i=;i<=T;i++)++gap[dis[i]];
     int p=S,ret=;
     memcpy(fron,fir,sizeof(fir));
     while(dis[S]<=T)
     {
         if(p==T){
             int f=INF;
             while(p!=S){
                 f=min(f,cap[path[p]]);
                 p=to[path[p]^];
             }
             p=T;ret+=f;
             while(p!=S){
                 cap[path[p]]-=f;
                 cap[path[p]^]+=f;
                 p=to[path[p]^];
             }
         }
         int &ii=fron[p];
         for(;ii;ii=nxt[ii]){
             if(!cap[ii]||dis[to[ii]]+!=dis[p])
                 continue;
             else
                 break;
         }
         if(ii){
             p=to[ii];
             path[p]=ii;
         }
         else{
             if(--gap[dis[p]]==)break;
             int minn=T+;
             for(int i=fir[p];i;i=nxt[i])
                 if(cap[i])
                     minn=min(minn,dis[to[i]]);
             gap[dis[p]=minn+]++;
             fron[p]=fir[p];
             if(p!=S)
                 p=to[path[p]^];
         }
     }
     return ret;
 }
 
 void Init()
 {
     memset(fir,,sizeof(fir));
     memset(used,,sizeof(used));
     cnt=;
 }
 int main()
 {
     int n,m,num,k,need;
     while(~scanf("%d%d",&m,&n))
     {
         Init();
         for(int i=;i<=m;i++){
             scanf("%d",&num);
             addedge(,i,num);
             addedge(i,,);
         }
         for(int i=m+;i<=m+n;i++){
             scanf("%d",&k);
             while(k--){
                 scanf("%d",&num);
                 if(used[num]){
                     addedge(used[num],i,INF);
                     addedge(i,used[num],);
                 }
                 else{
                     used[num]=i;
                     addedge(num,i,INF);
                     addedge(i,num,);
                 }
 
             }
             scanf("%d",&need);
             addedge(i,n+m+,need);
             addedge(n+m+,i,);
         }
         printf("%d\n",ISAP(,n+m+));
     }
     return ;
 }