【UVA11419 训练指南】我是SAM 【二分图最小覆盖，最小割】

题意

给出一个R*C大小的网格，网格上面放了一些目标。可以在网格外发射子弹，子弹会沿着垂直或者水平方向飞行，并且打掉飞行路径上的所有目标。你的任务是计算最少需要多少子弹，各从哪些位置发射，才能把所有目标全部打掉。

分析

啊！原来这个模型叫 最小覆盖模型啊！难道不是最小割直接做嘛？？

二分图最小覆盖：既选择尽量少的点，使得每条边至少有一个端点被选中。可以证明，最小覆盖数等于最大匹配数。

本题的建模方法：

将每一行看作一个X结点，每一列看作一个Y结点，每个目标对应一条边。这样，子弹打掉左右的目标意味着每条边至少有一个节点被选中。

好吧，我还是说一下我最小割的理解吧。建模一开始还是一样的，每一行为X结点，每一列为Y结点，每个目标对应一条从X到Y的一条边。然后从s向每个X结点连一条容量为1的边。然后每个Y结点都向t结点连一条容量为1的边。求最小割的时候一定是个割从s连出的边或者连向t的边。而如果割s->u这条边，那么就代表这一行打子弹，割v->t也同理。

如果只是输出这个最小的子弹数，那么到这里就结束了，是个非常简单的最小割。但是这个题要输出方案！

按照最小割来说的话，我们要知道，我们割的是哪一条边。一开始我想当然以为就是输出满流的边，但是很显然不对啊！

然后，然后，然后我就去可耻的百度了。

哪些边是最小割的边呢？我们知道，跑完最小割是以后是把所有的点都分为X阵营和Y阵营。那么连接着两个阵营的边就是最小割的边。那么我们只要找出哪些点是X哪些点是Y就可以了。怎么找呢？我们跑完dinic以后，是得到了一个不存在增广路的残量网络的。此时X和Y是分开的，那么只要从s结点开始顺着残量网络的边（包括反向边）跑一个DFS，只要能跑到的点都是X阵营。

具体看下面的代码吧~

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

 using namespace std;
 const int maxn=+;
 const int INF=;

 struct Dinic{
     int head[maxn],Next[*maxn],to[*maxn],cap[*maxn],flow[*maxn];
     int sz,n,m,s,t;
     bool vis[maxn];
     int cur[maxn],d[maxn];
     void init(int n){
         this->n=n;
         memset(head,-,sizeof(head));
         this->sz=-;
     }
     void add_edge(int a,int b,int c){
         ++sz;
         to[sz]=b;
         cap[sz]=c;flow[sz]=;
         Next[sz]=head[a];head[a]=sz;
         ++sz;
         to[sz]=a;
         cap[sz]=c;flow[sz]=c;
         Next[sz]=head[b];head[b]=sz;
     }
     bool BFS(){
         memset(vis,,sizeof(vis));
         queue<int>Q;
         vis[s]=;
         d[s]=;
         Q.push(s);
         while(!Q.empty()){
             int u=Q.front();Q.pop();
             for(int i=head[u];i!=-;i=Next[i]){
                 int v=to[i];
                 if(!vis[v]&&cap[i]>flow[i]){
                     vis[v]=;
                     d[v]=d[u]+;
                     Q.push(v);
                 }
             }
         }
         return vis[t];
    }
     int DFS(int x,int a){
         if(x==t||a==)return a;
         int Flow=,f;
         for(int& i=cur[x];i!=-;i=Next[i]){
             int v=to[i];
             if(d[v]==d[x]+&&(f=DFS(v,min(a,cap[i]-flow[i])))>){
                 Flow+=f;
                 flow[i]+=f;
                 flow[i^]-=f;
                 a-=f;
                 if(a==)break;
             }
         }
         return Flow;
     }
     int Maxflow(int s,int t){
         this->s=s,this->t=t;
         int Flow=;
         while(BFS()){
             for(int i=;i<=n;i++)
              cur[i]=head[i];

             Flow+=DFS(s,INF);
         }
         return Flow;
     }
 }dinic;
 int R,C,N;
 int foot[maxn];
 void get_ans(int u){
     foot[u]=;
     for(int i=dinic.head[u];i!=-;i=dinic.Next[i]){
         int v=dinic.to[i];
         if(!foot[v]&&dinic.cap[i]>dinic.flow[i])
             get_ans(v);
     }
     return;
 }

 int main(){
     while(scanf("%d%d%d",&R,&C,&N)!=EOF&&(R||C||N)){
         memset(foot,,sizeof(foot));
         dinic.init(R+C+);
         int r,c;
         for(int i=;i<=N;i++){
             scanf("%d%d",&r,&c);
             dinic.add_edge(r,c+R,);
         }
         for(int i=;i<=R;i++)
             dinic.add_edge(,i,);
         for(int i=;i<=C;i++)
             dinic.add_edge(i+R,C+R+,);
         int ans=dinic.Maxflow(,C+R+);
         printf("%d ",ans);
         get_ans();
         for(int i=;i<=R;i++){
             if(!foot[i]){
                 printf("r%d ",i);
             }
         }
         for(int i=;i<=C;i++){
             int u=i+R;
             if(foot[u]){
                 printf("c%d ",i);
             }
         }
         printf("\n");
     }
 return ;
 }