poj-3020

//1336K    0MS    G++
#include <stdio.h>
#include <string.h>

#define H_MAX 41
#define W_MAX 12
#define POINT_MAX H_MAX*W_MAX

int G[H_MAX][W_MAX];
int releationG[POINT_MAX][POINT_MAX];

int H;
int W;
int pointNum;

struct Point {
    int x;
    int y;
    char alone;
    int pair;
};

typedef struct Point Point;

Point V1[POINT_MAX];
Point V2[POINT_MAX];

char waittingMove[POINT_MAX];

char getPair(int id) {
    for (int i = 1; i <= POINT_MAX; i++) {
        if (releationG[id][i]) { // if id connect i
            if (!V2[i].pair) { // if i is not paired yet.
                V1[id].pair = i;
                V2[i].pair = id;
                return 1;
            } else { // be paired with other, try to move other
                if (!waittingMove[V2[i].pair]){ // move other success, if it not waiting move
                    waittingMove[V2[i].pair] = 1;
                    if (getPair(V2[i].pair)) {                    
                        V1[id].pair = i;
                        V2[i].pair = id;
                        return 1;
                    }
                } // if can not move other, just try next connected node.
            }
        }
    }
    return 0;
}

void solve() {
    int lonePointNum = 0;
    for (int i = 0; i < H; i++) {
        for (int j = 0; j < W; j++) {
            int curPointId = G[i][j];
            if (curPointId == 0) {
                continue;
            }
            int negihourNum = 0;
            //up
            
            if (i < H-1) {
                int upId = G[i+1][j];
                if (upId) {
                    releationG[curPointId][upId] = 1;
                    negihourNum++;
                }
            }
            //down
            if (i > 0) {
                int downId = G[i-1][j];
                if (downId) {
                    releationG[curPointId][downId] = 1;
                    negihourNum++;
                }
            }
            //left
            if (j > 0) {
                int leftId = G[i][j-1];
                if (leftId) {
                    releationG[curPointId][leftId] = 1;
                    negihourNum++;
                }
            }
            //right
            if (j < W-1) {
                int rightId = G[i][j+1];
                if (rightId) {
                    releationG[curPointId][rightId] = 1;
                    negihourNum++;
                }
            }
            if (!negihourNum) { // this point is alone
                V1[curPointId].alone = 1;
                V2[curPointId].alone = 1;
                // printf("alone %d %d\n", i, j);
                lonePointNum++;
            }
        }
    }
    // printf("alone point num %d %d\n", lonePointNum, pointNum);

    int edgeNum = 0;
    for (int i = 1; i <= pointNum; i++) {
        memset(waittingMove, 0, sizeof(waittingMove));
        if (!V1[i].alone && getPair(i)) {
            edgeNum++;
        }
    }
    // printf("edgeNum: %d\n", edgeNum);
    printf("%d\n", pointNum - edgeNum/2);
}

int main (){
    int caseNum;
    scanf("%d", &caseNum);
    for (int i = 0; i < caseNum; i++) {
        scanf("%d %d", &H, &W);
        memset(G, 0, sizeof(G));
        memset(releationG, 0, sizeof(releationG));
        memset(V1, 0, sizeof(V1));
        memset(V2, 0, sizeof(V2));
        pointNum = 0;
        for (int j = 0; j < H; j++) {
            char line[W_MAX] = "";
            scanf("%s", line);
            for (int k = 0; k < W; k++) {
                if (line[k] == '*') {
                    // printf("%d %d *\n", j ,k);
                    G[j][k] = ++pointNum;
                    V1[pointNum].x = j;
                    V1[pointNum].y = k;
                    V2[pointNum].x = j;
                    V2[pointNum].y = k;
                }
            }
        }
        solve();
    }
}

先贴一个好的题解：http://blog.csdn.net/lyy289065406/article/details/6647040

二分图果然是建图困难，coding简单，一开始想破了头也不知道如何建图，后来不得不参考别人的题解 ， 最受打击的是自己怎么也不会做的题被别人直接干成水题....

看了题解以后就简单了，采用了点复制这种套路，

每个城市C1,,,,CN 都复制一份D1..DN 分别归属与两个不同点集V1 V2, 而之间的边则是根据城市之间是否相邻来建立的：

e.g: C1和 C4相邻，那么V1中的C1和V2的D4就有连线，V2中的D1和V1中的C4就有连接（因为复制了点），那么一条边在这里就代表着一个天线。

这样，貌似求能覆盖所有城市最少的天线数就是这个二分图的最小边覆盖（覆盖图中所有的点，并且边数最小）了。

不过没有个例外的情况： 如果某个城市Cx没有个任何的城市相邻，那么必然在上面构造的图中，不会有任何的边连接Cx（同样，也不会有任何边连接Dx），

这只能情况下，当然不可能有一个边集覆盖所有的城市（最起码Cx，Dx不可能被覆盖了）。

所以要把这种单独的城市从V1和V2中挑出来，这个也好办，之间做一个排查就可以，搞一个标志位来标示是否是单独的城市。

这样V1 和V2中的城市都是边可达的了（及算一个完全二分图了），

设总共有A个城市，其中有B个单独城市，那么在当前的二分图应该会有2*（A-B）个点（因为都复制了一份，并且单独城市被剔除了）。

那么根据最小边覆盖的公式： 最小边覆盖 S = 2*（A-B）- 最大匹配数P。

而因为此二分图的两个点集是一个复制另外一个，那么其实最后需要的天线数应该是 S/2

而对于单独的城市，必然每个需要一个天线，这样最后需要的从天线数就是：

B + （A-B） - P/2 = A - P/2， 可以看到，其实B这种单独城市的case不用care，貌似最小边覆盖会这种单独点当成1处理。