n皇后问题

n皇后问题是指在一个n*n的国际象棋棋盘上放置n个皇后，使得这n个皇后两辆均不在同一行、同一列，同一对角线上，求合法的方案数。

既然题目中要求每行、每列都只能放置一个皇后，如果把n列皇后所在的行号依次写出，那么就会是一个1~n的排列（反之同理），于是就可以得到n！个排列。于是就可以在全排列的基础上求解，由于当到达递归边界时表示生成了一个排列，所以需要在其内部判断是否为合法方案，即遍历每两个皇后，判断它们是否在同一条对角线上。

#include <stdio.h>
#include <stdlib.h>
int n;//有几个皇后
const int maxn = 10;
int P[maxn];
int hashTable[maxn] = {false};
int count;

void generateP(int index)
{
	if(index == n + 1)//递归边界
	{
		bool flag = true;
		for(int i = 1; i <= n; i++)//遍历任意两个皇后
		{
			for(int j = i + 1; j <= n; j++)
			{
				if(abs(i - j) == abs(P[i] - P[j]))//0
				{
					flag = false;//不合法
				}
			}
		}
		if(flag)//若当前方案合法，令count加1
		{
			count++;
		}
		return;
	}

	for(int x = 1; x <= n; x++)
	{
		if(hashTable[x] == false)
		{
			P[index] = x;
			hashTable[x] = true;
			generateP(index + 1);
			hashTable[x] = false;
		}
	}
}
int main(void)
{
	scanf("%d", &n);
	generateP(1);
	printf("%d", count);
	return 0;
}

上述这种方法是通过枚举所有情况，然后判断每一种情况是否合法，称为暴力法

事实上，当已经放置了一部分皇后时（对应于生成排列的一部分），可能剩余的皇后无论怎么放置都不可能合法，此时就没有必要向下递归了，直接返回上层即可，这样可以减少很多计算量。

一般来说，如果在到达递归边界前的某层，由于一些事实导致已经不需要往任何一个子问题递归，就可以直接返回上一层。一般把这种方法称为回溯法。

#include <stdio.h>
#include <stdlib.h>
const int maxn = 10;
int P[maxn];
bool hashTable[maxn] = {false};
int n;
int count = 0;

void generateP(int index)
{
    if(index == n + 1)
    {
        count++;
        return;
    }
    for(int x = 1; x <= n; x++)
    {
        if(hashTable[x] == false)
        {
            bool flag = true;
            for(int pre = 1; pre < index; pre++)
            {
                if(abs(index - pre) == abs(x - P[pre]))
                {
                    flag = false;
                    break;
                }
            }
            if(flag)
            {
                P[index] = x;
                hashTable[x] = true;
                generateP(index + 1);
                hashTable[x] = false;
            }
        }
    }
}

int main(void)
{
    scanf("%d", &n);
    generateP(1);
    printf("%d", count);
    return 0;
}