全排列与子集实战：DFS 回溯法的通用代码模板与应用

最新推荐文章于 2025-12-16 17:51:46 发布

原创最新推荐文章于 2025-12-16 17:51:46 发布 · 385 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#深度优先 #算法

部署运行你感兴趣的模型镜像

全排列与子集实战：DFS 回溯法的通用代码模板与应用

深度优先搜索（DFS）回溯法是一种高效解决组合问题的算法，特别适用于生成全排列（所有元素的顺序排列）和子集（所有可能的子集）。它通过递归遍历所有可能解，并在无效路径时回溯剪枝，避免重复计算。下面我将逐步介绍通用代码模板，并实战应用于全排列和子集问题，最后讨论其实际应用场景。所有代码均使用Python实现，确保可读性和实用性。

1. DFS 回溯法的通用代码模板

回溯法的核心是递归函数，维护一个“路径”（当前部分解）和一个“选择列表”（剩余可选元素）。模板如下：

def backtrack(路径, 选择列表):
    if 满足结束条件:  # 例如路径长度达到要求
        结果集.append(路径[:])  # 添加路径的副本，避免引用问题
        return
    
    for 选择 in 选择列表:
        if 选择无效:  # 可选剪枝条件，如重复元素跳过
            continue
        路径.append(选择)  # 做选择
        backtrack(路径, 更新后的选择列表)  # 递归调用
        路径.pop()  # 回溯，撤销选择

关键点解释：
- 路径：列表，存储当前部分解（如已选元素）。
- 选择列表：列表，存储剩余可选元素。
- 结束条件：当路径长度达到目标时停止递归（如全排列时路径长度等于数组长度）。
- 剪枝：在循环中添加条件跳过无效选择，提高效率（如子集问题中跳过重复元素）。
- 回溯：通过pop()撤销上一步选择，确保遍历所有分支。
时间复杂度：通常为$O(2^n)$或$O(n!)$，取决于问题规模$n$（数组长度）。空间复杂度$O(n)$，用于递归栈。

此模板可灵活适配多种问题。接下来，实战应用它到全排列和子集生成。

2. 全排列实战：生成所有排列

全排列问题要求生成数组的所有可能顺序排列。例如，输入$[1,2,3]$，输出所有排列如$[1,2,3]$、$[1,3,2]$等。使用上述模板，实现如下：

def permute(nums):
    def backtrack(path, choices):
        if len(path) == len(nums):  # 结束条件：路径长度等于数组长度
            res.append(path[:])  # 添加完整排列
            return
        for i in range(len(choices)):
            path.append(choices[i])  # 做选择：添加当前元素
            # 更新选择列表：移除已选元素
            new_choices = choices[:i] + choices[i+1:]
            backtrack(path, new_choices)  # 递归
            path.pop()  # 回溯：撤销选择
    
    res = []  # 存储所有排列
    backtrack([], nums)  # 初始调用
    return res

# 示例用法
nums = [1, 2, 3]
print(permute(nums))  # 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

代码解析：
- 结束条件：当path长度等于输入数组长度时，表示一个完整排列。
- 选择列表更新：每次递归时，移除当前选择的元素（choices[i]），避免重复选择。
- 剪枝：本例无显式剪枝，因为假设元素不重复。若有重复元素，可添加条件跳过相同值。
效率：时间复杂度$O(n!)$，空间复杂度$O(n)$。适合$n$较小场景（如$n \leq 10$）。

3. 子集实战：生成所有子集

子集问题要求生成数组的所有可能子集（包括空集）。例如，输入$[1,2,3]$，输出子集如$[]$、$[1]$、$[1,2]$等。使用通用模板，实现如下：

def subsets(nums):
    def backtrack(start, path):
        res.append(path[:])  # 任何路径都视为一个子集
        for i in range(start, len(nums)):  # 从start索引开始遍历
            path.append(nums[i])  # 做选择：添加当前元素
            backtrack(i + 1, path)  # 递归：只选后续元素，避免重复
            path.pop()  # 回溯：撤销选择
    
    res = []  # 存储所有子集
    backtrack(0, [])  # 初始调用，start=0
    return res

# 示例用法
nums = [1, 2, 3]
print(subsets(nums))  # 输出：[[],[1],[1,2],[1,2,3],[1,3],[2],[2,3],[3]]

代码解析：
- 结束条件：无显式结束条件，每次递归前都添加当前路径（子集）。
- 选择列表管理：使用start参数控制遍历起始点，确保只选后续元素，避免生成重复子集（如$[1,2]$和$[2,1]$被视为相同）。
- 剪枝：通过start索引跳过已处理元素，提高效率。
效率：时间复杂度$O(2^n)$（每个元素选或不选），空间复杂度$O(n)$。适合$n$中等规模（如$n \leq 20$）。