回溯算法-Python

回溯算法

回溯算法是一种系统的搜索算法，用于解决诸如排列组合、子集生成、图的路径、棋盘问题等问题。其核心思想是通过递归尝试各种可能的解决方案，遇到不满足条件的解时则回退（回溯），继续尝试其他可能性，直到找到所有的解决方案或确认无解。

主要步骤:

选择路径: 在当前步骤选择一个可能的路径。
递归探索: 对当前选择的路径进行递归探索，继续尝试后续步骤。
约束检查: 检查当前选择是否满足问题的约束条件。如果不满足，则回溯。
回溯；如果当前路径无法导致有效解，则回退到上一步，尝试其他可能的路径。

# 回溯算法框架
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

1.没有重复数字的全排列

leetcode类似问题: 46. 全排列

给出一组数字，返回该组数字的所有排列
例如：[1,2,3]的所有排列如下
[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2], [3,2,1]

class Solution:
    def __init__(self):
        self.res = []

    def backtrack(self, nums, path, used):
        # 满足结束条件
        if len(path) == len(nums):
            self.res.append(path.copy())
            return
        for i in range(len(nums)):
            # 剔除已选择的元素
            if used[i]:
                continue
            # 做选择
            path.append(nums[i])
            used[i] = True
            self.backtrack(nums, path, used)
            # 撤销选择
            path.pop()
            used[i] = False

    def permute(self, nums):
        # 记录路径
        path = []
        # 标记选择是否被使用
        used = [False] * len(nums)
        self.backtrack(nums, path, used)
        return self.res

另一种写法

class Solution:
    def permute(self, nums):
        result = []

        def backtrack(start):
            # 当 start 等于 nums 的长度时，表示当前排列完成
            if start == len(nums):
                # 将当前排列加入结果列表
                result.append(nums[:])
                return
            for i in range(start, len(nums)):
                # 交换当前元素与 start 位置的元素
                nums[start], nums[i] = nums[i], nums[start]
                # 递归生成排列
                backtrack(start + 1)
                # 回溯，恢复数组的状态
                nums[start], nums[i] = nums[i], nums[start]

        backtrack(0)
        return result

2.生成所有子集

leetcode类似问题: 78. 子集

给定一个集合 [1, 2, 3]，我们需要生成这个集合的所有可能的子集。

class Solution:
    def subsets(self, nums):
        res = []
        path = []

        def backtrack(nums, start, res, path):
            # 将当前路径加入结果中
            res.append(path.copy())
            # 从start位置开始，尝试添加更多的元素到路径中
            for i in range(start, len(nums)):
                # 做选择
                path.append(nums[i])
                # 递归调用
                backtrack(nums, i + 1, res, path)
                # 撤销选择(回溯)
                path.pop()

        backtrack(nums, 0, res, path)
        return res

3.数独问题

leetcode类似问题: 37. 解数独

根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。

class Solution:
    def is_valid(self, board, row, col, num):
        for i in range(9):
            # 检查行
            if board[row][i] == num:
                return False
            # 检查列
            if board[i][col] == num:
                return False
        # 检查3x3子网格
        start_row = (row // 3) * 3
        start_col = (col // 3) * 3
        for i in range(start_row, start_row + 3):
            for j in range(start_col, start_col + 3):
                if board[i][j] == num:
                    return False
        return True

    def solveSudoku(self, board):
        for i in range(9):
            for j in range(9):
                if board[i][j] == ".":
                    # 尝试填入数字1-9
                    for n in "123456789":
                        if self.is_valid(board, i, j, n):
                            board[i][j] = n
                            # 递归调用，尝试解决下一个空位置
                            if self.solveSudoku(board):
                                return True
                            # 如果递归调用返回 False，撤销当前填入的 n
                            board[i][j] = "."
                    # 如果所有数字都尝试过还不能解决，返回 False，触发回溯
                    return False
        return True

4.八皇后问题

leetcode类似问题: 51. N 皇后

在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

class Solution:
    def is_valid(self, board, row, col):
        # 检查列是否有皇后
        for i in range(row):
            if board[i][col] == 'Q':
                return False

        # 检查左上对角线是否有皇后
        for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
            if board[i][j] == 'Q':
                return False

        # 检查右上对角线是否有皇后
        for i, j in zip(range(row, -1, -1), range(col, len(board), 1)):
            if board[i][j] == 'Q':
                return False
        return True

    def backtrack(self, board, row, res):
        # 如果所有行都放置了皇后，表示找到一个解决方案
        if row == len(board):
            res.append(board.copy())
            return
        for col in range(len(board)):
            if self.is_valid(board, row, col):
                # 做选择
                board[row] = board[row][:col] + 'Q' + board[row][col + 1:]
                # 进入下一行决策
                self.backtrack(board, row + 1, res)
                # 撤销选择
                board[row] = board[row][:col] + '.' + board[row][col + 1:]

    def solveNQueens(self, n):
        res = []
        # 初始化棋盘
        board = ["." * n for _ in range(n)]
        self.backtrack(board, 0, res)
        return res