leetcode 40 学习笔记（ 求组合总和II ）

40. 组合总和II

问题描述：传送门

思路：

和leetcode 39的区别是：

1、本题candidates中的每个数字在每个组合中只能使用一次。
2、本题数组candidates的元素是有重复的，而leetcode39是无重复元素的数组candidates。

本题和leetcode 39 一样，解集里不能包含重复的组合。

值得深思的是， 集合（数组candidates）有重复元素，但不能有重复的组合。

也就是说，抽象成树形结构， 去重时，是去同一树枝上的重，还是去同一树层上使用过的重。
先将candidates排序，
candidiates =[1，1，2]；target =3。
其树形结构如下图所示：

①确定递归函数的参数

可以看到，图中每个节点相对于leetcode 39多了一个used 数组。
与leetcode 39思路一致，加一个bool型数组used记录同一树枝上的元素是否使用过。
去重，就是靠used。

vector<vector<int>> result; // 存放组合集合
vector<int> path;           // 符合条件的组合
void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {

②确定递归的终止条件
和leetcode 39 一样，终止条件为sum>target 和sum== target。

代码如下：

if (sum > target) { // 这个条件其实可以省略 
    return;
}
if (sum == target) {
    result.push_back(path);
    return;
}

sum>target 这个条件可以省略，因为和在递归单层遍历的时候，会有剪枝的操作。

③确定单层的搜索逻辑
如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]
然后for循环执行continue。

如下图：

used[i - 1] == true，说明同一树支candidates[i - 1]使用过；
used[i - 1] == false，说明同一树层candidates[i - 1]使用过。

所以，单层搜索逻辑如下：

for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
    // used[i - 1] == true，说明同一树支candidates[i - 1]使用过
    // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
    // 要对同一树层使用过的元素进行跳过
    if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
        continue;
    }
    sum += candidates[i];
    path.push_back(candidates[i]);
    used[i] = true;
    backtracking(candidates, target, sum, i + 1, used); // 和39.组合总和的区别1：这里是i+1，每个数字在每个组合中只能使用一次
    used[i] = false;
    sum -= candidates[i];
    path.pop_back();
}

sum + candidates [ i ] <= target
为剪枝操作，在leetcode39有讲过。

代码：

整体代码如下：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            // used[i - 1] == true，说明同一树支candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 要对同一树层使用过的元素进行跳过
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, sum, i + 1, used); // 和39.组合总和的区别1，这里是i+1，每个数字在每个组合中只能使用一次
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);
        path.clear();
        result.clear();
        // 首先把给candidates排序，让其相同的元素都挨在一起。
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return result;
    }
};

大家明白了吗。