POJ 1149：PIGS 网络流经典题

PIGS

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 18345		Accepted: 8354

Description

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 arrives, 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

Mirko工作在一个有M间猪房的农场里，但是他没有钥匙不能打开这些房间。有趣的是，顾客有要买哪些猪的房间的钥匙。购买的时候Mirko就可以打开相应的房间，然后也可以调整相应房间里猪的数量关系。问在一定顾客与购买关系的条件下，Mirko最多能卖多少猪。

这个构图求最大网络流的想法太赞，我真是远远想不到。

构造图，构造一个源点S和汇点t。

顾客是除了源点和汇点以外的节点，并且把每个猪房的第一个顾客与源点相连，权值为该猪房的起始猪的数量，假设第一个购买第N个猪房与第一个购买第M个猪房的人是一个人，则将其合并成一个点。

顾客I在顾客J之后购买相同猪房中的猪，则有一条边从顾客J指向顾客I，权值为无穷大，因为是要从那个边过来的网络流中取一部分。(这种构图方法谁想的，太厉害了。)

每一个顾客都与汇点连一条边，边的权值是每一个顾客希望购买的猪的数量。

这种构图方式最让我瞠目结舌的在于它居然就真的全照顾到了题目所要求的所有条件，一开始我觉得这些条件真多真繁琐啊，构图怎么可能直接求一个网络流就完事了呢，以为图论的问题都是像之前那么直接套模板了，结果这种构图方式，哇~

代码：

#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <queue>
#include <cstring>
#pragma warning(disable:4996)
using namespace std;

const int sum = 201;
const int INF = 99999999;

int cap[sum][sum],flow[sum][sum],a[sum],p[sum];
int val[1005];
int flag[1005];
int N,M;

void Edmonds_Karp()
{
int u,t,result=0;
queue <int> s;
while(s.size())s.pop();

while(1)
{
memset(a,0,sizeof(a));
memset(p,0,sizeof(p));

a[0]=INF;
s.push(0);

while(s.size())
{
u=s.front();
s.pop();

for(t=0;t<=M+1;t++)
{
if(!a[t]&&flow[u][t]<cap[u][t])
{
s.push(t);
p[t]=u;
a[t]=min(a[u],cap[u][t]-flow[u][t]);//要和之前的那个点，逐一比较，到M时就是整个路径的最小残量
}
}
}
if(a[M+1]==0)
break;
result += a[M+1];

for(u=M+1;u!=0;u=p[u])
{
flow[p[u]][u] += a[M+1];
flow[u][p[u]] -= a[M+1];
}
}
cout<<result<<endl;
}

int main()
{
int i,j,num,out,u,v,value;
while(scanf("%d%d",&N,&M)==2)
{
memset(cap,0,sizeof(cap));
memset(flow,0,sizeof(flow));
memset(flag,0,sizeof(flag));

for(i=1;i<=N;i++)
{
scanf("%d",&val[i]);
}

for(i=1;i<=M;i++)
{
scanf("%d",&num);
for(j=1;j<=num;j++)
{
scanf("%d",&value);
if(!flag[value])
{
flag[value]=i;
cap[0][i] += val[value];
}
else
{
cap[flag[value]][i] = INF;
flag[value]=i;
}
}
scanf("%d",&out);
cap[i][M+1] += out;
}
Edmonds_Karp();
}
return 0;
}