leetcode常规算法题复盘（第五期）——八皇后

题目原文

面试题 08.12. 八皇后

设计一种算法，打印 N 皇后在 N × N 棋盘上的各种摆法，其中每个皇后都不同行、不同列，也不在对角线上。这里的“对角线”指的是所有的对角线，不只是平分整个棋盘的那两条对角线。

注意：本题相对原题做了扩展

示例:

 输入：4
 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
 解释: 4 皇后问题存在如下两个不同的解法。
[
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]

尝试解答

 八皇后老生常谈的问题了，提到回溯思想首先想到的经典例题就是八皇后，不过我的代码好像没太把回溯的味道做出来（虽然确实是回溯算法），先上自己的代码：

class Solution:
    def solveNQueens(self, n: int):
        listQ = [["." for _ in range(n)]for _ in range(n)]
        res = []
        return self.place(0,listQ,res)
        
        
    def place(self,rol,listQ,res):
        if rol==0:
            for i in range(len(listQ)):
                listQ[rol][i]="Q"
                #print(listQ)
                self.place(rol+1,listQ,res)
                listQ[rol][i]="."
            return res
        
        
        
        if rol == len(listQ):
            res.append([''.join(listQ[i]) for i in range(len(listQ))])
            print(res)
            listQ = [["." for _ in range(len(listQ))]for _ in range(len(listQ))]
            
            
        else:
            for i in range(len(listQ)):
                if self.check(rol,i,listQ):
                    listQ[rol][i] = "Q"
                    #print(listQ)
                    self.place(rol+1,listQ,res)
                    listQ[rol][i]="."
        
        
        
        
        
    def check(self,y,x,listQ):
        for j in range(len(listQ)):
            for i in range(len(listQ)):
                if listQ[j][i]=="Q":
                    if j==y or i==x or abs(j-y)==abs(i-x):
                        return False
        return True
    
    
    
    
    
    
if __name__ == "__main__":
    solu = Solution()
    print(solu.solveNQueens(4))

就是最简单的暴力尝试的算法，优化的方法暂时还没想到，还是借鉴一下大佬的思想吧。

后续回溯技能有所长进，增加不传参写法，不需要每次都把整个棋盘都传递了，每次静态地在原棋盘上进行修改。这里需要注意几点：

1、python对于二维以上的数组会有一个很蠢（我认为很蠢）的机制，不管是切片复制还是整体复制，都只是浅层复制，即引用同一个二维数组，因此当改变数组中的某个值时，所有的引用变量都会跟着改变。想要使用深层复制只能要么跟我写的一样，import copy包，调用其中的deepcopy方法；要么就将二维数组展开成一维复制后再组成二维数组，着实有些蠢。

2、设计回溯算法时应该考虑“截断”问题，换种说法就是在某个向下递归的位置一层一层执行下去了并在最后一层return了一个值，然而递归位置下面的所有回溯项都没有机会执行，所以在那种多解问题中，应该慎用return，保证逻辑自洽。

3、注意全局变量与局部变量的关系

4、一行代码生成“棋盘”：

listQ = [["." for _ in range(n)]for _ in range(n)]

import copy
class Solution:
    def solveNQueens(self, n):
        listQ = [["." for _ in range(n)]for _ in range(n)]
        ans = []
        
        def check(N):
            #输入第N行（0-）
            #输出所有可行的col列表
            #先找col
            res = []
            for i in range(n):
                res.append(i)
            for i in range(N):
                for j in range(n):
                    if listQ[i][j]=="Q":
                        if j in res:
                            res.remove(j)
                        if j+(N-i) in res:
                            res.remove(j+(N-i))
                        if j-(N-i) in res:
                            res.remove(j-(N-i))
            return res
        def backTrack(N):
            if N+1==n:
                res = check(N)
                while len(res)>0:
                    listQ[N][res[0]]="Q"
                    #print(listQ)
                    _listQ = copy.deepcopy(listQ)
                    #print(_listQ)
                    ans.append(_listQ)
                    listQ[N][res[0]]="."
                    #print(_listQ)
                    res.pop(0)
            else:
                if N>0:
                    res = check(N)
                else:
                    res = [_ for _ in range(n)]
                while len(res)>0:
                    listQ[N][res[0]]="Q"
                    backTrack(N+1)
                    listQ[N][res[0]]="."
                    res.pop(0)
        backTrack(0)
        return ans
            

 

标准题解

 思路一：递归算法

先上代码：

    public List<List<String>> 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] = '.';
        List<List<String>> res = new ArrayList<>();
        solve(res, chess, 0);
        return res;
    }

    private void solve(List<List<String>> res, char[][] chess, int row) {
        //终止条件，最后一行都走完了，说明找到了一组，把它加入到集合res中
        if (row == chess.length) {
            res.add(construct(chess));
            return;
        }
        //遍历每一行
        for (int col = 0; col < chess.length; col++) {
            //判断这个位置是否可以放皇后
            if (valid(chess, row, col)) {
                //数组复制一份
                char[][] temp = copy(chess);
                //在当前位置放个皇后
                temp[row][col] = 'Q';
                //递归到下一行继续
                solve(res, temp, row + 1);
            }
        }
    }

    //把二维数组chess中的数据测下copy一份
    private char[][] copy(char[][] chess) {
        char[][] temp = new char[chess.length][chess[0].length];
        for (int i = 0; i < chess.length; i++) {
            for (int j = 0; j < chess[0].length; j++) {
                temp[i][j] = chess[i][j];
            }
        }
        return temp;
    }

    //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;
    }

    //把数组转为list
    private List<String> construct(char[][] chess) {
        List<String> path = new ArrayList<>();
        for (int i = 0; i < chess.length; i++) {
            path.add(new String(chess[i]));
        }
        return path;
    }

//作者：sdwwld
//链接：https://leetcode-cn.com/problems/eight-queens-lcci/solution/nhuang-hou-jing-dian-hui-su-suan-fa-tu-wen-xiang-2/
//来源：力扣（LeetCode）
//著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

代码的注释非常清楚，因此就不再做更多解释了，代码很长，并且在不断复制数据，复制一次就需要一个二维遍历，所以代码性能必然会很差，不过这也确实是一个可以AC的方法。

思路二：回溯算法

先上代码：

    public List<List<String>> 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] = '.';
        List<List<String>> res = new ArrayList<>();
        solve(res, chess, 0);
        return res;
    }

    private void solve(List<List<String>> res, char[][] chess, int row) {
        if (row == chess.length) {
            res.add(construct(chess));
            return;
        }
        for (int col = 0; col < chess.length; col++) {
            if (valid(chess, row, col)) {
                chess[row][col] = 'Q';
                solve(res, 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;
    }

    //把数组转为list
    private List<String> construct(char[][] chess) {
        List<String> path = new ArrayList<>();
        for (int i = 0; i < chess.length; i++) {
            path.add(new String(chess[i]));
        }
        return path;
    }

//作者：sdwwld
//链接：https://leetcode-cn.com/problems/eight-queens-lcci/solution/nhuang-hou-jing-dian-hui-su-suan-fa-tu-wen-xiang-2/
//来源：力扣（LeetCode）
//著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

代码结构与我自己写的几乎一摸一样可是我们之间的运行差距真的很大（抓狂，我的都垫底了）

这是大佬的运行结果：

 

 

 这是我的运行结果：

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

    private void solve(List<List<String>> res, char[][] chess, int row) {
        if (row == chess.length) {
            res.add(construct(chess));
            return;
        }
        for (int col = 0; col < chess.length; col++) {
            if (valid(chess, row, col)) {
                chess[row][col] = 'Q';
                solve(res, chess, row + 1);
                chess[row][col] = '.';
            }
        }
    }

 

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

不过鉴于我用相同的思路跑出了这么差的成绩，于是我决定尝试一下新的思路。

于是我找到了一个运行几乎双百的java代码：

class Solution {
       public List<List<String>> solveNQueens(int n) {
        List<List<String>> ans = new ArrayList<>();
        char[][] nums = new char[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(nums[i], '.');
        }
        backtrack(nums,0, ans);
        return ans;
    }

    private void backtrack(char[][] nums, int currRow, List<List<String>> ans) {
        int len = nums.length;
        if (len == currRow) {
            List<String> path2 = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                path2.add(String.valueOf(nums[i]));
            }
            ans.add(path2);
            return;
        }

        for (int col = 0; col < len; col++) {
            //判断这个位置是否合适
            boolean isok = true;
            for (int row = 0; row < currRow; row++) {
                //竖的有Q
                if (nums[row][col] == 'Q') {
                    isok = false;
                    break;
                }
                //判断对角线
                if (col + (currRow - row) < len && nums[row][col + (currRow - row)] == 'Q') {
                    isok = false;
                    break;
                }
                if (col - (currRow - row) >= 0 && nums[row][col - (currRow - row)] == 'Q') {
                    isok = false;
                    break;
                }
            }
            if (!isok) {
                continue;
            }
            //满足条件
            nums[currRow][col] = 'Q';
            backtrack(nums, currRow + 1, ans);
            nums[currRow][col] = '.';
        }
    }
}

//作者：ckhero
//链接：https://leetcode-cn.com/problems/eight-queens-lcci/solution/jie-jin-shuang-bai-by-ckhero/
//来源：力扣（LeetCode）
//著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

这个几乎双百的java代码并没有更新奇的思路，他只是将check函数写进了主体处理函数中，这样省去了函数中调用其他函数的开销，提高了一些处理速度，但我个人认为这样也不是很可取，这回降低代码的可读性（读起来缺少了一些模块化的感觉，本质上对理解代码本身影响不大。）

思路差距

 八皇后实在太经典了，它的解题思路已经相当家喻户晓了，所以思路这里也没什么差距，就是代码实现不同人会有不同的写法。另外，复制数据结构的操作也不是完全不可取，或许有些问题非这种办法不可，至少我在这个问题上没有先想到这个方法，先记下来。

技术差距

从这期开始，技术差距将会专门讨论一些如何提高代码性能的问题，我们的目标不能仅仅停留在全AC上，缩短运行时间也是应该考虑的一个重要目标。

1、用一个数据结构将递归运算中的运行结果存储起来可以起到节省运算资源的效果，有时候甚至必须要这么做，因为这样可以实现回溯的作用。而单纯的进行存储效率会不如在原数据上进行改写的效果好。

2、函数中调用函数会降低代码的性能，但有时候我们不得不这么做，像某些递归运算，不得不在函数中调用函数。