HDOJ 2553 N皇后问题

N皇后问题

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 31488    Accepted Submission(s): 13639

Problem Description

在N*N的方格棋盘放置了N个皇后，使得它们不相互攻击（即任意2个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成45角的斜线上。
你的任务是，对于给定的N，求出有多少种合法的放置方法。

 

Input

共有若干行，每行一个正整数N≤10，表示棋盘和皇后的数量；如果N=0，表示结束。

 

Output

共有若干行，每行一个正整数，表示对应输入行的皇后的不同放置数量。

 

Sample Input

1 8 5 0

 

Sample Output

1 92 10

第一次代码：

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stack>
using namespace std;
int solve = 0;
int len;
int a[11];
stack <bool> state;
void dfs(int x,bool**board,int setnum, int allnum)
{
  if(setnum == allnum)
  {
      solve++;
      return;
  }
  for(int i=0;i<len;i++)
  {
     if(board[x][i]==true)
     {
        int xx,yy;
        //保存状态
        for(int j=0;j<len;j++)
            for(int k=0;k<len;k++)
            state.push(board[j][k]);
        //置不可摆放位
        for(int k =0;k<len;k++)
        {
            board[x][k] =false;
            board[k][i] =false;
            //置斜对角
            xx = x + k;
            yy = i + k;
            if(xx>=0 && xx<len && yy>=0 && yy<len)
            {
                board[xx][yy] = false;
            }
            xx = x - k;
            yy = i - k;
            if(xx>=0 && xx<len && yy>=0 && yy<len)
            {
                board[xx][yy] = false;
            }

            xx = x + k;
            yy = i - k;
            if(xx>=0 && xx<len && yy>=0 && yy<len)
            {
                board[xx][yy] = false;
            }

            xx = x - k;
            yy = i + k;

            if(xx>=0 && xx<len && yy>=0 && yy<len)
            {
                board[xx][yy] = false;
            }
        }

        dfs(x+1,board,setnum+1,allnum);

        //回溯恢复状态表
       for(int j=len-1;j>=0;j--)
            for(int k=len-1;k>=0;k--)
            {
                board[j][k] = state.top();
                state.pop();
            }

     }

  }
}

int main(void)
{

   for(int p=1;p<=10;p++)
   {
     len = p;
     bool **board = new bool*[len];
     for(int i=0;i<len;i++)
     {
         board[i] = new bool[len];
     }
      solve = 0;
      for(int i=0;i<len;i++)
        for(int j =0;j<len;j++)
        board[i][j] = true;
      dfs(0,board,0,len);
      a[p] = solve;
      for(int i =0;i<len;i++)
        delete [] board[i];
      delete []board;

   }
   while(cin>>len&&len)
   {
       cout<<a[len]<<endl;
   }
}

后来看了别人的代码，精炼简介，汗颜。参考下下这位老哥的解题思路，自己重新写了下

这是一道深搜题目！问题的关键是在剪枝。

下面我们对问题进行分析：

1.一行只能放一个皇后，所以我们一旦确定此处可以放皇后，那么该行就只能放一个皇后，下面的就不要再搜了。

2.每一列只能放一个皇后，所以我们下次搜索就不要再搜已经放过的皇后了。

3.斜的45°线也只能放一个。

综上如何才能最快速的确定一列和45°是否用过这个是个关键步骤，一旦此步骤确定我们就可以很快的进行搜索了。

我们用三个数组来保存他的每一个状态及（三个方向 ↖ ↑ ↗）

但是如果我们保存↑（每一列方向上的皇后）是非常容易保存的 但是保存（ 这两个方向上的状态就不容易了↖ ↗）

 

再分析，在这个（↖）方向上的数据的行和列有什么特点

 0  1  2  3   4

-1  0  1  2  3

-2 -1  0  1  2

-3 -2 -1  0  1

-4 -3 -2 -1  0 

将此表列出我们就应该知道在（↖）方向上的数据的行和列的特点了，及   在 （↖）方向上  列 - 行 的差是相等的。

假如我们用数组保存负数肯定是不行的， 所以我们要加上 n,让他变为非负.

 

再分析，在这个（ ↗）方向上的数据的行和列有什么特点

0 1 2 3 4

1 2 3 4 5

2 3 4 5 6

3 4 5 6 7

将此表列出我们就应该知道在（↗）方向上的数据的行和列的特点了，及   在 （↗）方向上  列 + 行 的和是相等的。

知道数据怎么处理就可以解决问题了。

第二次代码：

#include<iostream>
#include<string.h>
using namespace std;
int board[3][50];
int method[11];
int sum = 0;
void dfs(int n,int len)
{
    if(n==len)
    {
       sum++;
       return;
    }
    for(int i=0;i<len;i++)
    {
       if(board[0][i]==0&&board[1][i+n]==0&&board[2][n-i+len-1]==0)
       {
           //变值
           board[0][i] = board[1][i+n] = board[2][n-i+len-1] = 1;
           //深搜
           dfs(n+1,len);
           //回溯
           board[0][i] = board[1][i+n] = board[2][n-i+len-1] = 0;
       }
    }

}
int main()
{
   int len;
   //打表
   for(int i=1;i<11;i++)
   {
       sum = 0;
       dfs(0,i);
       method[i] = sum;
   }
   while(cin>>len&&len)
   {
      cout<<method[len]<<endl;
   }
   return 0;
}