HDOJ-----1045Fire Net二分图

Fire Net

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 10283    Accepted Submission(s): 6023

Problem Description

Suppose that we have a square city with straight streets. A map of a city is a square board with n rows and n columns, each representing a street or a piece of wall.

A blockhouse is a small castle that has four openings through which to shoot. The four openings are facing North, East, South, and West, respectively. There will be one machine gun shooting through each opening.

Here we assume that a bullet is so powerful that it can run across any distance and destroy a blockhouse on its way. On the other hand, a wall is so strongly built that can stop the bullets.

The goal is to place as many blockhouses in a city as possible so that no two can destroy each other. A configuration of blockhouses is legal provided that no two blockhouses are on the same horizontal row or vertical column in a map unless there is at least one wall separating them. In this problem we will consider small square cities (at most 4x4) that contain walls through which bullets cannot run through.

The following image shows five pictures of the same board. The first picture is the empty board, the second and third pictures show legal configurations, and the fourth and fifth pictures show illegal configurations. For this board, the maximum number of blockhouses in a legal configuration is 5; the second picture shows one way to do it, but there are several other ways.



Your task is to write a program that, given a description of a map, calculates the maximum number of blockhouses that can be placed in the city in a legal configuration.

 

Input

The input file contains one or more map descriptions, followed by a line containing the number 0 that signals the end of the file. Each map description begins with a line containing a positive integer n that is the size of the city; n will be at most 4. The next n lines each describe one row of the map, with a '.' indicating an open space and an uppercase 'X' indicating a wall. There are no spaces in the input file.

 

Output

For each test case, output one line containing the maximum number of blockhouses that can be placed in the city in a legal configuration.

 

Sample Input

  
  

   
   4
.X..
....
XX..
....
2
XX
.X
3
.X.
X.X
.X.
3
...
.XX
.XX
4
....
....
....
....
0
  
  

 

Sample Output

  
  

   
   5
1
5
2
4
  
  

学长的专题，本来看到这题想的是搜索，但是分类在二分图，就懵了

果然还是菜鸡，二分图想不出来，只好去翻题解了，巨巨真的是巨巨--

就是把所有题目给出的图给筛选一下，重新建图

题意是说建碉堡，碉堡可以上下左右四个方向机枪扫射，为了不互相伤害，每行每列只能有一个，但是墙可以挡子弹，有墙的话，就可以继续建，打不到对方，问最多建多少个，‘.’是空地，可以建碉堡，‘X’是墙

把每一行每一列可以建碉堡的一类地方分别作一个标号

以第一个样例来说，第一行X左端只能建一座碉堡，是同一类，作同一个标号1，右端是一类，作标号2

然后第二行只能建一个，全部做标号3

……

一直到第四行结束

然后从第一列开始，X上方能建一座碉堡，标号1，下方标号2

第二列两个X中间标号3，下方标号4

……

同理到第四列，然后以这些标号为起点与终点建立二分图，即求行与列的最大匹配-----------博大精深

不过唯一有点疑问的地方是，用vector建图会出现错误，不知道为什么，明明点都是一样的，但是邻接表就可以过

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#define ll long long
#define PI acos(-1.0)
#define inf 0x3f3f3f3f
#define mes(a, b) memset(a, b, sizeof(a))
using namespace std;
const int maxn = 100;
int link[maxn], head[maxn];
int row[maxn][maxn], col[maxn][maxn];
bool vis[maxn];
char map[maxn][maxn];
int roww, coll, ans, num;
//vector<int > edge[maxn];
struct node{
    int to, next;
}edge[maxn];
void add(int u, int v){
    edge[num].to = v;
    edge[num].next = head[u];
    head[u] = num++;
}
bool match(int u){
    //for(int i = 0; i < edge[u].size(); i++){
    for(int i = head[u]; i != -1; i = edge[i].next){
        int v = edge[i].to;
        //int v = edge[u][i];
        if(!vis[v]){
            vis[v] = true;
            if(link[v] == -1 || match(link[v])){
                link[v] = u;
                return true;
            }
        }
    }
    return false;
}
int main(){
    int n;
    while(~scanf("%d", &n), n){
        for(int i = 0; i < n; i++){
            scanf(" %s", map[i]);
        }
        roww = coll = 0;
        for(int i = 0; i < n; i++){//以行为起点，要是以列为起点，只要颠倒一下建图顺序就可以了
            roww++;
            for(int j = 0; j < n; j++){
                if(map[i][j] == 'X'){
                    roww++;
                    continue;
                }
                row[i][j] = roww;
            }
        }
        for(int j = 0; j < n; j++){//以列为终点
            coll++;
            for(int i = 0; i < n; i++){
                if(map[i][j] == 'X'){
                    coll++;
                    continue;
                }
                col[i][j] = coll;
            }
        }
        num = ans = 0;
        mes(head, -1);
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(map[i][j] == '.'){
                    add(row[i][j], col[i][j]);//建新的二分图，vector莫名的WA
                    //edge[row[i][j]].push_back(col[i][j]);
                }
            }
        }
        mes(link, -1);
        for(int i = 1; i <= roww; i++){//然后就是求二分图的模板了
            mes(vis, false);
            if(match(i)){
                ans++;
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}