八皇后问题——学习笔记

八皇后问题属于非常经典的算法问题。

 

先介绍下问题：

在一个8*8的国际象棋中，

放着八个皇后，使其互相不能攻击。

每个皇后的攻击范围为：皇后所在行、列以及对角线。

问题要求是找出所有可能的摆法。

 

这个问题其实挺像数独的，只不过数独只需要满足行列不重合即可。

 

然后呢，怎么解决这个问题呢，我先介绍一个比较容易接受的思路：

由于任意两个皇后都不可能在同一行，所以我们可以一行一行的往下摆，每行找个空位丢一个皇后即可。

首先第一行，找任一空位先丢一个皇后，如下（Q代表皇后，N代表空位）：

 Q, N, N, N, N, N, N, N
 N, N, N, N, N, N, N, N
 N, N, N, N, N, N, N, N
 N, N, N, N, N, N, N, N
 N, N, N, N, N, N, N, N
 N, N, N, N, N, N, N, N
 N, N, N, N, N, N, N, N
 N, N, N, N, N, N, N, N

看起来空位其实还有很多，但是实际上Q所在的行、列、对角线已经不能放其他Q了，那我们何不把这些位置标出来呢，我用X来标记，如下：

 Q, X, X, X, X, X, X, X
 X, X, N, N, N, N, N, N
 X, N, X, N, N, N, N, N
 X, N, N, X, N, N, N, N
 X, N, N, N, X, N, N, N
 X, N, N, N, N, X, N, N
 X, N, N, N, N, N, X, N
 X, N, N, N, N, N, N, X

这样一来下一次查找就可以直接滤过X标记的位置了。让我们顺着找下一行：

 Q, X, X, X, X, X, X, X
 X, X, Q, X, X, X, X, X
 X, X, X, X, N, N, N, N
 X, N, X, X, X, N, N, N
 X, N, X, N, X, X, N, N
 X, N, X, N, N, X, X, N
 X, N, X, N, N, N, X, X
 X, N, X, N, N, N, N, X

接下去的就交给代码来说明吧

enum MyEnum
{
	N = 0,
	Q = 1,
	X = 2
};

static const int L = 8;
 
int a[L][L] = { 0 };

//a为上一行完成标记的数组，num为行数
int Queens(int a[L][L], int row) {

	//当找到9个Q时，返回1
	if (row == L) {
		return 1;
	}

	int b[L][L];
	int count = 0;//用来记录前面row皇后使用该摆列时所有可能的摆列数目

	//循环L次找出该行所有的空位
	for (int i = 0; i < L; i++) {
		if (a[row][i] == N) {
			memcpy(b, a, sizeof(int)*L*L);

			b[row][i] = Q;

			//将新Q所在列和行所有N标记为X
			for (int j = 0; j < L; j++) {
				if (b[row][j] == N) {
					b[row][j] = X;
				}

				if (b[j][i] == N) {
					b[j][i] = X;
				}
			}

			//将左上角所有N标为X
			for (int j = 0, k = row, m = i; j < L; j++) {
				if (--k < 0) {
					break;
				}

				if (--m < 0) {
					break;
				}

				b[k][m] = X;
			}

			//将右下角所有N标为X
			for (int j = 0, k = row, m = i; j < L; j++) {
				if (++k >= L) {
					break;
				}

				if (++m >= L) {
					break;
				}

				b[k][m] = X;
			}

			//将左下角所有N标为X
			for (int j = 0, k = row, m = i; j < L; j++) {
				if (--k <0) {
					break;
				}

				if (++m >= L) {
					break;
				}

				b[k][m] = X;
			}

			//将右上角所有N标为X
			for (int j = 0, k = row, m = i; j < L; j++) {
				if (++k >=L) {
					break;
				}

				if (--m <0) {
					break;
				}

				b[k][m] = X;
			}
		
			//在此Q基础下，找下一个Q
			count+=Queens(b, row + 1);
		}
	}

	return count;
}

 

代码看起来有点多，实际上大部分代码都是在标记X了，实际上有更好的算法都不需要做什么标记。只需要一个长度为8的数组即可。下面介绍具体思路：

数组下标代表Q所在行，下标对应的值就是Q所在列。例如：

int a[8] = { 0,4,7,5,2,6,1,3 };

就相当于:

 Q, N, N, N, N, N, N, N
 N, N, N, N, Q, N, N, N
 N, N, N, N, N, N, N, Q
 N, N, N, N, N, Q, N, N
 N, N, Q, N, N, N, N, N
 N, N, N, N, N, N, Q, N
 N, Q, N, N, N, N, N, N
 N, N, N, Q, N, N, N, N

用一维数组来表示更加简洁。不多说，上代码：

static const int L=8;
int b[L] = { 0 };

//b一维数组，row所在行
int Queens2(int *b, int row) {
	//计算在该已摆放的Q的条件下，之后有几种可能的八皇后摆法
	int count = 0;

	//摆满八行后，返回1
	if (row == L) {
		return 1;
	}
	
	for (int i = 0; i < L; i++) {
		for (int j = 0; j < row; j++) {
			//判断是否列重合或者在其他Q的对角线上
			if (b[j] == i || abs(row - j) == abs(i - b[j])) {
				goto next;
			}
		}
		b[row] = i;
		//递归寻找下一个Q
		count += Queens2(b, row + 1);
	next:
		continue;
	}

	return count;
}

这个就相当简洁清爽了。也几乎是标准写法了，当然我这里借助了goto，可能有的人不适应，goto只要不用来作死还是不错的工具啦。

推荐一个知乎上大神们写的十行代码解决八皇后问题。各种乱七八糟，看看就好。

题外话，这里的八皇后问题其实是可以延申到N皇后的，大家可以自行探索。