POJ1149(最大流)

PIGS

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 21678		Accepted: 9911

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

 

 //2017-08-23
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <queue>
 #include <vector>

 using namespace std;

 const int N = ;
 const int M = ;
 const int INF = 0x3f3f3f3f;
 int head[N], tot;
 struct Edge{
     int next, to, w;
 }edge[N<<];

 void add_edge(int u, int v, int w){
     edge[tot].w = w;
     edge[tot].to = v;
     edge[tot].next = head[u];
     head[u] = tot++;

     edge[tot].w = ;
     edge[tot].to = u;
     edge[tot].next = head[v];
     head[v] = tot++;
 }

 struct Dinic{
     int level[N], S, T;
     void init(int _S, int _T){
         S = _S;
         T = _T;
         tot = ;
         memset(head, -, sizeof(head));
     }
     bool bfs(){
         queue<int> que;
         memset(level, -, sizeof(level));
         level[S] = ;
         que.push(S);
         while(!que.empty()){
             int u = que.front();
             que.pop();
             for(int i = head[u]; i != -; i = edge[i].next){
                 int v = edge[i].to;
                 int w = edge[i].w;
                 if(level[v] == - && w > ){
                     level[v] = level[u]+;
                     que.push(v);
                 }
             }
         }
         return level[T] != -;
     }
     int dfs(int u, int flow){
         if(u == T)return flow;
         int ans = , fw;
         for(int i = head[u]; i != -; i = edge[i].next){
             int v = edge[i].to, w = edge[i].w;
             if(!w || level[v] != level[u]+)
               continue;
             fw = dfs(v, min(flow-ans, w));
             ans += fw;
             edge[i].w -= fw;
             edge[i^].w += fw;
             if(ans == flow)return ans;
         }
         if(ans == )level[u] = ;
         return ans;
     }
     int maxflow(){
         int flow = ;
         while(bfs())
           flow += dfs(S, INF);
         return flow;
     }

 }dinic;

 int house[M];

 int main()
 {
     std::ios::sync_with_stdio(false);
     //freopen("input.txt", "r", stdin);
     int n, m;
     while(cin>>m>>n){
         int s = , t = n+;
         dinic.init(s, t);
         for(int i = ; i <= m; i++)
           cin>>house[i];
         int k, v;
         int book[M];
         memset(book, , sizeof(book));
         for(int i = ; i <= n; i++){
             cin>>k;
             int weight = ;
             while(k--){
                 cin>>v;
                 if(!book[v]){
                     book[v] = i;
                     weight += house[v];
                 }else{
                     add_edge(book[v], i, INF);
                 }
             }
             if(weight)add_edge(s, i, weight);
             cin>>v;
             add_edge(i, t, v);
         }
         cout<<dinic.maxflow()<<endl;
     }
     return ;

 }