Leetcode-剪枝

51. N皇后 https://leetcode-cn.com/problems/n-queens/

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

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

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

解：

dfs + 剪枝，枚举每个行。注意在做回溯之前，要把当前放置的皇后拿掉，把其造成影响的标识位都消除。

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        def could_place(row, col):
            # row这一行是没有放置过的行，要检查col这一列、(row,col)所占两条对角线有没有被放置过，如果都没有，(row,col)可以放皇后
            return not (cols[col]+hill_diagonals[row-col]+\
                        dale_diagonals[row+col]) 
        
        def place_queen(row, col):
            queens.add((row, col))  # 放皇后，记录位置，标记列和两对角线
            cols[col] = 1
            hill_diagonals[row-col] = 1
            dale_diagonals[row+col] = 1
        
        def remove_queen(row, col):
            queens.remove((row, col))  # 移除皇后，清空列和两对角线的标记
            cols[col] = 0
            hill_diagonals[row-col] = 0
            dale_diagonals[row+col] = 0
        
        def add_solution():
            # 如果找到一个解，按要求记录下来
            solution = []
            for _, col in sorted(queens):
                solution.append('.'*col + 'Q' + '.'*(n-col-1))
            output.append(solution)
        
        def dfs(row):
            # 从第一行row=0开始放置皇后，放到n-1行
            for col in range(n):  # 对于确定的row，遍历所有列col
                if could_place(row, col):
                    place_queen(row, col)  # 如果(row, col)可以放皇后，就放
                    if row == n-1:  # 如果已经放了最后一个，说明找到一个解
                        add_solution()
                    else:  # 没有放到最后一个的话
                        dfs(row+1)  # 去找row行之后所有可能的放置解法
                    remove_queen(row, col)  # 不管是哪种情况都要回溯，移除当前皇后，进入(row, col+1) 的情况
            
        cols = [0] * n
        hill_diagonals = [0] * (2 * n -1)
        dale_diagonals = [0] * (2 * n -1)
        queens = set()
        output = []
        
        dfs(0)
        return output

　　

52. N皇后ii https://leetcode-cn.com/problems/n-queens-ii/

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

解：

跟#51基本相同，修改一下最后返回值的处理即可

class Solution:
    def totalNQueens(self, n: int) -> int:
        def could_place(row, col):
            # row这一行是没有放置过的行，要检查col这一列、(row,col)所占两条对角线有没有被放置过，如果都没有，(row,col)可以放皇后
            return not (cols[col]+hill_diagonals[row-col]+\
                        dale_diagonals[row+col]) 
        
        def place_queen(row, col):
            queens.add((row, col))  # 放皇后，记录位置，标记列和两对角线
            cols[col] = 1
            hill_diagonals[row-col] = 1
            dale_diagonals[row+col] = 1
        
        def remove_queen(row, col):
            queens.remove((row, col))  # 移除皇后，清空列和两对角线的标记
            cols[col] = 0
            hill_diagonals[row-col] = 0
            dale_diagonals[row+col] = 0
        
        def dfs(row):
            nonlocal res
            for col in range(n):
                if could_place(row, col):
                    place_queen(row, col)
                    if row == n-1:
                        res += 1
                    else:
                        dfs(row+1)
                    remove_queen(row, col)  # 把刚才放置的拿掉才能回溯
                    
        cols = [0] * n
        hill_diagonals = [0] * (2 * n - 1)
        dale_diagonals = [0] * (2 * n - 1)
        queens = set()
        res = 0
        dfs(0)
        return res

　　

36. 有效的数独 https://leetcode-cn.com/problems/valid-sudoku/

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

数独部分空格内已填入了数字，空白格用 '.' 表示。

 说明:

一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
给定数独序列只包含数字 1-9 和字符 '.' 。
给定数独永远是 9x9 形式的。

解：

两层嵌套循环遍历即可，分别对行、列、子数独用 n=9 个哈希表（其中key为1～9）来存所有已经遇到过的值，如果某个key的value大于1的话说明数独无效。

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        # 9行，9列，9个子数独
        rows = [{} for _ in range(9)]  # 每个哈希表存，列表下标对应行的，已填数字情况 
        cols = [{} for _ in range(9)]
        boxes = [{} for _ in range(9)]  # 子数独编号为boxes的下标，从上到下从左到右索引
        
        for i in range(9):
            for j in range(9):
                num = board[i][j]
                if num != '.':     # 如果某个位置已经填入数
                    num = int(num)
                    box_idx = (i//3)*3 + j//3   # 当前位置所处的子数独索引
                    
                    rows[i][num] = rows[i].get(num, 0) + 1  # 先保留当前的数，在哈希表中保存
                    cols[j][num] = cols[j].get(num, 0) + 1
                    boxes[box_idx][num] = boxes[box_idx].get(num, 0) + 1
                    
                    # 检查如果保留当前数的话，是否合法
                    if rows[i][num] > 1 or cols[j][num] > 1 or boxes[box_idx][num] > 1:
                        return False
        return True

 

37. 解数独 https://leetcode-cn.com/problems/sudoku-solver/

编写一个程序，通过已填充的空格来解决数独问题。

解：

dfs, 枚举每个空格。

from collections import defaultdict
class Solution:
    def solveSudoku(self, board: List[List[str]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        def could_place(d, row, col):
            """
            Check if one could place a number d in (row, col) cell
            """
            return not (d in rows[row] or d in columns[col] or \
                    d in boxes[box_index(row, col)])
        
        def place_number(d, row, col):
            """
            Place a number d in (row, col) cell
            """
            rows[row][d] += 1
            columns[col][d] += 1
            boxes[box_index(row, col)][d] += 1
            board[row][col] = str(d)
            
        def remove_number(d, row, col):
            """
            Remove a number which didn't lead 
            to a solution
            """
            del rows[row][d]
            del columns[col][d]
            del boxes[box_index(row, col)][d]
            board[row][col] = '.'    
            
        def place_next_numbers(row, col):
            """
            Call backtrack function in recursion
            to continue to place numbers
            till the moment we have a solution
            """
            # if we're in the last cell
            # that means we have the solution
            if col == N - 1 and row == N - 1:
                nonlocal sudoku_solved
                sudoku_solved = True
            #if not yet    
            else:
                # if we're in the end of the row
                # go to the next row
                if col == N - 1:
                    backtrack(row + 1, 0)
                # go to the next column
                else:
                    backtrack(row, col + 1)
                
                
        def backtrack(row = 0, col = 0):
            """
            Backtracking
            """
            # if the cell is empty
            if board[row][col] == '.':
                # iterate over all numbers from 1 to 9
                for d in range(1, 10):
                    if could_place(d, row, col):
                        place_number(d, row, col)
                        place_next_numbers(row, col)
                        # if sudoku is solved, there is no need to backtrack
                        # since the single unique solution is promised
                        if not sudoku_solved:
                            remove_number(d, row, col)
            else:
                place_next_numbers(row, col)
                    
        # box size
        n = 3
        # row size
        N = n * n
        # lambda function to compute box index
        box_index = lambda row, col: (row // n ) * n + col // n
        
        # init rows, columns and boxes
        rows = [defaultdict(int) for i in range(N)]
        columns = [defaultdict(int) for i in range(N)]
        boxes = [defaultdict(int) for i in range(N)]
        for i in range(N):
            for j in range(N):
                if board[i][j] != '.': 
                    d = int(board[i][j])
                    place_number(d, i, j)
        
        sudoku_solved = False
        backtrack()

　　

除了普通的dfs，还可以加一些剪枝的条件来加速。先枚举可选项少的空格：预处理，先遍历一边格子，找出每个空格的可选数，并排序，dfs搜索时就从可选数最少的空格开始。