组合总和II-回溯

• 题目

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用 一次 。

• 实例

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

• 代码

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> cur = new ArrayList<>();  
    public void dfs(int[] c, int target, int sum, int index) {
        if (sum == target) {
            res.add(new ArrayList<>(cur));
            return;
        }
        int n = c.length;
        if (sum > target || index == n) {
           
            return;
        }

        // 1,2,2,2,5
        // 这样的话就是，每层第一个数必选，如果前面的数一样并且前面的数访问过，才跳过
        // 但是这样，当要选第二个数时，说明此时已经从第一个数回溯回来，此时第一个数没访问过，则第二个数选了
        // 当要选第3个数时，说明此时已经从第二个数回溯回来，此时第一个数、第二个数都没访问过，则第三个数选了
        // 相当于根本就没有排除数据
        // if (i != index && c[i-1] == c[i] && visited[i-1]) {
        //         continue;
        // }

        // 1,2,2,2,5
        // 这样的话就是，每层第一个数必选，如果前面的数一样并且前面的数没有访问过，才跳过
        // 但是这样，当要选第二个数时，说明此时已经从第一个数回溯回来，此时第一个数没访问过，则第二个数不选
        // 当要选第3个数时，说明此时已经从第二个数回溯回来，此时第一个数、第二个数都没访问过，则第三个数不选了
        // !visted[i-1]屌用没有
        // 所以这样写，也能AC
        // if (i != index && c[i-1] == c[i] && !visited[i-1]) {
        //         continue;
        // }   


        for (int i = index; i < n; i++) {
            // 每一层都是从c[index]到c[n-1]开始选择,其中里面相同的数只能选一个
            // 就把数组排序，然后只选c[index],后面相同的都跳过
            // 每层第一个数必选，后面相同的数跳过
            if (i != index && c[i-1] == c[i] ) {
                continue;
            }
            
            sum += c[i];
            cur.add(c[i]);
            dfs(c, target, sum, i + 1);
            
            sum -= c[i];
            cur.remove(cur.size() - 1);
        }
    }

    public List<List<Integer>> combinationSum2(int[] c, int target) {
        int n = c.length;
        Arrays.sort(c);
        dfs(c, target, 0 ,0);
        return res;
    }
}