【DFS + 回溯 + 剪枝】LeetCode - 39. 组合总和

题目描述

题目链接

解法

如何快速判断一道题是否应该使用 DFS + 回溯算法来爆搜。

总的来说，你可以从两个方面来考虑：

• 求的是所有的方案，而不是方案数。
  由于求的是所有方案，不可能有什么特别的优化，我们只能进行枚举。这时候可能的解法有动态规划、记忆化搜索、DFS + 回溯算法。
• 通常数据范围不会太大，只有几十。
  如果是动态规划或是记忆化搜索的题的话，由于它们的特点在于低重复/不重复枚举，所以一般数据范围可以出到 10510^5105 到 10710^7107，而 DFS + 回溯的话，通常会限制在 30 以内。

思路分析： 根据示例 1：输入: candidates = [2, 3, 6, 7]，target = 7。

• 候选数组里有 2，如果找到了组合总和为 7 - 2 = 5 的所有组合，再在之前加上 2 ，就是 7 的所有组合；
• 同理考虑 3，如果找到了组合总和为 7 - 3 = 4 的所有组合，再在之前加上 3 ，就是 7 的所有组合，依次这样找下去。

基于以上的想法，可以 画出树形图，编码时通过 深度优先遍历 实现。建议大家自己在纸上画出这棵树，这一类问题都需要先画出树形图，然后编码实现。

几点说明：

1. 以 target = 7 为 根结点 ，创建一个分支的时 做减法 ；
2. 每一个箭头表示：从父亲结点的数值减去边上的数值，得到孩子结点的数值。边的值就是题目中给出的 candidate 数组的每个元素的值；
3. 减到 0 或者负数的时候停止，即：结点 0 和负数结点成为叶子结点；
4. 所有从根结点到结点 0 的路径（只能从上往下，没有回路）就是题目要找的一个结果。

在遍历时，如果遇到 -1 叶子结点，表示超出，那就退回到上一步，这就是 回溯

回溯算法其实就是一个暴力穷举的算法

这棵树有 4 个叶子结点的值 0，对应的路径列表是 [[2, 2, 3], [2, 3, 2], [3, 2, 2], [7]]，而示例中给出的输出只有 [[7], [2, 2, 3]]。这是因为题目中要求每一个符合要求的解是不计算顺序的组合，而我们多了重复的路径。

产生重复的原因是：在每一个结点，做减法，展开分支的时候，由于题目中说 每一个元素可以重复使用，我们考虑了 所有的 候选数，因此出现了重复的列表。

重复路径的解决办法： 我们在搜索的时候可以 按某种顺序搜索，每一次搜索的时候设置下一轮搜索的起点 index，这就是 剪枝

多叉树

class Solution {
private:
    vector<vector<int> > ans;//解集
    vector<int> path;//解集中的某一组合
    void DFS(vector<int>& candidates, int target, int index)
    {
        if(target < 0) return;
        if(target == 0)
        {
            ans.push_back(path);
            return;
        }
        for(int i = index; i < candidates.size() && target - candidates[i] >= 0; i++)
        {
            path.push_back(candidates[i]);//重复选取
            DFS(candidates, target - candidates[i], i);
            path.pop_back();//回溯
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        ans.clear();
        path.clear();
        sort(candidates.begin(), candidates.end());//从小到大排序
        DFS(candidates, target, 0);
        //target 表示减去之后当前剩余数，index = 0 表示当前位置在 candidates[0]
        return ans;
    }
};

二叉树

class Solution {
private:
    vector<vector<int> > ans;//解集
    vector<int> path;//解集中的某一组合
    void DFS(vector<int>& candidates, int target, int index)
    {
        if(target < 0 || index >= candidates.size()) return;
        if(target == 0)
        {
            ans.push_back(path);
            return;
        }
        //二叉树
        path.push_back(candidates[index]);//重复选取
        DFS(candidates, target - candidates[index], index);
        path.pop_back();//回溯
        
        DFS(candidates, target, index + 1);
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        ans.clear();
        path.clear();
        sort(candidates.begin(), candidates.end());//从小到大排序
        DFS(candidates, target, 0);
        //target 表示减去之后当前剩余数，index = 0 表示当前位置在 candidates[0]
        return ans;
    }
};

【完全背包】LeetCode - 322. 零钱兑换 的解法2中也用到了DFS，但是没用到回溯，而是贪心，思路上还是有相似的地方的。