回溯算法解题框架-------labuladong笔记(太牛了)

原创已于 2025-02-20 18:28:24 修改 · 935 阅读

13 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #笔记 #leetcode #数据结构 #c++

于 2025-02-20 16:03:19 首次发布

LeetCode 专栏收录该内容

12 篇文章

订阅专栏

回溯算法解题框架之我是搬运工(太难了)

问题：

回溯算法和DFS算法基本可认为是一种算法；抽象的说，解决一个回溯问题，实际上就是遍历

一棵决策树的过程，树的每个叶子结点存放着一个合法答案。将整棵树遍历一遍，把叶子结点上的答案都收集起来，就能得到所有的合法答案。

在一个节点上需要考虑：

结束条件：到达决策树底层就无需再做选择
选择列表：当前可以做哪些选择
路径：目前已经做出的选择

框架：

result = []
void backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

其核心就是 for 循环里面的递归，在递归调用之前「做选择」，在递归调用之后「撤销选择」，特别简单。

全排列问题解析：

leecode1：

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

解析：

我们在高中的时候就做过排列组合的数学题，我们也知道 n 个不重复的数，全排列共有 n! 个。那么我们当时是怎么穷举全排列的呢？

比方说给三个数 [1,2,3]，你肯定不会无规律地乱穷举，一般是这样：

先固定第一位为 1，然后第二位可以是 2，那么第三位只能是 3；然后可以把第二位变成 3，第三位就只能是 2 了；然后就只能变化第一位，变成 2，然后再穷举后两位……

我们定义的 backtrack 函数其实就像一个指针，在这棵树上游走，同时要正确维护每个节点的属性，每当走到树的底层叶子节点，其「路径」就是一个全排列。

回忆二叉树遍历：

前序遍历的代码在进入某一个节点之前的那个时间点执行
后序遍历代码在离开某个节点之后的那个时间点执行

「路径」和「选择」是每个节点的属性，函数在树上游走要正确处理节点的属性，那么就要在这两个特殊时间点搞点动作：

核心框架:

for (选择 : 选择列表){
    //做选择
    将该选择从选择列表移除;
    路径.add(选择);
    
    backtrack(路径，选择列表);
    
    //撤销选择
    路径.remove(选择);
    将该选择再加入选择列表;
}

代码:

class Solution {
private:
    vector<vector<int>> res;
public:
    // 主函数，输入一组不重复的数字，返回它们的全排列
    vector<vector<int>> permute(vector<int>& nums) {
        // 记录「路径」
        vector<int> track;
        // 「路径」中的元素会被标记为true，避免重复使用
        vector<bool> used(nums.size(), false);

        backtrack(nums, track, used);
        return res;
    }

    // 路径：记录在 track 中
    // 选择列表：nums 中不存在于 track 的那些元素
    // 结束条件：nums 中的元素全都在 track 中出现
    void backtrack(vector<int>& nums, vector<int>& track, vector<bool>& used) {
        // 触发结束条件
        if (track.size() == nums.size()) {
            res.push_back(track);
            return;
        }

        for (int i = 0; i < nums.size(); i++) {
            // 排除不合法的选择
            if (used[i]) {

                // nums[i] 已经在 track 中，跳过
                continue;
            }
            // 做选择
            track.push_back(nums[i]);
            used[i] = true;
            // 进入下一层决策树
            backtrack(nums, track, used);
            // 取消选择
            track.pop_back();
            used[i] = false;
        }
    }
};

数据结构：

nums：数字组
track：记录路径
used ：记录该元素(数组)是否用过

leecode2:全排列2

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> track;
    vector<bool> used;

    vector<vector<int>> permuteUnique(vector<int>& nums) {
        // 先排序，让相同的元素靠在一起
        sort(nums.begin(), nums.end());
        used = vector<bool>(nums.size(), false);
        backtrack(nums);
        return res;
    }

    void backtrack(vector<int>& nums) {
        if (track.size() == nums.size()) {
            res.push_back(track);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (used[i]) {
                continue;
            }
            // 新添加的剪枝逻辑，固定相同的元素在排列中的相对位置
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                // 确保不是访问第一个元素
                //如果前面的相邻相等元素没有用过，则跳过
                continue;
            }
            track.push_back(nums[i]);
            used[i] = true;
            backtrack(nums);
            track.pop_back();
            used[i] = false;
        }
    }
};

对比一下之前的标准全排列解法代码，这段解法代码只有两处不同：

1、对 nums 进行了排序。

2、添加了一句额外的剪枝逻辑。

是注意排列问题的剪枝逻辑，和子集/组合问题的剪枝逻辑略有不同：新增了 !used[i - 1] 的逻辑判断。

回答：设输入为 nums = [1,2,2']，标准的全排列算法会得出如下答案：

[
    [1,2,2'],[1,2',2],
    [2,1,2'],[2,2',1],
    [2',1,2],[2',2,1]
]

显然，这个结果存在重复，比如 [1,2,2'] 和 [1,2',2] 应该只被算作同一个排列，但被算作了两个不同的排列。如何去除重复？

答案是，保证相同元素在排列中的相对位置保持不变。

比如说 nums = [1,2,2'] 这个例子，保持排列中 2 一直在 2' 前面。

标准全排列算法之所以出现重复，是因为把相同元素形成的排列序列视为不同的序列，但实际上它们应该是相同的；而如果固定相同元素形成的序列顺序，当然就避免了重复。

组合问题解析：

leecode1：

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

combine(3, 2) 的返回值应该是：

[ [1,2],[1,3],[2,3] ]

现在你只需要把第 2 层（根节点视为第 0 层）的节点收集起来，就是大小为 2 的所有组合

class Solution {
public:
    vector<vector<int>> res;
    // 记录回溯算法的递归路径
    deque<int> track;

    // 主函数
    vector<vector<int>> combine(int n, int k) {
        backtrack(1, n, k);
        return res;
    }

    void backtrack(int start, int n, int k) {
        // base case
        if (k == track.size()) {
            // 遍历到了第 k 层，收集当前节点的值
            res.push_back(vector<int>(track.begin(), track.end()));
            return;
        }

        // 回溯算法标准框架
        for (int i = start; i <= n; i++) {
            // 选择
            track.push_back(i);
            // 通过 start 参数控制树枝的遍历，避免产生重复的子集
            backtrack(i + 1, n, k);
            // 撤销选择
            track.pop_back();
        }
    }
};

子集问题：

给你一个整数数组 nums，其中可能包含重复元素，请你返回该数组所有可能的子集。

输入 nums = [1,2,2]，应该输出：

[ [],[1],[2],[1,2],[2,2],[1,2,2] ]

该数组一定不是集合（毕竟不包含重复元素）

这里将另一个2记为2’

结果出现了重复，所以我们需要进行剪枝，如果一个节点有多条值相同的树枝相邻，则只遍历第一条，剩下的都剪掉，不要去遍历

体现在代码上，需要先进行排序，让相同的元素靠在一起，如果发现 nums[i] == nums[i-1]，则跳过

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<<vector<int>> res;
        deque<int> track;
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        //前序位置，每个节点的值都是一个子集
        sort(nums.begin(), nums.end());
        backtrack(nums,0);
        return res;
    }
    void backtrack(vector<int>& nums,int start){
        //前序位置
        res.push_back(vector<int>(track.begin(),track.end()));

        for(int i=start;i<nums.size();i++){
            //剪枝逻辑
            if(i > start && nums[i] == nums[i-1]){
                continue;
            }
            track.push_back(nums[i]);
            backtrack(nums,i+1);
            track.pop_back();
        }
    }
    }
};