八皇、N皇后后问题
八皇后问题介绍：
八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于 1848 年提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、 同一列或同一斜线上，问有多少种摆法(92)。
算法思路分析：
- 第一个皇后先放第一行第一列
- 第二个皇后放在第二行第一列、然后判断是否 OK， 如果不 OK，继续放在第二列、第三列、依次把所有列都 放完，找到一个合适
- 继续第三个皇后，还是第一列、第二列……直到第 8 个皇后也能放在一个不冲突的位置，算是找到了一个正确 解
- 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解， 全部得到
- 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4 的步骤
- 示意图:
- 说明：
理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题。arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} //对应 arr 下标 表示第几行，即第几个皇后，arr[i] = val, val 表示第 i+1 个皇后，放在第 i+1 行的第 val+1 列。
韩老师的代码：
public class Queue8 {
public static void main(String[] args) {
// 测试一把 ， 8皇后是否正确
Queue8 queue8 = new Queue8();
queue8.check(0);
System.out.printf("一共有%d解法", count);
System.out.println();
System.out.printf("一共判断冲突的次数%d次", judgeCount); // 1.5w
}
/**
* 说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题.
* arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3}
* 对应arr 下标 表示第几行，即第几个皇后， arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列
*/
// 定义一个max表示共有多少个皇后
int max = 8;// 8个皇后摆放在8*8棋盘
// 定义数组array, 保存皇后放置位置的结果,比如 arr = {0 , 4, 7, 5, 2, 6, 1, 3}
int[] array = new int[max];
static int count = 0;// 记录共有多少中摆放方式
static int judgeCount = 0;// 记录判断了多少次
/**
* 编写一个方法，放置第n个皇后 特别注意: check 是 每一次递归时， 进入到check中都有 for(int i = 0; i < max;i++)
* 因此会有回溯
*
* @param n
*/
private void check(int n) {
if (n == max) {
// n = 8: 第n+1=9个皇后, 说明前8个皇后就已经放好
print(); // 输出该情况的摆法
return;// 结束
}
// 依次放入皇后，并判断是否冲突
for (int i = 0; i < max; i++) {
// 先把当前这个皇后 n , 放到该行的第(i+1)列
array[n] = i;
// 判断当放置第n个皇后到i列时，是否冲突
if (judge(n)) {
// 不冲突
// 若不冲突，就接着放n+1个皇后,即开始递归
check(n + 1); //
}
// 如果冲突，就继续执行 array[n] = i; 即将第n个皇后，放置在本行得 后移的一个位置
}
}
/**
* 判断当我们放置第n个皇后, 就去检测该皇后是否和前面已经摆放的皇后冲突
*
* @param n 表示第n个皇后
* @return
*/
private boolean judge(int n) {
judgeCount++;
for (int i = 0; i < n; i++) {
// 说明
// 1. array[i] == array[n] 表示判断 第n个皇后是否和前面的n-1个皇后在同一列
// 2. Math.abs(n-i) == Math.abs(array[n] - array[i]) 表示判断第n个皇后是否和第i皇后是否在同一斜线
// n = 1 放置第 2列:1 <---> n = 1 array[1] = 1
// Math.abs(1-0) == 1 同理 Math.abs(array[n] - array[i]) = Math.abs(1-0) = 1
// 3. 判断是否在同一行, 没有必要，因为 n 每次都在递增
if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
return false;
}
}
return true;
}
// 写一个方法，可以将皇后摆放的位置输出
private void print() {
count++;
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
}
力扣皇后相关题目
-
解题思路：回溯法
-
解题代码：
public class Test36 {
public static void main(String[] args) {
// 测试max=4
System.out.println(new Test36().solveNQueens(4));
}
public List<List<String>> solveNQueens(int max) {
/**
* 说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题.
* arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3}
* 对应arr 下标 表示第几行，即第几个皇后， arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列
*/
// 定义一个max表示共有多少个皇后
int[] array = new int[max];// max个皇后摆放在max*max棋盘
// 返回的结果集
// eg：4个皇后时输出 -> [[.Q.., ...Q, Q..., ..Q.], [..Q., Q..., ...Q, .Q..]]
List<List<String>> res = new ArrayList<>();
// 放置第0（即第1个皇后）,最多放置max个皇后,一维数组array表示的二维棋盘,需要返回的结果集
check(0, max, array, res);
return res;
}
/**
* 回溯法：放置第n个皇后
* @param n 放置第n+1个皇后（n从0开始）
* @param max 最多放置max个皇后
* @param array 一维数组array表示的二维棋盘
* @param res 需要返回的结果集
*/
private void check(int n, int max, int[] array, List<List<String>> res) {
if (n == max) {
// n+1个皇后已经摆放完成，说明前n个皇后就已经放好了
List<String> list = print(array);// 将该情况的摆法存入List<String>
res.add(list);// 将该情况的摆法存入结果集List<List<String>>
return;// 结束
}
// 依次放入皇后，并判断是否冲突
for (int i = 0; i < max; i++) {
// 先把当前这个皇后 n , 放到该行的第(i+1)列
array[n] = i;// 第一个皇后在第一行第一列所有情况出现后，依次放置第n列
if (judge(n, array)) {
// 判断当放置第n个皇后到i列时，是否冲突
// 若不冲突，就接着放n+1个皇后,即开始递归
check(n + 1, max, array, res);
}
// 如果冲突，就继续执行 array[n] = i; 即将第n个皇后，放置在本行得 后移的一个位置
}
}
/**
* 判断摆放第n个皇时,和之前的皇后是否冲突
* @param n
* @param array
* @return
*/
private boolean judge(int n, int[] array) {
for (int i = 0; i < n; i++) {
// 说明
// 1. array[i] == array[n] 表示判断 第n个皇后是否和前面的n-1个皇后在同一列
// 2. Math.abs(n-i) == Math.abs(array[n] - array[i]) 表示判断第n个皇后是否和第i皇后是否在同一斜线
// n = 1 放置第 2列:1 <---> n = 1 array[1] = 1
// Math.abs(1-0) == 1 同理 Math.abs(array[n] - array[i]) = Math.abs(1-0) = 1
// 3. 判断是否在同一行, 没有必要，因为 n 每次都在递增
if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
return false;
}
}
return true;
}
/**
* 将某种情况下的摆放方式存入List<String>并返回
* @param array
* @return
*/
private List<String> print(int[] array) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < array.length; i++) {
// array = [1 3 0 2]
String str = "";
for (int j = 0; j < array.length; j++) {
if (j == array[i]) {
str = str + "Q";
} else {
str = str + ".";
}
}
list.add(str);
}
return list;
}
}