LeetCode 39. Combination Sum

All elements of candidates are distinct

由题目可知所有元素都是不重复的，因此不用去重

JAVA

① 普遍做法（2ms）

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        List<Integer> combine = new ArrayList<Integer>();
        dfs(candidates, ans, combine, target, 0);
        return ans;
    }

    public void dfs(int[] candidates, List<List<Integer>> ans, List<Integer> combine, int target, int idx) {
        if (idx == candidates.length) {
            return;
        }
        if (target == 0) {
            ans.add(new ArrayList<>(combine));
            return;
        }
        dfs(candidates, ans, combine, target, idx + 1);
        if (target - candidates[idx] >= 0) {
            int tmp = target - candidates[idx];
            combine.add(candidates[idx]);
            dfs(candidates, ans, combine, tmp, idx);
            combine.remove(combine.size() - 1);
        }
    }
}

② 排序 + 剪枝（2ms）

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        List<Integer> combine = new ArrayList<Integer>();
        Arrays.sort(candidates);							// 排序
        dfs(candidates, ans, combine, target, 0);
        return ans;
    }

    public void dfs(int[] candidates, List<List<Integer>> ans, List<Integer> combine, int target, int begin) {
        if (target == 0) {
            ans.add(new ArrayList<>(combine));
            return;
        }
        for (int i = begin; i < candidates.length; i++) {	// 剪枝，可减少一轮递归
            if (target - candidates[i] >= 0) {
                combine.add(candidates[i]);
                dfs(candidates, ans, combine, target - candidates[i], i);
                combine.remove(combine.size() - 1);
            } else {break;}
        }
    }
}

Python

① 普遍做法（88ms）

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        def dfs(candidates, res, combine, target, idx, length):
            if target == 0:
                res.append(combine)
                return
            if idx == length:
                return

            dfs(candidates, res, combine, target, idx+1, length)

            if target-candidates[idx] < 0:
                return
            else:
                dfs(candidates, res, combine +
                    [candidates[idx]], target-candidates[idx], idx, length)  # 不用 remove

        res = []
        combine = []
        length = len(candidates)
        candidates.sort()
        dfs(candidates, res, combine, target, 0, length)
        return res

② 排序 + 剪枝（60ms）

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        def dfs(candidates, res, combine, target, begin, length):
            if target == 0:
                res.append(combine)
                return

            for i in range(begin, length):
                tmp = target-candidates[i]
                if tmp < 0:
                    break
                dfs(candidates, res, combine +
                    [candidates[i]], tmp, i, length)       # 不用 remove

        res = []
        combine = []
        length = len(candidates)
        candidates.sort()
        dfs(candidates, res, combine, target, 0, length)
        return res