八皇后的问题

题意： 

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

 

Input

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

 

Output

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

 

Sample Input

1

8

5

0

 

Sample Output

1

92

10

 

 

 

 思路分析：

     

        用DFS，回溯的方法。对于这种案例多的，可以先打表。

        先把第一个皇后放在第一行的第一列，然后放第二行，此时要判断第二个皇后能不能攻击第一个皇后（不能攻击即不在同一行，同一列，对角线）攻击不到就接着放第三行的皇后，若此时第三个皇后的位置（假设在第三行第一列）会攻击前面的皇后，那么就换成第三行第二列，一直不行就一直换，如果这一行任何一个位置都不行，那么就回溯到第二行，把第二行的皇后所在列数调整一下。。。以此类推。。

 

        设queue1(x,y),queue2(x1,y1)

        在同一条对角线：x-x1=y-y1和x+x1=y+y1

源代码如下：

 

        

#include<iostream>
#include<cstring>
#include<stdio.h>
using namespace std;
int q, num;
int map[12];

void dfs(int cow)
{
    int column, k, flag;
    if (cow == q + 1)                  //越界，则结束
    {
        num++;
        return;
    }
    else{

        for (column = 1; column <= q; column++)
        {
            map[cow] = column;     //把第cow行的皇后放在第cloumn列
            flag = 1;
            for (k = 1; k < cow; ++k) //小于cow，放接下来的皇后
            {
                if (map[k] == column || cow - map[cow] == k - map[k] || cow + map[cow] == k + map[k])
                {
                    flag = 0;
                    break;
                }
            }

            if (flag)
                dfs(cow + 1);
        }
    }

}

int main()
{
    int n;
    int queue[11];
    for (q = 1; q <= 10; ++q)
    {
        num = 0;
        dfs(1);
        queue[q] = num;
    }                                             //打表
    while (cin >> n)
    {
        if (n == 0)
            return 0;
        cout << queue[n] << endl;
    }
    
    return 0;
}

心得：

     八皇后的问题弄了好久，理解比之前深刻一些，回溯是一种很好的方法，但是要注意找到越界条件，还有就是在什么时候递归，当时在下面这段代码纠结好久，特别不懂为什么要这样写，但是慢慢看，后面还是看懂了，希望以后能够运用上这种方法！加油~

for (column = 1; column <= q; column++)
        {
            map[cow] = column;     //把第cow行的皇后放在第cloumn列
            flag = 1;
            for (k = 1; k < cow; ++k) //小于cow，放接下来的皇后
            {
                if (map[k] == column || cow - map[cow] == k - map[k] || cow + map[cow] == k + map[k])
                {
                    flag = 0;
                    break;
                }
            }

            if (flag)
                dfs(cow + 1);
        }