LeetCode回溯算法精讲：从模板到高频题解析

1. LeetCode Hot 100回溯篇：算法工程师的必修课

刷LeetCode是每个程序员进阶的必经之路，而回溯算法更是面试中的高频考点。最近在准备跳槽时，我系统梳理了LeetCode Hot 100中的回溯题目，发现这类题型虽然套路明显，但想要快速AC（Accepted）还是需要掌握一些技巧。回溯算法本质上就是一种暴力搜索的优化，通过"试错"的思想解决问题，当发现当前路径无法得到解时，就回退到上一步重新选择。

回溯法特别适合解决组合、排列、子集、棋盘类问题，比如经典的N皇后、全排列、组合总和等题目。这类问题通常需要遍历所有可能的解空间，而回溯算法通过递归和剪枝来高效地完成这一过程。我在刷题过程中发现，掌握回溯模板和常见优化方法，能解决80%以上的相关问题。

2. 回溯算法核心框架解析

2.1 回溯算法的通用模板

回溯算法有一个非常清晰的递归结构，经过大量练习后，我总结出了以下通用模板：

python复制def backtrack(路径, 选择列表):
    if 满足结束条件:
        结果.append(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

这个模板适用于绝大多数回溯问题。以LeetCode 46（全排列）为例：

python复制def permute(nums):
    res = []
    def backtrack(path, nums):
        if not nums:
            res.append(path)
            return
        for i in range(len(nums)):
            backtrack(path+[nums[i]], nums[:i]+nums[i+1:])
    backtrack([], nums)
    return res

提示：在写回溯代码时，一定要注意"做选择"和"撤销选择"的对称性，这是回溯算法的核心思想。

2.2 回溯与DFS的区别

很多初学者容易混淆回溯和DFS（深度优先搜索）。实际上，回溯是DFS的一种特殊形式，区别在于：

1. DFS主要用于遍历图或树结构，目的是访问所有节点
2. 回溯主要用于解决决策问题，目的是找到所有满足条件的解
3. 回溯在递归返回时会"撤销选择"，而DFS通常不需要

2.3 回溯算法的时间复杂度分析

回溯算法的时间复杂度通常是解空间的大小。以全排列问题为例，n个数的全排列有n!种可能，因此时间复杂度为O(n!)。在实际分析时，我们需要考虑：

1. 递归树的深度（通常等于选择列表的大小）
2. 每个节点的分支数
3. 剪枝操作减少的计算量

3. LeetCode Hot 100回溯题精讲

3.1 组合类问题

组合总和（LeetCode 39）是这类问题的典型代表。题目要求找出所有和为target的组合，同一个数可以重复使用。我的解题思路：

1. 排序数组便于剪枝
2. 递归时记录当前组合和起始索引
3. 当剩余值小于0时剪枝

python复制def combinationSum(candidates, target):
    res = []
    candidates.sort()
    
    def backtrack(start, path, target):
        if target == 0:
            res.append(path)
            return
        for i in range(start, len(candidates)):
            if candidates[i] > target: break
            backtrack(i, path+[candidates[i]], target-candidates[i])
    
    backtrack(0, [], target)
    return res

注意：组合问题通常需要start参数避免重复，而排列问题则不需要。

3.2 排列类问题

全排列II（LeetCode 47）在基础全排列上增加了去重要求。关键点在于：

1. 排序后便于跳过重复元素
2. 使用visited数组标记已使用的元素
3. 跳过与前一个相同且未使用的元素

python复制def permuteUnique(nums):
    res = []
    nums.sort()
    visited = [False]*len(nums)
    
    def backtrack(path):
        if len(path) == len(nums):
            res.append(path)
            return
        for i in range(len(nums)):
            if visited[i] or (i>0 and nums[i]==nums[i-1] and not visited[i-1]):
                continue
            visited[i] = True
            backtrack(path+[nums[i]])
            visited[i] = False
    
    backtrack([])
    return res

3.3 子集类问题

子集（LeetCode 78）要求找出所有可能的子集。这类问题的特点是：

1. 每个元素都有选或不选两种选择
2. 不需要满足特定条件，所有路径都是解
3. 可以通过位运算优化

我的解法：

python复制def subsets(nums):
    res = []
    
    def backtrack(start, path):
        res.append(path)
        for i in range(start, len(nums)):
            backtrack(i+1, path+[nums[i]])
    
    backtrack(0, [])
    return res

3.4 棋盘类问题

N皇后（LeetCode 51）是经典的回溯问题，难点在于：

1. 如何高效判断位置是否合法
2. 如何优雅地表示棋盘
3. 如何剪枝优化

我的解决方案：

python复制def solveNQueens(n):
    res = []
    
    def backtrack(queens, xy_diff, xy_sum):
        p = len(queens)
        if p == n:
            res.append(queens)
            return
        for q in range(n):
            if q not in queens and p-q not in xy_diff and p+q not in xy_sum:
                backtrack(queens+[q], xy_diff+[p-q], xy_sum+[p+q])
    
    backtrack([], [], [])
    return [["."*i + "Q" + "."*(n-i-1) for i in sol] for sol in res]

4. 回溯算法优化技巧

4.1 剪枝策略

剪枝是回溯算法优化的核心。常见剪枝方法包括：

1. 排序后提前终止循环（如组合总和）
2. 跳过重复元素（如全排列II）
3. 利用数学性质减少计算（如N皇后）
4. 记忆化搜索避免重复计算

4.2 位运算优化

当问题涉及状态压缩时，位运算可以大幅提高效率。例如子集问题：

python复制def subsets(nums):
    res = []
    n = len(nums)
    for i in range(1<<n):
        res.append([nums[j] for j in range(n) if (i & (1<<j))])
    return res

4.3 迭代实现

有些回溯问题可以用迭代替代递归，避免栈溢出风险。例如全排列的迭代实现：

python复制def permute(nums):
    stack = [(nums, [])]
    res = []
    while stack:
        nums, path = stack.pop()
        if not nums:
            res.append(path)
        for i in range(len(nums)):
            stack.append((nums[:i]+nums[i+1:], path+[nums[i]]))
    return res

5. 常见错误与调试技巧

5.1 无限递归问题

回溯算法最常见的错误是无限递归，通常由以下原因导致：

1. 忘记设置终止条件
2. 终止条件设置不当
3. 选择列表没有正确更新

调试方法：

1. 打印递归深度和当前路径
2. 检查终止条件是否会被触发
3. 验证选择列表是否随递归更新

5.2 结果重复问题

当结果中出现重复解时，通常是因为：

1. 没有对输入数组排序（当需要去重时）
2. 跳过重复元素的逻辑错误
3. 选择列表的范围控制不当

解决方法：

1. 先排序输入数组
2. 添加跳过重复元素的判断
3. 仔细检查选择列表的起始索引

5.3 性能优化技巧

当回溯算法超时时，可以考虑：

1. 尽早剪枝：在递归开始前检查是否可以提前返回
2. 使用更高效的数据结构：如用集合替代列表查找
3. 减少拷贝操作：尽量在原地修改状态
4. 转换为迭代实现：减少函数调用开销

6. LeetCode Hot 100回溯题目清单

根据我的刷题经验，以下是必刷的回溯题目：

1. 组合总和系列（39, 40, 216）
2. 全排列系列（46, 47）
3. 子集系列（78, 90）
4. 分割回文串（131）
5. 复原IP地址（93）
6. N皇后（51）
7. 单词搜索（79）
8. 括号生成（22）
9. 解数独（37）
10. 二进制手表（401）

对于每道题目，建议：

1. 先自己尝试实现基础解法
2. 然后思考如何优化剪枝
3. 最后比较与最优解的差距
4. 记录每种解法的时间和空间复杂度

7. 回溯算法在面试中的应用

在技术面试中，回溯问题通常考察：

1. 对算法思想的理解深度
2. 代码实现能力
3. 问题分析能力
4. 优化思维

应对策略：

1. 先明确问题属于哪种回溯类型（组合、排列、子集等）
2. 画出递归树帮助理解
3. 讨论最坏情况下的复杂度
4. 提出优化思路，即使没时间实现

我在面试中遇到过一道变形的组合总和问题，面试官要求找出所有和为target的组合，但每个数字只能使用一次，且组合长度必须为k。通过套用回溯模板并添加适当条件，顺利解决了这个问题。

8. 我的刷题心得

经过几个月的集中刷题，我总结出以下经验：

1. 理解比记忆更重要：掌握回溯思想比死记硬背代码更有价值
2. 从简单题开始：先熟悉模板，再挑战难题
3. 分类练习：按问题类型集中刷题，容易发现规律
4. 反复练习：隔段时间重做之前的问题，检验是否真正掌握
5. 参加周赛：LeetCode周赛（如周赛430）是很好的实战机会

对于"爱吃香蕉的狒狒"（LeetCode 875）这类看似不像回溯的问题，也要保持开放思维，有时候回溯可能是解决方案之一。