poj2226Muddy Fields【最小点覆盖(建图的思路比较好）】

大意：如下图告诉你一个矩阵，让你用1 * x (x 为任意值） 的木板去铺符号*  可以覆盖

问最少多少木板能够把所有的*覆盖掉

4 4
*.*.
.***
***.
..*.

Boards 1, 2, 3 and 4 are placed as follows: 
1.2. 
.333 
444. 
..2. 
Board 2 overlaps boards 3 and 4.

分析：
题目要求是把所有的点都覆盖掉
回忆一下之前做过的
这种类型的大概就是二分图的最小点覆盖或者最小边覆盖
那么怎么建立二分图呢
因为X是个不确定值
所以我们尽量让X取值越大越好 
也就是说每一个横向或纵向的*区域都可以看做是一个联通块
那么只要把横向的连通块放在左集合，把纵向的连通块放在右集合 把点看左边
那么只要所有的边被覆盖则就是覆盖掉所有的*了
这样想来因为左右集合放的就是所求的连通块，那么只要求出最小点覆盖集即ok啦
最小点覆盖集 = 二分图最大匹配

代码：

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

const int maxn = 55;
int G[maxn * maxn / 2][maxn * maxn / 2];

int vis[maxn * maxn / 2];
int Link[maxn * maxn / 2];
int n;
bool Find(int u) {
    for(int i = 1; i <= n; i++) {
        if(G[u][i] && !vis[i]) {
            vis[i] = 1;
            if(Link[i] == -1 || Find(Link[i])) {
                Link[i] = u;
                return true;
            }
        }
    }
    return false;
}

int solve() {
    int cnt = 0;
    memset(Link, -1, sizeof(Link));
    for(int i = 1; i <= n; i++) {
        memset(vis, 0, sizeof(vis));
        if(Find(i)) cnt++;
    }
    return cnt;
}

char mat[maxn][maxn];
int vis1[maxn][maxn], vis2[maxn][maxn];
int main() {
    int m;
    for(int i = 0; i <= 50; i++) {
        mat[0][i] = mat[i][0] = '.';
    }
    while(EOF != scanf("%d %d",&n, &m)) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                scanf("
%c",&mat[i][j]);
            }
        }
        int tot1 = 1; int tot2 = 1;
        memset(vis1, 0, sizeof(vis1)); memset(vis2, 0, sizeof(vis2));
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                if(mat[i][j] == '*') {
                    if(!vis1[i][j - 1]) {
                        vis1[i][j] = tot1++;
                    } else {
                        vis1[i][j] = vis1[i][j - 1];
                    }
                    if(!vis2[i - 1][j]) {
                        vis2[i][j] = tot2++;
                    } else {
                        vis2[i][j] = vis2[i - 1][j];
                    }
                }
            }
        }
        memset(G, 0, sizeof(G));
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                if(mat[i][j] == '*') {
                    G[vis1[i][j]][vis2[i][j]] = 1;
                }
            }
        }
        n = max(tot1, tot2);
        printf("%d
",solve());
    }
    return 0;
}