POJ 1149

PIGS

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 15724		Accepted: 7023

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

Source

Croatia OI 2002 Final Exam - First day

 

有M个猪圈，从源点到第一个打开每个猪圈的顾客连一条边，容量为猪圈的初始猪数，然后打开同一个猪圈的打开者，按照打开的顺序依次往下一个打开者连一条容量

为无穷大的边，每个顾客向汇点连一条容量为他想买的猪数的边，走最大流

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

const int MAX_M = 1005;
const int MAX_N =105;
int M, N;
int pig[MAX_M];
struct Edge {int from, to, cap, flow;};
vector <int> p[MAX_M];
int buy[MAX_N];
vector <int> G[MAX_M];
vector <Edge> edges;
int _max = 0;
int d[MAX_N];
int cur[MAX_N];
bool vis[MAX_N];

void add_edge(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);
}



void solve() {
        for (int i = 1; i <= N; ++i) {
                add_edge(i, N + 1, buy[i]);
        }

        for (int i = 1; i <= M; ++i) {
                if (p[i].size()) {
                        add_edge(0, p[i][0], pig[i]);
                        for (int j = 0; j < p[i].size() - 1; ++j) {
                                add_edge(p[i][j], p[i][j + 1], _max);
                        }
                }
        }

}

bool BFS(int s, int t) {
        memset(vis, 0, sizeof(vis));
        queue <int> q;
        q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while (!q.empty()) {
                int x = q.front(); q.pop();
                for (int i = 0; i < G[x].size(); ++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[t];
}

int DFS(int x, int a, int t) {
        if (x == t || a == 0) return a;
        int flow = 0, f;
        for (int &i = cur[x]; i < G[x].size(); ++i) {
                Edge &e = edges[ G[x][i] ];
                if (d[x] + 1 == d[e.to] &&  (f = DFS(e.to, min(a, e.cap - e.flow), t))> 0) {
                        e.flow += f;
                        edges[ G[x][i] ^ 1].flow -= f;
                        flow += f;
                        a -= f;
                        if (a == 0) break;
                }
        }

        return flow;
}

int Maxflow(int s, int t) {
        int flow = 0;
        while (BFS(s, t)) {
                memset(cur, 0, sizeof(cur));
                flow += DFS(s, _max, t);
        }

        return flow;
}

int main()
{
    //freopen("sw.in", "r", stdin);
    scanf("%d%d", &M, &N);
    for (int i = 1; i <= M; ++i) {
            scanf("%d", &pig[i]);
            _max += pig[i];
    }
    for (int i = 1; i <= N; ++i) {
            int n;
            scanf("%d", &n);
            for (int j = 1; j <= n; ++j) {
                    int ch;
                    scanf("%d", &ch);
                    p[ch].push_back(i);
            }
            scanf("%d", &buy[i]);
    }

    solve();
    printf("%d
", Maxflow(0, N + 1));


    //cout << "Hello world!" << endl;
    return 0;
}