Java数据结构与算法———（27）八皇后问题

八皇后问题：在8 × 8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

一、代码

package recursion;

/**
 * 八皇后问题：在8 × 8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。
 * 说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题。arr[8] = {0 , 4, 7, 5, 2, 6,
 * 1, 3}，对应 arr 的下标 表示第几行，即第几个皇后，arr[i] = val，表示第i+1个皇后，放在第i+1行的第val+1列
 * 
 * @author Lee
 */
public class Queue8 {
	// 定义一个max表示共有多少个皇后
	int max = 8;
	static int count = 0;//统计共有多少种解法
	static int judgeCount = 0;//统计判断的次数
	// 定义一个一位数组array，保存皇后放置位置的结果，比如 arr = {0, 4, 7, 5, 2, 6, 1, 3}
	int[] array = new int[max];

	public static void main(String[] args) {
		// 测试8皇后代码是否正确
		Queue8 q = new Queue8();
		q.check(0);// 0表示第1个皇后，然后会自动放第2个，第3个，直到第8个
		System.out.printf("共有%d种解法", count);
		System.out.printf("\n共判断了%d次", judgeCount);
	}

	// 方法：输出皇后摆放的位置
	private void print() {
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println();
		count++;
	}

	// 方法：当放置第n个皇后时，检查该皇后是否和前面已经放置好的皇后冲突
	// 返回true说明不冲突，放回false说明冲突
	private boolean judge(int n) {
		judgeCount++;
		for (int i = 0; i < n; i++) {
			// 说明（关键）：array[i] = val，表示第 i+1 个皇后，放在第 i+1 行的第 val+1 列
			// 1. array[i] == array[n] 表示第 n 个皇后和前面的 n-1 个皇后在同一列上
			// 2. Math.abs(n - i) == Math.abs(array[n] - array[i]) 表示第 n 个皇后和前面的n-1个皇后在一条斜线上
			// 3. 由于n本身代表行数，所以当n不等于i时，第n个皇后和第i个皇后就不在同一行上。由于i<n，所以没有必要判断判断是否在同一行
			if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
				return false;
			}
		}
		return true;
	}

	// 方法：放置第n个皇后
	// 特别注意：check在每一次递归时，进入到check中都有for(int i = 0; i < max; i++)，因此会有回溯
	// n等于0时，表示放第1个皇后，然后会自动放置第2个皇后，直到放置第8个皇后
	private void check(int n) {
		// 当8个皇后都已经放好后
		if (n == max) {// 当n==max，即n==8时，意味着n表示第9个皇后，前面的8个皇后都已经放好了
			print();
			return;
		}

		// 当前放置的皇后是8个中的一个，则依次放入皇后，并判断是否冲突
		for (int i = 0; i < max; i++) {
			// 先把当前这个皇后n，放到该行的第1列
			array[n] = i;// 表示将第n个皇后放到该行的第i列，i是从0开始的，然后自增，表示先放第1列，如果冲突，就放第2列，递归，直到第8列
			// 判断当放置第n个皇后到i列时，是否冲突
			if (judge(n)) {
				// 不冲突，接着放第n+1个皇后，即开始递归
				check(n + 1);
			}
			// 如果冲突，就继续执行array[n]=i，即将第n个皇后的位置在本行后移一个位置
		}
	}
}

二、结果

0 4 7 5 2 6 1 3 
0 5 7 2 6 3 1 4 
0 6 3 5 7 1 4 2 
0 6 4 7 1 3 5 2 
1 3 5 7 2 0 6 4 
1 4 6 0 2 7 5 3 
1 4 6 3 0 7 5 2 
1 5 0 6 3 7 2 4 
1 5 7 2 0 3 6 4 
1 6 2 5 7 4 0 3 
1 6 4 7 0 3 5 2 
1 7 5 0 2 4 6 3 
2 0 6 4 7 1 3 5 
2 4 1 7 0 6 3 5 
2 4 1 7 5 3 6 0 
2 4 6 0 3 1 7 5 
2 4 7 3 0 6 1 5 
2 5 1 4 7 0 6 3 
2 5 1 6 0 3 7 4 
2 5 1 6 4 0 7 3 
2 5 3 0 7 4 6 1 
2 5 3 1 7 4 6 0 
2 5 7 0 3 6 4 1 
2 5 7 0 4 6 1 3 
2 5 7 1 3 0 6 4 
2 6 1 7 4 0 3 5 
2 6 1 7 5 3 0 4 
2 7 3 6 0 5 1 4 
3 0 4 7 1 6 2 5 
3 0 4 7 5 2 6 1 
3 1 4 7 5 0 2 6 
3 1 6 2 5 7 0 4 
3 1 6 2 5 7 4 0 
3 1 6 4 0 7 5 2 
3 1 7 4 6 0 2 5 
3 1 7 5 0 2 4 6 
3 5 0 4 1 7 2 6 
3 5 7 1 6 0 2 4 
3 5 7 2 0 6 4 1 
3 6 0 7 4 1 5 2 
3 6 2 7 1 4 0 5 
3 6 4 1 5 0 2 7 
3 6 4 2 0 5 7 1 
3 7 0 2 5 1 6 4 
3 7 0 4 6 1 5 2 
3 7 4 2 0 6 1 5 
4 0 3 5 7 1 6 2 
4 0 7 3 1 6 2 5 
4 0 7 5 2 6 1 3 
4 1 3 5 7 2 0 6 
4 1 3 6 2 7 5 0 
4 1 5 0 6 3 7 2 
4 1 7 0 3 6 2 5 
4 2 0 5 7 1 3 6 
4 2 0 6 1 7 5 3 
4 2 7 3 6 0 5 1 
4 6 0 2 7 5 3 1 
4 6 0 3 1 7 5 2 
4 6 1 3 7 0 2 5 
4 6 1 5 2 0 3 7 
4 6 1 5 2 0 7 3 
4 6 3 0 2 7 5 1 
4 7 3 0 2 5 1 6 
4 7 3 0 6 1 5 2 
5 0 4 1 7 2 6 3 
5 1 6 0 2 4 7 3 
5 1 6 0 3 7 4 2 
5 2 0 6 4 7 1 3 
5 2 0 7 3 1 6 4 
5 2 0 7 4 1 3 6 
5 2 4 6 0 3 1 7 
5 2 4 7 0 3 1 6 
5 2 6 1 3 7 0 4 
5 2 6 1 7 4 0 3 
5 2 6 3 0 7 1 4 
5 3 0 4 7 1 6 2 
5 3 1 7 4 6 0 2 
5 3 6 0 2 4 1 7 
5 3 6 0 7 1 4 2 
5 7 1 3 0 6 4 2 
6 0 2 7 5 3 1 4 
6 1 3 0 7 4 2 5 
6 1 5 2 0 3 7 4 
6 2 0 5 7 4 1 3 
6 2 7 1 4 0 5 3 
6 3 1 4 7 0 2 5 
6 3 1 7 5 0 2 4 
6 4 2 0 5 7 1 3 
7 1 3 0 6 4 2 5 
7 1 4 2 0 6 3 5 
7 2 0 5 1 4 6 3 
7 3 0 2 5 1 6 4 
共有92种解法
共判断了15720次