【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=1000000+10;
const int INF=2147480000;

struct Dinic{
    int head[maxn],Next[3*maxn],to[3*maxn],cap[3*maxn],flow[3*maxn];
    int sz,n,m,s,t;
    bool vis[maxn];
    int cur[maxn],d[maxn];
    void init(int n){
        this->n=n;
        memset(head,-1,sizeof(head));
        this->sz=-1;
    }
    void add_edge(int a,int b,int c){
        ++sz;
        to[sz]=b;
        cap[sz]=c;flow[sz]=0;
        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,0,sizeof(vis));
        queue<int>Q;
        vis[s]=1;
        d[s]=0;
        Q.push(s);
        while(!Q.empty()){
            int u=Q.front();Q.pop();
            for(int i=head[u];i!=-1;i=Next[i]){
                int v=to[i];
                if(!vis[v]&&cap[i]>flow[i]){
                    vis[v]=1;
                    d[v]=d[u]+1;
                    Q.push(v);
                }
            }
        }
        return vis[t];
   }
    int DFS(int x,int a){
        if(x==t||a==0)return a;
        int Flow=0,f;
        for(int& i=cur[x];i!=-1;i=Next[i]){
            int v=to[i];
            if(d[v]==d[x]+1&&(f=DFS(v,min(a,cap[i]-flow[i])))>0){
                Flow+=f;
                flow[i]+=f;
                flow[i^1]-=f;
                a-=f;
                if(a==0)break;
            }
        }
        return Flow;
    }
    int Maxflow(int s,int t){
        this->s=s,this->t=t;
        int Flow=0;
        while(BFS()){
            for(int i=0;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]=1;
    for(int i=dinic.head[u];i!=-1;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,0,sizeof(foot));
        dinic.init(R+C+5);
        int r,c;
        for(int i=1;i<=N;i++){
            scanf("%d%d",&r,&c);
            dinic.add_edge(r,c+R,1);
        }
        for(int i=1;i<=R;i++)
            dinic.add_edge(0,i,1);
        for(int i=1;i<=C;i++)
            dinic.add_edge(i+R,C+R+1,1);
        int ans=dinic.Maxflow(0,C+R+1);
        printf("%d ",ans);
        get_ans(0);
        for(int i=1;i<=R;i++){
            if(!foot[i]){
                printf("r%d ",i);
            }
        }
        for(int i=1;i<=C;i++){
            int u=i+R;
            if(foot[u]){
                printf("c%d ",i);
            }
        }
        printf("\n");
    }
return 0;
}