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);
}
}
