poj 1149 -- PIGS

PIGS

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 15747		Accepted: 7034

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

题意：有一养猪场，有m个猪圈，给出每个猪圈中猪的数量，来了n个买主，每个买主手中有若干猪圈的钥匙，且给出每个买主想要买多少猪。问，最多能卖出多少头猪。

思路：网络流最大流问题。第二个最大流的题目，建图比较麻烦。下面说说我的建图方式。

　　1. 我们将所有买主当成结点。那么除了买主外，还需两个点，一个源点一个汇点。我称之为supers,supert.
　　2. 将源点与每个猪圈的第一个买主建边，如有重复的可并，实现的时候我是用flag[]数组标记钥匙是否第一次出现，如果是则可建边，否则看 step 3.
　　3. 如果不是第一次出现，说明在这个买主之前有买主买猪。这时，在这两个买主之间建边，权值（也就是容量）为INF。实现时是用nodes[]数组记录前一个买主。
　　4. 将每个买主连向汇点。容量为次买主要买的猪数。

　　我的建图方式就是这样。。建完图后用Dinic 求解。

/*======================================================================
 *           Author :   kevin
 *         Filename :   PIGS.cpp
 *       Creat time :   2014-07-20 15:11
 *      Description :
========================================================================*/
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#define clr(a,b) memset(a,b,sizeof(a))
#define MaxM 1005
#define MaxN 105
#define INF 0x7f7f7f7f
using namespace std;
struct Edge{
    int from,to,cap,flow;
};
vector<Edge> edges;
vector<int>G[MaxN];
bool vis[MaxN];
int d[MaxN],cur[MaxN],supers,supert;
bool BFS()
{
    clr(vis,0);
    queue<int>Q;
    Q.push(supers);
    d[supers] = 0;
    vis[supers] = 1;
    while(!Q.empty()){
        int x = Q.front(); Q.pop();
        int len = G[x].size();
        for(int i = 0; i < len; i++){
            Edge& e = edges[G[x][i]];
            if(!vis[e.to] && e.cap > e.flow){
                vis[e.to] = 1;
                d[e.to] = d[x]+1;
                Q.push(e.to);
            }
        }
    }
    return vis[supert];
}
int DFS(int x,int a)
{
    if(x == supert || a == 0) return a;
    int flow = 0,f;
    int len = G[x].size();
    for(int& i = cur[x]; i < len; i++){
        Edge& e = edges[G[x][i]];
        if(d[x] + 1 == d[e.to] && (f = DFS(e.to,min(a,e.cap-e.flow))) > 0){
            e.flow += f;
            edges[G[x][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(!a) break;
        }
    }
    return flow;
}
void AddEdge(int from,int to,int cap)
{
    edges.push_back((Edge){from,to,cap,0});
    edges.push_back((Edge){to,from,0,0});
    int m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}
int Dinic(int s,int t)
{
    int flow = 0;
    while(BFS()){
        clr(cur,0);
        flow += DFS(s,INF);
    }
    return flow;
}
int main(int argc,char *argv[])
{
    int n,m,keys,k;
    int pighome[MaxM],  //猪圈中猪的数量
        nodes[MaxM],    //前一个买主的信息
        flag[MaxM];     //标记是否是买猪第一人
    while(scanf("%d%d",&n,&m)!=EOF){
        clr(pighome,0);
        clr(nodes,0);
        clr(flag,0);
        supers = 0;
        supert = m+1;
        for(int i = 1; i <= n; i++)
            scanf("%d",&pighome[i]);
        for(int i = 1; i <= m; i++){
            int sum = 0;
            scanf("%d",&keys);  //钥匙的数量
            for(int j = 0; j < keys; j++){
                scanf("%d",&k);
                if(!flag[k]){
                    sum += pighome[k];  //合并重边
                    flag[k] = 1;
                }
                else{
                    if(nodes[k]){
                        AddEdge(nodes[k],i,INF); //建买主之间的边
                    }
                }
                nodes[k] = i;
            }
            AddEdge(supers,i,sum);  //添加合并后的边
            int buy;
            scanf("%d",&buy);
            AddEdge(i,supert,buy);  //建立买主到汇点的边
        }
        int ans = Dinic(supers,supert);
        printf("%d\n",ans);
        edges.clear();
        for(int i = 0; i < MaxN; i++)
            G[i].clear();
    }
    return 0;
}