hdu1045Fire Net(经典dfs)

Fire Net

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

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表示墙，.表示空位置，问最多可以放多少炮台

题解：dfs搜索。边搜索边计数，如果遇到不能放的情况就回溯。从左上角开始放，放到右下角的时候退出dfs。判断该位置能不能放：找该位置前面和上面（因为是从左上角开始放的，所以只要看前面和上面）有没有炮台，如果有炮台又没有墙挡住那就不能放，其他情况都可以放（只要该位置为空）。

有个n*n二维数组的技巧：如果该位置是第k个元素，那么该位置的行坐标为k/n,列坐标为k%n！！！！

 #include<bits/stdc++.h>
 using namespace std;
 int n;
 char s[][];int ans;
 int check(int x,int y) {
     for(int i=x-; i>=; i--) { //同一列往上找
         if(s[i][y]=='')//遇到有碉堡肯定不能放
             return ;
         if(s[i][y]=='X')
             return ;
     }
     for(int i=y-; i>=; i--) { //同一行往左边找
         if(s[x][i]=='')//遇到有碉堡肯定不能放
             return ;
         if(s[x][i]=='X')
             return ;
     }
     return ;
 }
 void dfs(int k,int num) {
     int x,y;
     if(k==n*n)
     {
         ans=max(ans,num);return ;
     }
     else
     {
         x=k/n;//重要的技巧！！！
         y=k%n;
         if(s[x][y]=='.'&&check(x,y))
         {
             s[x][y]='';
             dfs(k+,num+);//继续寻找并计数
             s[x][y]='.';//回溯
         }
         dfs(k+,num);//放不了，继续寻找，数量保持不变
     }
 }
 int main() {
     while(~scanf("%d",&n),n) {
         memset(s,'\0',sizeof(s));
         ans=;
         for(int i=; i<n; i++) {
             getchar();//用来输入回车，不然他会把回车存到s数组里面
             for(int j=; j<n; j++) {
                 scanf("%c",&s[i][j]);
             }
         }
         dfs(,);//(0,0)开始走
         printf("%d\n",ans);
     }
     return ;
 }