[LeetCode] 39. 组合总和

题目链接 : https://leetcode-cn.com/problems/combination-sum/

题目描述:

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。

示例:

示例 1:

输入: candidates = [2,3,6,7], target = 7,

所求解集为:

[

  [7],

  [2,2,3]

]

示例 2:

输入: candidates = [2,3,5], target = 8,

所求解集为:

[

  [2,2,2,2],

  [2,3,3],

  [3,5]

]

思路:

回溯算法

很标准的模板

关注我的知乎专栏,了解更多解题技巧,大家一起加油!

代码:

python

class Solution:

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:

        candidates.sort()

        n = len(candidates)

        res = []

        def helper(i, tmp_sum, tmp):

            if tmp_sum > target or i == n:

                return

            if tmp_sum == target:

                res.append(tmp)

                return

            helper(i,  tmp_sum + candidates[i],tmp + [candidates[i]])

            helper(i+1, tmp_sum ,tmp)

        helper(0, 0, [])

        return res

python

class Solution:

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:

        candidates.sort()

        n = len(candidates)

        res = []

        def backtrack(i, tmp_sum, tmp):

            if  tmp_sum > target or i == n:

                return

            if tmp_sum == target:

                res.append(tmp)

                return

            for j in range(i, n):

                if tmp_sum + candidates[j] > target:

                    break

                backtrack(j,tmp_sum + candidates[j],tmp+[candidates[j]])

        backtrack(0, 0, [])

        return res

java

class Solution {

    public List<List<Integer>> combinationSum(int[] candidates, int target) {

        List<List<Integer>> res = new ArrayList<>();

        Arrays.sort(candidates);

        //System.out.println(candidates);

        backtrack(candidates, target, res, 0, new ArrayList<Integer>());

        return res;

    }

    private void backtrack(int[] candidates, int target, List<List<Integer>> res, int i, ArrayList<Integer> tmp_list) {

        if (target < 0) return;

        if (target == 0) {

            res.add(new ArrayList<>(tmp_list));

            return;

        }

        for (int start = i; start < candidates.length; start++) {

            if (target < 0) break;

            //System.out.println(start);

            tmp_list.add(candidates[start]);

            //System.out.println(tmp_list);

            backtrack(candidates, target - candidates[start], res, start, tmp_list);

            tmp_list.remove(tmp_list.size() - 1);

        }

    }

}

类似题目还有:

这类题目都是同一类型的,用回溯算法!

其实回溯算法关键在于:不合适就退回上一步

然后通过约束条件, 减少时间复杂度.

大家可以从下面的解法找出一点感觉!