ZOJ1002 Fire Net DFS（深度优先搜索） 已AC

Fire Net

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

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.

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.

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

题目的意思就是在n*n的方阵里放炮塔，炮塔可以向上下左右攻击，直到被墙挡住才停止，问我们最多可以放多少个互不攻击的炮塔。

我第一次写的时候没有考虑放与不放这个问题，导致前三组输出数据都对，但到第四组就出了问题，第四组的第一个格子应是不能放的。所以这题要用到DFS（深度优先搜索），可能有些和我一样的菜鸟不知道这是啥意思，所以小Ray就在此解释一下（知道的大神就直接跳过哈）

DFS

以下是核心代码

1. ** 
2.  * DFS核心伪代码 
3.  * 前置条件是visit数组全部设置成false 
4.  * @param n 当前开始搜索的节点 
5.  * @param d 当前到达的深度，也即是路径长度 
6.  * @return 是否有解 
7.  */  
8. bool DFS(Node n, int d){  
9.     if (d == 4){//路径长度为返回true，表示此次搜索有解  
10.         return true;  
11.     }  
12.   
13.     for (Node nextNode in n){//遍历跟节点n相邻的节点nextNode，  
14.         if (!visit[nextNode]){//未访问过的节点才能继续搜索  
15.   
16.             //例如搜索到V1了，那么V1要设置成已访问  
17.             visit[nextNode] = true;  
18.   
19.             //接下来要从V1开始继续访问了，路径长度当然要加  
20.   
21.             if (DFS(nextNode, d+1)){//如果搜索出有解  
22.                 //例如到了V6，找到解了，你必须一层一层递归的告诉上层已经找到解  
23.                 return true;  
24.             }  
25.   
26.             //重新设置成未访问，因为它有可能出现在下一次搜索的别的路径中  
27.             visit[nextNode] = false;  
28.   
29.         }  
30.         //到这里，发现本次搜索还没找到解，那就要从当前节点的下一个节点开始搜索。  
31.     }  
32.     return false;//本次搜索无解  
33. }  

简而言之就是不断往深度搜索，如果条件不成立就返回上一个结点，然后在上一个结点处选择另一条路径。类似于二叉树的遍历加上了条件。详细的请看 http://rapheal.iteye.com/blog/1526863。

题目分析：这道题不像八皇后那样，只需考虑八个皇后（八行）的状态（因为每一行都会影响到其余行），这里因为有墙将格子分隔开，所以每一个格子，所以并不是每一个格子都是互相有联系的，一个格子只与某些格子有联系而且我们不知道是哪些格子（因为墙是随机的），所以我们需要判断每一个格子。

比如：第一个放炮塔，第二个放，第三个放。。。。。以此类推

第一个不放，第二个放，第三个放。。。。。。

第一个不放，第二个不放，第三个放。。。。。

以下是代码：

#include <iostream>
#include <algorithm>
using namespace std;
char ori[99][99];//其实只用开到5就可以了，但我刚看题的时候没有注意到最大只到4.。。。。。
char pro[99][99];
int ans=0;//最终的答案
int n;
int cnt=0;//每一种情况下炮塔的个数
bool f(int k)//用来判断此处是否可以放炮塔
{
    //这里用了比较傻的办法，将其分成四个方向，厉害的大神可以用%的方法，可以把四个循环缩减到两个
    //k代表的是第几个格子，k/n即为这个格子的行数，k%n为列数
    for(int i=k/n-1;i>=0;i--)
    {
        if(pro[i][k%n]=='X')//如果到墙就结束
            break;
        if(pro[i][k%n]=='0')//如果有炮塔在这条线上就返回false
            return false;
    }
    for(int i=k/n+1;i<n;i++)
    {
        if(pro[i][k%n]=='X')
            break;
        if(pro[i][k%n]=='0')
            return false;
    }
    for(int i=k%n-1;i>=0;i--)
    {
        if(pro[k/n][i]=='X')
            break;
        if(pro[k/n][i]=='0')
            return false;
    }
    for(int i=k%n+1;i<n;i++)
    {
        if(pro[k/n][i]=='X')
            break;
        if(pro[k/n][i]=='0')
            return false;
    }
    return true;
}
void DFS(int k)
{
    for(int i=k;i<n*n;i++)
    {
        if(pro[i/n][i%n]=='.'&&f(i))//判断是否已经放过
        {
            pro[i/n][i%n]='0';
            cnt++;
            DFS(k+1);//开始看下一个格子的情况
            if(cnt>ans)ans=cnt;//到这里一种情况就已经结束，就要判断这种情况下炮塔是不是最多的
            pro[i/n][i%n]='.';//代表着这个位置不放,例如DFS(0)（有放炮塔）这个分支结束时，开始第二个分支DFS(0)(没放炮塔）
            cnt--;//对应的次数也要减1
        }
    }
}
int main()
{
    while(cin>>n&&n)
    {
        ans=0;cnt=0;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
            {
                cin>>pro[i][j];
            }
        DFS(0);
        cout<<ans<<endl;
    }
    return 0;
    
}