Uva 11419 我是SAM

题目链接：https://vjudge.net/problem/UVA-11419

题意：一个网格里面有一些目标，可以从某一行，某一列发射一发子弹，可以打穿；

求最少的子弹，和在哪里打？

分析：

听说可以用吗MCMF做，没多想；

一个目标，拆成两个点，X,Y，X与Y之间连一条边，现在，在这些点里面选出一些点，使得每一条边都有一个端点被覆盖，这就是最小点覆盖=最大匹配（证明在之前写过，博客里可以找到，证明很有意思）；

然后还要找出哪些被覆盖了；

 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <algorithm>
 using namespace std;

 const int maxn =  + ; // 单侧顶点的最大数目

 // 二分图最大基数匹配
 struct BPM
 {
     int n, m;               // 左右顶点个数
     vector<int> G[maxn];    // 邻接表
     int left[maxn];         // left[i]为右边第i个点的匹配点编号，-1表示不存在
     bool T[maxn];           // T[i]为右边第i个点是否已标记

     int right[maxn];        // 求最小覆盖用
     bool S[maxn];           // 求最小覆盖用

     void init(int n, int m)
     {
         this->n = n;
         this->m = m;
         for(int i = ; i < n; i++) G[i].clear();
     }

     void AddEdge(int u, int v)
     {
         G[u].push_back(v);
     }

     bool match(int u)
     {
         S[u] = true;
         for(int i = ; i < G[u].size(); i++)
         {
             int v = G[u][i];
             if (!T[v])
             {
                 T[v] = true;
                 if (left[v] == - || match(left[v]))
                 {
                     left[v] = u;
                     right[u] = v;
                     return true;
                 }
             }
         }
         return false;
     }

     // 求最大匹配
     int solve()
     {
         memset(left, -, sizeof(left));
         memset(right, -, sizeof(right));
         int ans = ;
         for(int u = ; u < n; u++)   // 从左边结点u开始增广
         {
             memset(S, , sizeof(S));
             memset(T, , sizeof(T));
             if(match(u)) ans++;
         }
         return ans;
     }

     // 求最小覆盖。X和Y为最小覆盖中的点集
     int mincover(vector<int>& X, vector<int>& Y)
     {
         int ans = solve();
         memset(S, , sizeof(S));
         memset(T, , sizeof(T));
         for(int u = ; u < n; u++)
             if(right[u] == -) match(u); // 从所有X未盖点出发增广
         for(int u = ; u < n; u++)
             if(!S[u]) X.push_back(u); // X中的未标记点
         for(int v = ; v < m; v++)
             if(T[v]) Y.push_back(v);  // Y中的已标记点
         return ans;
     }
 };

 BPM solver;

 int R, C, N;

 int main()
 {
     int kase = ;
     while(scanf("%d%d%d", &R, &C, &N) ==  && R && C && N)
     {
         solver.init(R, C);
         for(int i = ; i < N; i++)
         {
             int r, c;
             scanf("%d%d", &r, &c);
             r--;
             c--;
             solver.AddEdge(r, c);
         }
         vector<int> X, Y;
         int ans = solver.mincover(X, Y);
         printf("%d", ans);
         for(int i = ; i < X.size(); i++) printf(" r%d", X[i]+);
         for(int i = ; i < Y.size(); i++) printf(" c%d", Y[i]+);
         printf("\n");
     }
     return ;
 }