LightOJ 1152 Hiding Gold 最大匹配

题目：http://www.lightoj.com/volume_showproblem.php?problem=1152

题意：有n*m个方格，有些里面有金子，现在用1*2的骨牌覆盖所有的金子，骨牌可以横着放或者竖着放，骨牌可以叠加。求覆盖所有的金子需要多少骨牌

思路：先求出所有的恰好可以用骨牌覆盖的金子，也就是所有两两相邻的金子个数，这些金子两个用一个骨牌覆盖，可以用匈牙利算法来求，相邻的金子连边，把每个金子拆成两个点，求出最大匹配。然后金子数减去两两相邻的金子个数就是落单的金子个数，这些金子每个需要一个骨牌来覆盖，于是求出答案

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;

const int N = 510;
struct edge
{
    int to, next;
} g[N*N];
int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
int head[N], match[N];
int nx, ny, cnt, cas = 0;
bool used[N];
void add_edge(int v, int u)
{
    g[cnt].to = u, g[cnt].next = head[v], head[v] = cnt++;
}
bool dfs(int v)
{
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(! used[u])
        {
            used[u] = true;
            if(match[u] == -1 || dfs(match[u]))
            {
                match[u] = v;
                return true;
            }
        }
    }
    return false;
}
int hungary()
{
    int res = 0;
    memset(match, -1, sizeof match);
    for(int i = 1; i <= nx; i++)
    {
        memset(used, 0, sizeof used);
        if(dfs(i)) res++;
    }
    return res;
}
char mpa[50][50];
int id[50][50];
int main()
{
    int t, n, m;

    scanf("%d", &t);
    while(t--)
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i++)
            scanf(" %s", mpa[i] + 1);
        memset(id, 0, sizeof id);
        int num = 0;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
                if(mpa[i][j] == '*') id[i][j] = ++num; //给每个金子编号
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
                if(id[i][j])
                {
                    for(int k = 0; k < 4; k++)
                    {
                        int nx = i + dx[k], ny = j + dy[k];
                        if(nx >= 1 && nx <= n && ny >= 1 && ny <= m && id[nx][ny]) 
                            add_edge(id[i][j], id[nx][ny]);//对每个金子，和它四个方向上的金子连边，没有就不连
                    }
                }
        nx = ny = num;
        int ans = hungary();
        /*
        *由于对每个金子拆点，求出的最大匹配是双倍的，除以2才是真正的最大匹配，不除以2则是匹配的点，
        *那么节点数 - 匹配的点 = 落单的个数。明显落单的金子每个需要一个骨牌，匹配的点两个需要一个骨牌
        *于是，答案= 节点 - 匹配点 + 匹配点 / 2
        */
        printf("Case %d: %d\n", ++cas, num - ans + ans / 2);//
    }
    return 0;
}