dfs HDU 1045

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

 

 

 

题意:

        给你一个N*N的棋盘,棋盘中有空白格和墙’X’,现在要你在空白格上放大炮,要求任意两个大炮不能在同行或者同列,除非他们之间有一个’X’墙.问你最多能放几门大炮.。

代码1：

/*

用DFS对每个空格做两种选择(放或不放)即可，假设我们当前在r，c位置放了大炮，那么这一步我们还要把从r，c位置往4个方向扩展的所有格子都标记上，然后才是下一步选择。

        对于这种情况,我们应该给所有放大炮的格子定序.即我们假设我们是从上到下,从左到右来放大炮的.所以我们首先枚举第一个大炮应该放的位置,确定了首位后,我们在从该位置之后的所有位置中选出第二个应该放大炮的位置….直到我们到达右下角.(定序)


*/
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=10;
int dr[]={-1,1,0,0};
int dc[]={0,0,-1,1};
char map[maxn][maxn];
int vis[maxn][maxn];
int n;
int ans;//解
void dfs(int pos,int num)//pos是当前位置,num是之前已经放了几个大炮
{
    int r=pos/n, c=pos%n;
    if(map[r][c]=='X') return;
    if(vis[r][c]==1) return;
    int pre_vis[maxn][maxn];
    for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
        pre_vis[i][j]=vis[i][j];//保存下当前的状态,用于回溯
    vis[r][c]=1;//当前位置标记(放大炮)
    ans = max(ans,num+1);
    for(int d=0;d<4;d++)//从当前方向往4个方向走，遇到强就停下来，把所有空格都标记上
    {
        int nr=r, nc=c;
        while(1)
        {
            nr=nr+dr[d], nc=nc+dc[d];
            if(nr<0||nr>=n||nc<0||nc>=n||map[nr][nc]=='X') break;
            vis[nr][nc]=1;
        }
    }
    for(int i=pos+1;i<n*n;i++) //定序,选取下一个位置放大炮
        dfs(i,num+1);
    for(int i=0;i<n;i++)//回溯
    for(int j=0;j<n;j++)
        vis[i][j]=pre_vis[i][j];
}
int main()
{
    while(scanf("%d",&n)==1&&n)
    {
        ans=0;
        memset(vis,0,sizeof(vis));
        for(int i=0;i<n;i++)
            scanf("%s",map[i]);
        for(int i=0;i<n*n;i++) dfs(i,0);
        printf("%d\n",ans);
    }
}
 

方法二：

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=10;
int dr[]={-1,1,0,0};
int dc[]={0,0,-1,1};
char map[maxn][maxn];
int vis[maxn][maxn];
int n;
int ans;//解
void dfs(int pos,int num)//pos是当前位置,num是之前已经放了几个大炮
{
    if(pos==n*n) return ;  //不加这句就会出现越界错误
    dfs(pos+1,num);   //这个地方不放，下面考虑的是这个地方放，同时搜索下一步要回溯。
    int r=pos/n, c=pos%n;
    if(map[r][c]=='X') return;
    if(vis[r][c]==1) return;
    int pre_vis[maxn][maxn];
    for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
        pre_vis[i][j]=vis[i][j];//保存下当前的状态,用于回溯
    vis[r][c]=1;
    ans = max(ans,num+1);
    for(int d=0;d<4;d++)//从当前方向往4个方向走,遇到墙就停下来
    {
        int nr=r, nc=c;
        while(1)
        {
            nr=nr+dr[d], nc=nc+dc[d];
            if(nr<0||nr>=n||nc<0||nc>=n||map[nr][nc]=='X') break;
            vis[nr][nc]=1;
        }
    }
    //for(int i=pos+1;i<n*n;i++) //定序,选取下一个位置放大炮
    dfs(pos+1,num+1);   //直接考虑相邻的下一个格子
    for(int i=0;i<n;i++)//回溯
    for(int j=0;j<n;j++)
        vis[i][j]=pre_vis[i][j];
}
int main()
{
    while(scanf("%d",&n)==1&&n)
    {
        ans=0;
        memset(vis,0,sizeof(vis));
        for(int i=0;i<n;i++)
            scanf("%s",map[i]);
        dfs(0,0);
        printf("%d\n",ans);
    }
}