【leetcode】回溯刷题总结

回溯法

有递归就有回溯，递归与回溯相辅相成。

回溯搜索法是纯暴力搜索算法。

一般的回溯问题都可以抽象为树结构，树的深度为递归次数，树的宽度为候选集合大小。

需要回溯解决的问题（用暴力循环很难解决）：

• 组合问题（一般在叶子节点收集结果）
• 切割问题（一般在叶子节点收集结果）
• 子集问题（一般在每个节点收集结果）
• 排列问题（一般在叶子节点收集结果）
• 棋盘问题，如N皇后、解数独

回溯法模板

def backTracking(parameter):
    if 终止条件:
        收集结果
        return
    for循环 集合元素:
        处理节点
        递归函数
        回溯操作，撤销处理节点情况
    return

以leetcode77题 组合 为例：

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        self.res = []
        self.backTracking(n, k, 1, [])
        return self.res

    def backTracking(self, n, k, start, path):
        # 终止条件
        if len(path) == k:
            # 收集结果
            self.res.append(path)
            return
        # 剪枝优化
        end = n - (k - len(path)) + 2
        # for循环集合元素
        for i in range(start, end):
            # 包含回溯的递归
            self.backTracking(n, k, i + 1, path + [i])

需要去重的组合问题-LeetCode40题 组合总和II

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        self.res = []
        candidates.sort()
        self.backTracking(candidates, target, 0, [], 0)
        return self.res

    def backTracking(self, candidates, target, start, path, cur_sum):
        if cur_sum == target:
            self.res.append(path)
            return
        for i in range(start, len(candidates)):
            # 剪枝优化
            if cur_sum + candidates[i] > target:
                break
            # 对同一树层使用过的元素进行跳过
            if i > start and candidates[i] == candidates[i - 1]:
                continue
            self.backTracking(candidates, target, i + 1, path + [candidates[i]], cur_sum + candidates[i])

字符串切割问题-LeetCode131题 分割回文串

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        self.res = []
        # 动态规划预先计算字符串回文结果
        self.isPalindrome = [[False] * len(s) for _ in range(len(s))]
        self.computePalindrome(s)
        # 回溯法进行字符串切割
        self.backTracking(s, 0, [])
        return self.res
    
    def backTracking(self, s, start, path):
        # 每次递归都是一次切割操作，start代表本次切割的起始位置
        if start == len(s):
            self.res.append(path)
        for i in range(start, len(s)):
            if not self.isPalindrome[start][i]:
                continue
            self.backTracking(s, i + 1, path + [s[start: i + 1]])
    
    def computePalindrome(self, s):
        # 动态规划预先计算s[i, j + 1]是否回文
        # 需要倒序计算，保证在i行时，i+1行已经计算好了
        for i in range(len(s) - 1, -1, -1):
            for j in range(i, len(s)):
                if j == i:
                    self.isPalindrome[i][j] = True
                elif j - i == 1:
                    self.isPalindrome[i][j] = (s[i] == s[j])
                else:
                    self.isPalindrome[i][j] = (s[i] == s[j] and self.isPalindrome[i+1][j-1])

特殊的排列问题-LeetCode51题 N皇后

由于N皇后要求每行、每列不能有重叠，所以N皇后就变成了对数字1-n进行排列的问题，限制条件是棋盘对角线元素不能重叠

class Solution:
    def solveNQueens(self, n: int) -> List[List[str]]:
        self.res = []
        self.backTracking(n, [i for i in range(n)], [])
        return self.res

    def backTracking(self, n, tobe, path):
        # tobe是待选择的每一行的列索引
        # path是已选择的每一行的列索引
        if not tobe:
            # 收集结果
            tmp = []
            for i in path:
                tmp.append('.' * i + 'Q' + '.' * (n - i - 1))
            self.res.append(tmp)
            return
        for i in range(len(tobe)):
            # 当前要选择的坐标
            tmp_x, tmp_y = len(path), tobe[i]
            # 判断是否和已选择的坐标对角线重复
            flag = True
            for x, y in enumerate(path):
                if tmp_x - x == abs(tmp_y - y):
                    flag = False
                    break
            if flag:
                self.backTracking(n, tobe[:i] + tobe[i + 1:], path + [tobe[i]])

二维递归问题-LeetCode37题 解数独

带返回值的递归函数，找到第一个解法时直接返回

class Solution:
    def solveSudoku(self, board: List[List[str]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        self.backTracking(board, 0, 0)

    def backTracking(self, board, x, y):
        # x代表待搜索的横坐标，y代表待搜索的纵坐标
        if x > 8:
            return True
        if board[x][y] == '.':
            for k in range(1, 10):
                if self.isValid(board, x, y, k):
                    board[x][y] = str(k)
                    if y == 8:
                        if self.backTracking(board, x + 1, 0):
                            return True
                    else:
                        if self.backTracking(board, x, y + 1):
                            return True
                    board[x][y] = '.'
        else:
            if y == 8:
                if self.backTracking(board, x + 1, 0):
                    return True
            else:
                if self.backTracking(board, x, y + 1):
                    return True

    def isValid(self, board, x, y, value):
        for i in range(9):
            if board[i][y] == str(value) or board[x][i] == str(value):
                return False
        for i in range(3):
            for j in range(3):
                if board[i + x // 3 * 3][j + y // 3 * 3] == str(value):
                    return False
        return True

LeetCode698题 划分为k个相等的子集

以数字视角选择桶，复杂度k^n，会超时

以桶视角选择数字，复杂度k*2^n，即先为每个桶选择若干数字，若选择成功继续为下一个桶选择，直到每个桶都选择完毕。同时还可以将已经失败的used数组状态记录下来，进行剪枝

class Solution:
    def canPartitionKSubsets(self, nums: List[int], k: int) -> bool:
        sum_ = sum(nums)
        if sum_ % k != 0:
            return False
        target = sum_ // k
        self.res = False
        used = ['0'] * len(nums)
        self.fail_used = set()
        self.backTracking(k, nums, 0, used, target, 0)
        return self.res

    def backTracking(self, k, nums, start, used, target, cur_sum):
        if k == 0:
            self.res = True
            return
        if cur_sum == target:
            self.backTracking(k - 1, nums, 0, used, target, 0)
        for i in range(start, len(nums)):
            if used[i] == '1' or (cur_sum + nums[i] > target) or ''.join(used) in self.fail_used:
                continue
            used[i] = '1'
            self.backTracking(k, nums, i + 1, used, target, cur_sum + nums[i])
            if self.res:
                return
            self.fail_used.add(''.join(used))
            used[i] = '0'