Gym101981I Magic Potion（最大流）

Problem I. Magic Potion

There are n heroes and m monsters living in an island. The monsters became very vicious these days, so the heroes decided to diminish the monsters in the island. However, the i-th hero can only kill one monster belonging to the set Mi. Joe, the strategist, has k bottles of magic potion, each of which can buff one hero’s power and let him be able to kill one more monster. Since the potion is very powerful, a hero can only take at most one bottle of potion. Please help Joe find out the maximum number of monsters that can be killed by the heroes if he uses the optimal strategy.

Input

　　The first line contains three integers n, m, k (1 ≤ n, m, k ≤ 500) — the number of heroes, the number of monsters and the number of bottles of potion. Each of the next n lines contains one integer ti, the size of Mi, and the following ti integers Mi,j (1 ≤ j ≤ ti), the indices (1-based) of monsters that can be killed by the i-th hero (1 ≤ ti ≤ m, 1 ≤ Mi,j ≤ m).

Output

　　 Print the maximum number of monsters that can be killed by the heroes.

Examples

standard input

3 5 2

4 1 2 3 5

2 2 5

2 1 2

standard output

4

standard input

5 10 2

2 3 10

5 1 3 4 6 10

5 3 4 6 8 9

3 1 9 10

5 1 3 6 7 10

standard output

7

题目大意

---

给定n个英雄，m只怪兽，k瓶药。每个英雄只能杀一只怪，一个英雄磕了药后能够多杀一只，但一个英雄至多只能磕一次药。已知每个英雄能够杀死哪些怪兽，问最多杀几只怪。

解题思路

---

添加源点和两个中间结点，编号分别为1，2，3。再添加n个结点表示英雄，编号为4~n+3。再添加m个结点表示怪兽，编号为n+3+1~n+m+3。最后添加汇点，编号为n+m+4。

连接源点和两个中间结点，容量分别为n和k。将每个英雄和两个中间节点连接，容量为1。将每个英雄和他能够消灭的怪兽连接，容量为1。最后将每个怪兽和汇点连接，容量为1。

从源点到汇点跑最大流，结果即为最终的数量。

PS：还有其他解法，如跑一遍容量为1的最大流后，在跑一遍容量为2的最大流，再分类讨论结果 。

AC代码

---

 #include<bits/stdc++.h>
 using namespace std;
 const int MAXN = 5e6+;  //X 集合中的顶点数上限
 const int MAXM = 5e6+;  // 总的边数上限
 const int INF = 0x3f3f3f3f;
 int head[MAXN],tot;
 int S,T;  // S 是源点，T 是汇点
 int d[MAXN];  // 存储每个顶点的层次
 ​
 struct Edge{
     int v,c,nxt;
     // v 是指边的另一个顶点，c 表示容量
 }e[MAXM];
 ​
 void init(){
     memset(head,-,sizeof(head));
     tot=;
 }
 ​
 void addedge(int u,int v,int c){
     // 插入一条从 u 连向 v，容量为 c 的弧
     e[tot].v=v;e[tot].c=c;
     e[tot].nxt=head[u];
     head[u]=tot++;

     e[tot].v=u;e[tot].c=;
     e[tot].nxt=head[v];
     head[v]=tot++;
 }
 ​
 bool bfs(){
     // bfs构建层次图G_L
     memset(d,-,sizeof(d));
     queue<int> q;
     q.push(S);
     d[S]=;
     while(!q.empty()){
         int u=q.front();
         q.pop();
         for(int i=head[u];i!=-;i=e[i].nxt){
             int v=e[i].v;
             if(e[i].c>&&d[v]==-){
                 q.push(v);
                 d[v]=d[u]+;
             }
         }
     }
     return (d[T]!=-);
 }
 ​
 int dfs(int u,int flow){
     // dfs在层次图G_L中寻找增广路径
     // flow 表示当前搜索分支的流量上限
     if(u==T){
         return flow;
     }
     int res=;
     for(int i=head[u];i!=-;i=e[i].nxt){
         int v=e[i].v;
         if(e[i].c>&&d[u]+==d[v]){
             int tmp=dfs(v,min(flow,e[i].c));
             // 递归计算顶点 v，用 c(u, v) 来更新当前流量上限
             flow-=tmp;
             e[i].c-=tmp;
             res+=tmp;
             e[i^].c+=tmp;  // 修改反向弧的容量
             if(flow==){  // 流量达到上限，不必继续搜索了
                 break;
             }
         }
     }
     if(res==){
         // 当前没有经过顶点 u 的可行流，不再搜索顶点 u
         d[u]=-;
     }
     return res;
 }
 ​
 int maxflow(){  // 函数返回值就是最大流的结果
     int res=;
     while(bfs()){
         res+=dfs(S,INF);  // 初始流量上限为 INF
     }
     return res;
 }
 ​
 int main(){
     int m,n,k,mid1,mid2;
     while(~scanf("%d %d %d",&n,&m,&k)){
         init();
         S=;T=n+m+;mid1=;mid2=;
         int cnt,v;
         addedge(S,mid1,n);
         addedge(S,mid2,k);
         for(int i=;i<=n;i++){
             addedge(mid1,i+,);
             addedge(mid2,i+,);
             scanf("%d",&cnt);
             for(int j=;j<cnt;j++){
                 scanf("%d",&v);
                 addedge(i+,n+v+,);
     }
     }
 for(int i=;i<=m;i++)
 addedge(n+i+,T,);
 ​
         printf("%d\n",maxflow());
     }
     return ;
 }