POJ 3020 Antenna Placement(匈牙利算法—最小路径覆盖)

题目链接：POJ 3020 Antenna Placement

首先要明确的是，输入的一堆“圈圈星星”可以看做是一张大地图，地图上有所有城市的坐标，但是这里有一个误区：不能简单地把城市的两个x、y坐标作为准备构造的二分图的两个顶点集。

城市才是要构造的二分图的顶点！

构造方法如下：

例如输入：

*oo

***

O*o

时，可以抽象为一个数字地图：

100

234

050

数字就是根据输入的城市次序作为该城市的编号，0代表该位置没有城市。

然后根据题目的“范围”规则，从第一个城市开始，以自身作为中心城市，向四个方向的城市进行连线（覆盖）

因此就能够得到边集：

e12 e21 e32 e43 e53

e23 e34

e35

可以看到，这些边都是有向边，但是每一条边都有与其对应的一条相反边。

即任意两个城市（顶点）之间的边是成对出现的

那么我们就可以确定下来，应该 构造无向二分图（其实无向=双向）

因为若要构造有向的二分图时，需要判断已出现的边，是很麻烦的工作



为了把有向图G构造为无向二分图，这里需要引入一个新名词“拆点”

其实就是把原有向图G的每一个顶点都”拆分（我认为复制更准确）”为2个点，分别属于所要构造的二分图的两个顶点集



例如在刚才的例子中抽出一条有向边e12举例说明：

复制顶点1和顶点2，使得1，2∈V1； 1’，2’∈V2 ，不难发现|V1|=|V2|

根据边e12和e21，得到无向二分图：




那么同理就可以得到刚才的例子的 无向二分图为：




再继而通过无向二分图，以V1的元素作为row，V2的元素作为col，构造 可达矩阵 存储到计算机

1’ 2’ 3’ 4’ 5’

1 F T F F F

2 T F T F F

3 F T F T T

4 F F T F F

5 F F T F F



接下来就是要求这个 无向二分图的最小路径覆盖 了

利用公式：



无向二分图的最小路径覆盖 = 顶点数 – 最大二分匹配数/2



顶点数：就是用于构造无向二分图的城市数，即进行“拆点”操作前的顶点数量

最大二分匹配书之所以要除以2，是因为进行了“拆点”擦奥做做使得匹配总数多了一倍，因此除以2得到原图的真正的匹配数



最后剩下的问题就是求最大二分匹配数了，用匈牙利算法，这就不多说了，参考POJ3041的做法，基本一摸一样。



从这道题得出了一个结论：

当二分图的两个顶点子集基数相等时，该二分图所有顶点的匹配数 等于 任意一个顶点子集匹配数的2倍

以上来自：http://blog.csdn.net/lyy289065406/article/details/6647040

这个题并没有说求出来的路径不相交，但是想想题意中已经隐含了这一点。

1、每个基站只能覆盖两个，那显然不会出现交叉出十字路口这一情况。

2、相交于端点这种情况也是不存在，或者说没用的，假如有三个点，有两个点都和另一点相连，这样也是需要两个基站，那连一条线，另一个点不连线，这样也是需要两个基站。

综合以上两种情况，这题也是符合最小路径覆盖的。

上边写的是错的。。

今天做POJ 2060 突然明白了这题不用Floyd的根本原因：建图时候把所有能连的点都连起来了，那就相当求了一遍Floyd~ 04/06/2014

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int MAX_N = 40 + 10;
const int MAX_M = 10 + 5;
const int MAX_K = MAX_N * MAX_M;

bool _map[MAX_K][MAX_K], vis[MAX_K];
int link[MAX_K], n, k, cnt, newG[MAX_N][MAX_M];
char G[MAX_N][MAX_M];

bool dfs(int u)
{
    for(int i = 1; i <= cnt; i++)
    {
        if(!vis[i] && _map[u][i])
        {
            vis[i] = 1;
            if(link[i] == -1 || dfs(link[i]))
            {
                link[i] = u;
                return true;
            }
        }
    }
    return false;
}
int MaxMatch()
{
    int num = 0;
    memset(link, -1, sizeof(link));
    for(int i = 1; i <= cnt; i++)
    {
        memset(vis, 0, sizeof(vis));
        if(dfs(i))
            num++;
    }
    return num;
}
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        cnt = 0;
        memset(_map, 0, sizeof(_map));
        memset(newG, 0, sizeof(newG));
        scanf("%d%d", &n, &k);
        for(int i = 0; i < n; i++)
            scanf("%s", G[i]);
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < k; j++)
            {
                if(G[i][j] == '*')
                {
                    cnt++;
                    newG[i][j] = cnt;
                }
            }
        }
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < k; j++)
            {
                if(newG[i][j] > 0)
                {
                    if(i != 0)
                        if(newG[i - 1][j] > 0)
                            _map[newG[i][j]][newG[i - 1][j]] = 1;
                    if(i != n - 1)
                        if(newG[i + 1][j] > 0)
                            _map[newG[i][j]][newG[i + 1][j]] = 1;
                    if(j != 0)
                        if(newG[i][j - 1] > 0)
                            _map[newG[i][j]][newG[i][j - 1]] = 1;
                    if(j != k - 1)
                        if(newG[i][j + 1] > 0)
                            _map[newG[i][j]][newG[i][j + 1]] = 1;
                }
            }
        }
        printf("%d\n", cnt  - MaxMatch() / 2);
    }
    return 0;
}