POJ 3020:Antenna Placement(最小路径覆盖)

题目链接：http://poj.org/problem?id=3020

题目给出一个矩阵，矩阵由'*'和‘o'组成，然后按图中操作，看画多少个圈圈可以把

所有的’*‘号都画进去。这样就把所有的’*‘号位置看成一个个顶点，可以看出这是一个

无向图，画圈的时候只能两个相邻的画，题目让找的其实是一个最小路径覆盖，就是

选择最少的边然后包含图中所有的点，答案就是：节点数-最大匹配数（如果是无向图要除2）

假设每个节点都有一条边相连，则有节点数那么多条边，然后求二分图最大匹配，

加入u和v匹配了，那么在求的过程中，v和u匹配又算了一次，但是这是个无向图，其实这是

同一条边，所以如果是无向图，最大匹配数要除2.

AC代码：

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

int H,W;   ///矩阵的长和宽
const int maxn = 100;
const int maxm = 20000;
char Map[maxn][maxn];
int a[maxn][maxn];
int dir[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};    ///上，右，下，左
struct Edge
{
    int v;
    int nex;
}edge[maxm];
int edgeNumber;
int head[maxm];
void addEdge(int u,int v)
{
    edge[edgeNumber].v = v;
    edge[edgeNumber].nex = head[u];
    head[u] = edgeNumber++;
}
int vis[maxm];
int match[maxm];
bool hungry(int u)
{
    for(int i = head[u]; i != -1; i = edge[i].nex)
    {
        int v = edge[i].v;
        if(vis[v]==0)
        {
            vis[v] = 1;
            if(match[v]==0 || hungry(match[v]))
            {
                match[v] = u;
                return true;
            }
        }
    }
    return false;
}
void solve(int id)
{
    memset(match,0,sizeof(match));
    int ans = 0;
    for(int i = 1; i <= id; i++)
    {
        memset(vis,0,sizeof(vis));
        if(hungry(i))
            ans++;
    }
    printf("%d\n",id-ans/2);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&H,&W);
        int id = 0;
        for(int i = 0; i < H; i++)
            for(int j = 0; j < W; j++)
            {
                scanf(" %c",&Map[i][j]);
                if(Map[i][j]=='*')
                    a[i][j] = ++id;
                else
                    a[i][j] = -1;
            }
        edgeNumber = 0;
        memset(head,-1,sizeof(head));
        for(int i = 0; i < H; i++)
            for(int j = 0; j < W; j++)
            {
                if(a[i][j]!=-1)
                {
                    for(int k = 0; k < 4; k++)
                    {
                        int dx = i + dir[k][0];
                        int dy = j + dir[k][1];
                        if(dx>=0&&dx<H&&dy>=0&&dy<W)
                        {
                            if(a[dx][dy]!=-1)
                            {
                                addEdge(a[i][j],a[dx][dy]);
                            }
                        }
                    }
                }
            }
        solve(id);
    }
    return 0;
}