Poj 1149 Pigs

Poj 1149 Pigs

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

分析：本题的关键就在于如何构造一个容量网络。在本题中，容量网络的构造如下。

(1)将顾客看作除源点和汇点外以的结点，并且另设两个节点:源点和汇点。

(2)源点和每个猪圈的第一个顾客连边，边的权是开始时猪圈中猪的数目，若有重边则将边权合并（因此源点流出的流量就是所有的猪圈能提供的猪的数目）。

(3)若顾客j紧跟在顾客i之后打开某个猪圈，则边<i,j>的权是+∞；这是因为，如果顾客j紧跟在i之后打开某个猪圈，那么迈克就有可能根据顾客j的需求将其他猪圈中的猪调整到该猪圈，这样j就能买到尽可能多的猪

(5)每个顾客和汇点之间连边，边的权是顾客希望购买的猪的数目(因此汇点流入的量就是每个顾客所购买的猪的数目)。

这题数据量较小，采用一般增广路算法即可

#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
const int INF2 = 300000000;
const int MAXM = 1005;
const int MAXN = 105;
struct Edge {
    int f,c;
};
Edge edge[MAXN][MAXN];
int n,v;
int house[MAXM],last[MAXM];
int flag[MAXN],pre[MAXN],alpha[MAXN];
queue<int > q;
void init() {
    int M,N,num,k;
    scanf("%d%d",&M,&N);
    n = N+2;
    memset(last,0,sizeof(last));
    memset(edge,0x3f,sizeof(edge));
    for(int i = 1;i <= M;i++) scanf("%d",&house[i]);
    for(int i = 1;i <= N;i++) {
        scanf("%d",&num);
        for(int j = 0;j < num;j++) {
            scanf("%d",&k);
            if(last[k] == 0) {
                if(edge[0][i].c == INF) edge[0][i].c = 0;
                edge[0][i].c+=house[k];
                edge[0][i].f = 0;
            }
            else {edge[last[k]][i].c = INF2;edge[last[k]][i].f = 0;}
            last[k] = i;
        }
        scanf("%d",&edge[i][n-1].c);
        edge[i][n-1].f = 0;
    }
    /*for(int i = 0;i < n;i++) {
        for(int j = 0;j < n;j++) 
            edge[i][j].f = 0;
    }*/
}
void ford() {
    for(;;) {
        memset(flag,0xff,sizeof(flag));
        memset(pre,0xff,sizeof(pre));
        flag[0] = 0;pre[0] = 0;alpha[0] = INF;
        while(!q.empty()) q.pop();
        q.push(0);
        while(!q.empty() && flag[n-1] == -1) {
            v = q.front();q.pop();
            for(int i = 0;i < n;i++) {
                if(flag[i] == -1) {
                    if(edge[v][i].c < INF && edge[v][i].f < edge[v][i].c) {
                        flag[i] = 0;pre[i] = v;
                        alpha[i] = min(alpha[v],edge[v][i].c - edge[v][i].f);
                        q.push(i);
                    }
                    else if(edge[i][v].c < INF && edge[i][v].f > 0) {
                        flag[i] = 0;pre[i] = -v;
                        alpha[i] = min(alpha[v],edge[i][v].f);
                        q.push(i);
                    }
                }
            }
            flag[v] = 1;
        }
        if(flag[n-1] == -1 || alpha[n-1] == 0) break;   
        int k1 = n-1,k2 = abs(pre[k1]);
        int a = alpha[n-1];
        while (1)
        {
            if(edge[k2][k1].f < INF) edge[k2][k1].f += a;
            else edge[k1][k2].f -= a;
            if(k2 == 0) break;
            k1 = k2;k2 = abs(pre[k2]);
        } 
    }
    int maxflow = 0;
    for(int i = 0;i < n;i++) {
        for(int j = 0;j < n;j++) {
            if(i == 0 && edge[i][j].f != INF) maxflow+=edge[i][j].f;
        }
    }
    /*for(int i = 0;i < n;i++) {
        for(int j = 0;j < n;j++) {
            if(i!=j) printf("%d %d\n",edge[i][j].c,edge[i][j].f);
        }
    }*/
    printf("%d\n",maxflow);
}
int main() {
    init();
    ford();
    return 0;
}