2021-01-11经典的八皇后问题和N皇后问题, 回溯

(25) 2024-05-15 09:01:01

八皇后的来源

八皇后问题是一个以国际象棋为背景的问题:如何能够在8×8的国际象棋棋盘上放置八个皇后,使得任何一个皇后都无法直接吃掉其他的皇后?为了达到此目的,任两个皇后都不能处于同一条横行、纵行或斜线上。八皇后问题可以推广为更一般的n皇后摆放问题:这时棋盘的大小变为n×n,而皇后个数也变成n。当且仅当n = 1或n ≥ 4时问题有解。

八皇后问题最早是由国际象棋棋手马克斯·贝瑟尔(Max Bezzel)于1848年提出。第一个解在1850年由弗朗兹·诺克(Franz Nauck)给出。并且将其推广为更一般的n皇后摆放问题。诺克也是首先将问题推广到更一般的n皇后摆放问题的人之一。

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第1张

 

问题分析

 

我们先不看8皇后,我们先来看一下4皇后,其实原理都是一样的,比如在下面的4*4的格子里,如果我们在其中一个格子里输入了皇后,那么在这一行这一列和这左右两边的对角线上都不能有皇后。

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第2张

所以有一种方式就是我们一个个去试

 

第一行

比如我们在第一行第一列输入了一个皇后

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第3张

第二行

第二行我们就不能在第一列和第二列输入皇后了,因为有冲突了。但我们可以在第3列输入皇后

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第4张

第三行

第三行我们发现在任何位置输入都会有冲突。这说明我们之前选择的是错误的,再回到上一步,我们发现第二步不光能选择第3列,而且还能选择第4列,既然选择第3列不合适,那我们就选择第4列吧

 

第二行(重新选择)

第二行我们选择第4列

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第5张

第三行(重新选择)

第3行我们只有选择第2列不会有冲突

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第6张

第四行

我们发现第4行又没有可选择的了。第一次重试失败

 

第二次重试

到这里我们只有重新回到第一步了,这说明我们之前第一行选择第一列是无解的,所以我们第一行不应该选择第一列,我们再来选择第二列来试试

第一行

这一行我们选择第2列

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第7张

第二行

第二行我们前3个都不能选,只能选第4列

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第8张

第三行

第三行我们只能选第1列

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第9张

第四行

第四行我们只能选第3列

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第10张

最后我们终于找到了一组解。除了这组解还有没有其他解呢,肯定还是有的,因为4皇后是有两组解的,这里我们就不在一个个试了。

 

我们来看一下他查找的过程,就是先从第1行的第1列开始往下找,然后再从第1行的第2列……,一直到第1行的第n列。代码该怎么写呢,看到这里估计大家都已经想到了,这不就是一棵N叉树的前序遍历吗,我们来看下,是不是下面这样的。

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第11张

我们先来看一下二叉树的前序遍历怎么写,不明白的可以参考下373,数据结构-6,树

public static void preOrder(TreeNode tree) {
  
      if (tree == null)        return;    System.out.printf(tree.val + "");    preOrder(tree.left);    preOrder(tree.right);}

二叉树是有两个子节点,那么N叉树当然是有N个子节点了,所以N叉树的前序遍历是这样的

public static void preOrder(TreeNode tree) {
  
      if (tree == null)        return;    System.out.printf(tree.val + "");    preOrder("第1个子节点");    preOrder("第2个子节点");    ……    preOrder("第n个子节点");}

如果N是一个很大的值,这样写要写死人了,我们一般使用循环的方式

public static void preOrder(TreeNode tree) {
  
      if (tree == null)        return;    System.out.printf(tree.val + "");    for (int i = 0; i <n ; i++) {
  
          preOrder("第i个子节点");    }}

搞懂了上面的分析过程,那么这题的代码轮廓就呼之欲出了


 private void solve(char[][] chess, int row) {
     "终止条件"
     return;
 
     for (int col = 0; col < chess.length; col++) {
         //判断这个位置是否可以放皇后
         if (valid(chess, row, col)) {
             //如果可以放,我们就把原来的数组chess复制一份,
             char[][] temp = copy(chess);
            //然后在这个位置放上皇后
            temp[row][col] = 'Q';
            //下一行
            solve(temp, row + 1);
         }
    }
}

我们来分析下上面的代码,因为是递归所以必须要有终止条件,那么这题的终止条件就是我们最后一行已经走完了,也就是

if (row == chess.length) {
  
           return;}

第7行就是判断在这个位置我们能不能放皇后,如果不能放我们就判断这一行的下一列能不能放……,如果能放我们就把原来数组chess复制一份,然后把皇后放到这个位置,然后再判断下一行,这和我们上面画图的过程非常类似。注意这里的第9行为什么要复制一份,因为数组是引用传递,这涉及到递归的时候分支污染问题(后面有时间我会专门写一篇关于递归的时候分支污染问题)。当然不复制一份也是可以的,我们下面再讲。当我们把上面的问题都搞懂的时候,代码也就很容易写出来了,我们来看下N皇后的最终代码

 1public void solveNQueens(int n) {
 2    char[][] chess = new char[n][n];
 3    for (int i = 0; i < n; i++)
 4        for (int j = 0; j < n; j++)
 5            chess[i][j] = '.';
 6    solve(chess, 0);
 7}
 8
 9private void solve(char[][] chess, int row) {
10    if (row == chess.length) {
11        //自己写的一个公共方法,打印二维数组的,
12        // 主要用于测试数据用的
13        Util.printTwoCharArrays(chess);
14        System.out.println();
15        return;
16    }
17    for (int col = 0; col < chess.length; col++) {
18        if (valid(chess, row, col)) {
19            char[][] temp = copy(chess);
20            temp[row][col] = 'Q';
21            solve(temp, row + 1);
22        }
23    }
24}
25
26//把二维数组chess中的数据测下copy一份
27private char[][] copy(char[][] chess) {
28    char[][] temp = new char[chess.length][chess[0].length];
29    for (int i = 0; i < chess.length; i++) {
30        for (int j = 0; j < chess[0].length; j++) {
31            temp[i][j] = chess[i][j];
32        }
33    }
34    return temp;
35}
36
37//row表示第几行,col表示第几列
38private boolean valid(char[][] chess, int row, int col) {
39    //判断当前列有没有皇后,因为他是一行一行往下走的,
40    //我们只需要检查走过的行数即可,通俗一点就是判断当前
41    //坐标位置的上面有没有皇后
42    for (int i = 0; i < row; i++) {
43        if (chess[i][col] == 'Q') {
44            return false;
45        }
46    }
47    //判断当前坐标的右上角有没有皇后
48    for (int i = row - 1, j = col + 1; i >= 0 && j < chess.length; i--, j++) {
49        if (chess[i][j] == 'Q') {
50            return false;
51        }
52    }
53    //判断当前坐标的左上角有没有皇后
54    for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
55        if (chess[i][j] == 'Q') {
56            return false;
57        }
58    }
59    return true;
60}

代码看起来比较多,我们主要看下solve方法即可,其他的方法不看也可以,知道有这个功能就行。solve代码中其核心代码是在17-23行,上面是终止条件的判断,我们就用4皇后来测试一下

solveNQueens(4);

看一下打印的结果

2021-01-11经典的八皇后问题和N皇后问题, 回溯 (https://mushiming.com/)  第12张

我们看到4皇后的时候有两组解,其中第一组和我们上面图中分析的完全一样。

4皇后解决了,那么8皇后也一样,我们只要在函数调用的时候传入8就可以了。同理,要想计算10皇后,20皇后,100皇后……也都是可以的。

 

回溯解决

上面代码中每次遇到能放皇后的时候,我们都会把原数组复制一份,这样对新数据的修改就不会影响到原来的,也就是不会造成分支污染。但这样每次尝试的时候都都把原数组复制一份,影响效率,有没有其他的方法不复制呢,是有的。就是每次我们选择把这个位置放置皇后的时候,如果最终不能成功,那么返回的时候我们就还要把这个位置还原。这就是回溯算法,也是试探算法。我们来看下代码

 1private void solve(char[][] chess, int row) {
 2    if (row == chess.length) {
 3        //自己写的一个公共方法,打印二维数组的,
 4        // 主要用于测试数据用的
 5        Util.printTwoCharArrays(chess);
 6        System.out.println();
 7        return;
 8    }
 9    for (int col = 0; col < chess.length; col++) {
10        if (valid(chess, row, col)) {
11            chess[row][col] = 'Q';
12            solve(chess, row + 1);
13            chess[row][col] = '.';
14        }
15    }
16}

主要来看下11-13行,其他的都没变,还和上面的一样。这和我们之前讲的391,回溯算法求组合问题很类似。他是先假设[row][col]这个位置可以放皇后,然后往下找,无论找到找不到最后都会回到这个地方,因为这里是递归调用,回到这个地方的时候我们再把它复原,然后走下一个分支。最后我们再来看下使用回溯算法解N皇后的完整代码

 public void solveNQueens(int n) {
     char[][] chess = new char[n][n];
     for (int i = 0; i < n; i++)
         for (int j = 0; j < n; j++)
             chess[i][j] = '.';
     solve(chess, 0);
 }
 
 private void solve(char[][] chess, int row) {
    if (row == chess.length) {
        //自己写的一个公共方法,打印二维数组的,
        // 主要用于测试数据用的
        Util.printTwoCharArrays(chess);
        System.out.println();
        return;
    }
    for (int col = 0; col < chess.length; col++) {
        if (valid(chess, row, col)) {
            chess[row][col] = 'Q';
            solve(chess, row + 1);
            chess[row][col] = '.';
        }
    }
}

//row表示第几行,col表示第几列
private boolean valid(char[][] chess, int row, int col) {
    //判断当前列有没有皇后,因为他是一行一行往下走的,
    //我们只需要检查走过的行数即可,通俗一点就是判断当前
    //坐标位置的上面有没有皇后
    for (int i = 0; i < row; i++) {
        if (chess[i][col] == 'Q') {
            return false;
        }
    }
    //判断当前坐标的右上角有没有皇后
    for (int i = row - 1, j = col + 1; i >= 0 && j < chess.length; i--, j++) {
        if (chess[i][j] == 'Q') {
            return false;
        }
    }
    //判断当前坐标的左上角有没有皇后
    for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
        if (chess[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}

 

总结

8皇后问题其实是一道很经典的回溯算法题,我们这里并没有专门针对8皇后来讲,我们这里讲的是N皇后,如果这道题搞懂了,那么8皇后自然也就懂了,因为这里的N可以是任何正整数。

 

递归一般可能会有多个分支,我们要保证每个分支的修改不会污染其他分支,也就是不要对其他分支造成影响,这一点很重要。由于一些语言中除了基本类型以外,其他的大部分都是引用传递,所以我们在一个分支修改之后可能就会对其他分支产生一些我们不想要的垃圾数据,这个时候我们就有两中解决方式,一种就是我们上面讲到的第一种,复制一份新的数据,这样每个分支都会产生一些新的数据,所以即使修改了也不会对其他分支有影响。还一种方式就是我们每次使用完之后再把它复原,一般的情况下我们都会选择第二种,因为这种代码更简洁一些,也不会重复的复制数据,造成大量的垃圾数据。

 

转自:https://mp.weixin.qq.com/s?__biz=MzU0ODMyNDk0Mw==&mid=2247487459&idx=1&sn=f45fc8231198edb3de2acc69e17986ea&chksm=fb419cc3cc3615d5d31d55072d5c2f58e4002aa8c1b637e89f1ef577e253943c04efc39c1b1d&scene=21#wechat_redirect

 

THE END

发表回复