-----暴力dfs+回溯 hdu 1045-Fire Net

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
题目大意：给你一个n行n列的方块格子，每个格子上可能是空地，也可能是墙壁，然后空地上可以放炮弹，炮弹可以向上下左右发射，墙壁可以阻挡炮弹的攻击，要求你再空地上放炮弹，使得炮弹之间不能相互攻击，求能放的炮弹的最大数目

解题思路：因为n的数据量很小，所以可以直接dfs枚举+回溯；
一开始的时候我的想法是，用vis数组（初始化vis=0)标记空格是否被放过炮弹，同时vis也标记放过炮弹的同行和同列，直到遇到炮弹为止，如果vis被标记为1的话，这个格子就不能放了；但是这个想法不对…因为回溯的时候只能把放过炮弹的还原，同行同列的不能还原；

后来看来人家的写法…发觉自己还是太弱/(ㄒoㄒ)/~~
正确思路：从第一行第一列开始搜，然后要判断该位置能不能放炮弹，能不能放要判断它的同一行，和同一列是否曾经放过炮弹，如果没有的话，可以放，或者是即使同行或者同列有炮弹存在，但是有墙壁的阻隔，所以也能放，放上去后把把该位置更新为#，代表炮弹的存在，一直搜到没有位置放炮弹为止

#include <iostream>#include <cstdio>#include <cstring>#include <stdio.h>#include <stdlib.h>using namespace std;int n,coun;char map[6][6];int judge(int x,int y) ///判断x,y这个位置能不能放炮弹{    if(map[x][y]=='X') return 0;    if(map[x][y]=='#')  return 0;    for(int i=y+1; i<=n; i++)    {        if(map[x][i]=='#') return 0;///这一列有放过炮弹        if(map[x][i]=='X') break;    }    for(int i=y-1; i>=1; i--)    {        if(map[x][i]=='#') return 0;///这一列有放过炮弹        if(map[x][i]=='X') break;    }    for(int i =x+1; i<=n; i++)    {        if(map[i][y]=='#') return 0;///这一行有放过炮弹        if(map[i][y]=='X') break;    }    for(int i =x-1; i>=1; i--)    {        if(map[i][y]=='#') return 0;///这一行有放过炮弹        if(map[i][y]=='X') break;    }    return 1;}void dfs(int i,int j,int step)///什么时候开始回溯{    int flag=0;    if(step>coun) coun=step;    for(int x=i; x<=n; x++)        for(int y=1; y<=n; y++)        {            if(x==i&&y<j) continue;///避免重复            if(judge(x,y)==1)            {                flag=1;                map[x][y]='#';                dfs(x,y,step+1);                map[x][y]='.';            }        }    if(flag==1)        return;}int main(){    while(~scanf("%d",&n)&&n)    {        for(int i=1; i<=n; i++)            for(int j=1; j<=n; j++)                cin>>map[i][j];        coun=0;        dfs(1,1,0);        printf("%d\n",coun);    }}