用python实现N皇后问题

一、N皇后I

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

上图为 8 皇后问题的一种解法。

给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。

每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

示例:

输入: 4

输出: [

[".Q…", // 解法 1

“…Q”,

“Q…”,

“…Q.”],

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

“Q…”,

“…Q”,

“.Q…”]

]

解释: 4 皇后问题存在两个不同的解法。

算法设计：

• 在n元组x[1:n]表示n后问题的解。其中，x[i]表示皇后i放在棋盘的第i行的第x[i]列。由于不允许将2个皇后放在同一列上，所有解向量中的x[i]互不相同。2个皇后不能放在同一斜线上是问题的隐约束。对于一般的n后问题，这一隐约束条件可以化成显约束的形式。如果将nn格的棋盘看做二维方阵，其行号从上到下，列号从左至右一次编号1,2，……，n，从棋盘左上角到右下角的主对角线及其平行线（即斜率为-1的各斜线）上，2个下标值的差（行号-列号）值相等。同理，斜率为+1的每一条斜线上，2个下标值的和（行号+列号）值相等……

回溯算法：

• 记录行,列, 正对角,负对角,不能有两个以上的棋子.
  如何判断是否在对角上呢?
  正对角就是相加之和一样的
  负对角就是相减只差一样的

72 ms

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        res = []
        s = "." * n
        def backtrack(i, tmp,col,z_diagonal,f_diagonal):
            if i == n:
                res.append(tmp)
                return 
            for j in range(n):
                if j not in col and i + j not in  z_diagonal and i - j not in f_diagonal:
                    backtrack(i+1,tmp + [s[:j] + "Q" + s[j+1:]], col | {j}, z_diagonal |{i + j} , f_diagonal |{i - j}  ) 
            
        backtrack(0,[],set(),set(),set())    
        return res

64 ms

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        def traceBack(r):
            #得到一个合理结果
            if r >= n:
                temp = []
                for i in matrix:
                    temp.append(''.join(i))
                result.append(temp)
                return
            #只需对此行的各列进行分析
            for i in range(n):
                if col[i] and hill_dig[r + i] and dale_dig[r - i + n - 1]:
                    matrix[r][i] = 'Q'
                    #束缚条件
                    col[i] = False
                    hill_dig[r+i] = False
                    dale_dig[r-i+n-1] = False
                    #对下一行进行分析
                    traceBack(r + 1)
                    #回退，束缚条件重置
                    matrix[r][i] = '.'
                    col[i] = True
                    hill_dig[r + i] = True
                    dale_dig[r - i + n - 1] = True
            return

        result = []
        matrix = [['.' for i in range(n)] for i in range(n)]
        col = [True for i in range(n)]
        dale_dig = [True for i in range(2 * n - 1)] #主对角线 row-col常数
        hill_dig = [True for i in range(2 * n - 1)] #从对角线，row+col常数
        traceBack(0)
        return result

60 ms

class Solution(object):
    def solveNQueens(self, n):
        def DFS(queens, xy_dif, xy_sum):
            p = len(queens)
            if p == n:
                result.append(queens)
                return None
            for q in range(n):
                if q not in queens and p-q not in xy_dif and p+q not in xy_sum:
                    DFS(queens+[q], xy_dif+[p-q], xy_sum+[p+q])
        
        result = []
        DFS([], [], [])
        return [ ["."*i + "Q" + "."*(n-i-1) for i in sol] for sol in result ]

二、N皇后 II

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

上图为 8 皇后问题的一种解法。

给定一个整数 n，返回 n 皇后不同的解决方案的数量。

示例:

输入: 4

输出: 2

解释: 4 皇后问题存在如下两个不同的解法。

[

[".Q…", // 解法 1

“…Q”,

“Q…”,

“…Q.”],

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

“Q…”,

“…Q”,

“.Q…”]

]

算法设计：

• 在n元组x[1:n]表示n后问题的解。其中，x[i]表示皇后i放在棋盘的第i行的第x[i]列。由于不允许将2个皇后放在同一列上，所有解向量中的x[i]互不相同。2个皇后不能放在同一斜线上是问题的隐约束。对于一般的n后问题，这一隐约束条件可以化成显约束的形式。如果将nn格的棋盘看做二维方阵，其行号从上到下，列号从左至右一次编号1,2，……，n，从棋盘左上角到右下角的主对角线及其平行线（即斜率为-1的各斜线）上，2个下标值的差（行号-列号）值相等。同理，斜率为+1的每一条斜线上，2个下标值的和（行号+列号）值相等……

回溯算法

• 记录 行, 列, 正对角,负对角,不能有两个以上的棋子.
  如何判断是否在对角上呢?
  正对角就是相加之和一样的
  负对角就是相减只差一样的

56 ms

class Solution:
    def totalNQueens(self, n: int) -> int:
        self.res = 0
        def backtrack(i,col,z_diagonal,f_diagonal):
            if i == n:return  True
            for j in range(n):
                if j not in col and i + j not in  z_diagonal and i - j not in f_diagonal:
                    if backtrack(i+1, col | {j}, z_diagonal |{i + j} , f_diagonal |{i - j}  ) :
                        self.res += 1
            return False
        backtrack(0,set(),set(),set())    
        return self.res

52 ms

class Solution:
    def totalNQueens(self, n: int) -> int:
        def DFS(n: int, row: int, cols: int, left: int, right: int):
            """ 深度优先搜索
            :param n: N皇后个数
            :param row: 递归的深度
            :param cols: 可被攻击的列
            :param left: 左侧斜线上可被攻击的列
            :param right: 右侧斜线上可被攻击的列
            """
            if row >= n:
                self.res += 1
                return

            # 获取当前可用的空间
            bits = (~(cols | left | right)) & ((1 << n) - 1)

            # 遍历可用空间
            while bits:
                # 获取一个位置
                p = bits & -bits
                DFS(n, row + 1, cols | p, (left | p) << 1, (right | p) >> 1)
                bits = bits & (bits - 1)

        if not (n == 1 or n >= 4):
            # N皇后问题只有在 N 大于等于 4 或等于 1 的时候才有解
            return 0
        self.res = 0
        DFS(n, 0, 0, 0, 0)
        return self.res

使用 bitmap 回溯

44 ms

class Solution:
    def totalNQueens(self, n):
        """
        :type n: int
        :rtype: int
        """
        def backtrack(row = 0, hills = 0, next_row = 0, dales = 0, count = 0):
            """
            :type row: 当前放置皇后的行号
            :type hills: 主对角线占据情况 [1 = 被占据，0 = 未被占据]
            :type next_row: 下一行被占据的情况 [1 = 被占据，0 = 未被占据]
            :type dales: 次对角线占据情况 [1 = 被占据，0 = 未被占据]
            :rtype: 所有可行解的个数
            """
            if row == n:  # 如果已经放置了 n 个皇后
                count += 1  # 累加可行解
            else:
                # 当前行可用的列
                # ! 表示 0 和 1 的含义对于变量 hills, next_row and dales的含义是相反的
                # [1 = 未被占据，0 = 被占据]
                free_columns = columns & ~(hills | next_row | dales)
                
                # 找到可以放置下一个皇后的列
                while free_columns:
                    # free_columns 的第一个为 '1' 的位
                    # 在该列我们放置当前皇后
                    curr_column = - free_columns & free_columns
                    
                    # 放置皇后
                    # 并且排除对应的列
                    free_columns ^= curr_column
                    
                    count = backtrack(row + 1, 
                                      (hills | curr_column) << 1, 
                                      next_row | curr_column, 
                                      (dales | curr_column) >> 1, 
                                      count)
            return count

        # 棋盘所有的列都可放置，
        # 即，按位表示为 n 个 '1'
        # bin(cols) = 0b1111 (n = 4), bin(cols) = 0b111 (n = 3)
        # [1 = 可放置]
        columns = (1 << n) - 1
        return backtrack()