0039. Combination Sum (M)

Combination Sum (M)

题目

Given a set of candidate numbers (candidates) (without duplicates) and a target number (target), find all unique combinations in candidates where the candidate numbers sums to target.

The same repeated number may be chosen from candidates unlimited number of times.

Note:

  • All numbers (including target) will be positive integers.
  • The solution set must not contain duplicate combinations.

Example 1:

Input: candidates = [2,3,6,7], target = 7,
A solution set is:
[
  [7],
  [2,2,3]
]

Example 2:

Input: candidates = [2,3,5], target = 8,
A solution set is:
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

题意

给一串数,找出所有和等于目标值的组合,每个数字可以重复使用。

思路

排列组合题很容易想到使用回溯法,但与37. Sudoku Solver不同的是,37只要求在回溯中找到一种符合条件的解即可,而本题需要找到所有符合条件的解,因此这两种回溯法递归函数返回值的含义不同(实际上本题递归函数可以没有返回值,但加上返回值可以在适当的地方直接跳出循环,提高算法的效率)。

回溯法实现:

  1. 先对数组排序,方便处理。
  2. 递归边界为 sum >= target,其中当 sum == target 时,需要将该解记录下来。
  3. 递归主体:每次加入的值不小于上一次加入的值(因为是递增数列所以很容易处理), 加入后进行递归,递归完成后将加入的数去掉。如果递归返回值为false,说明刚刚加入的数已经使整个序列的和达到了最大限值,不用再继续加入更大的值,可以直接跳出。

代码实现

Java

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

    private boolean solve(int[] candidates, int target, int sum, List<Integer> list, List<List<Integer>> ans, int index) {
        if (sum > target) {
            return false;
        }
        if (sum == target) {
            ans.add(new ArrayList<>(list));
            return false;
        }

        for (int i = index; i < candidates.length; i++) {
            list.add(candidates[i]);
            boolean flag = solve(candidates, target, sum + candidates[i], list, ans, i);
            list.remove(list.size() - 1);
            if (!flag) {
                break;
            }
        }

        return true;
    }
}

JavaScript

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function (candidates, target) {
  let res = []
  dfs(candidates, 0, 0, target, [], res)
  return res
}

let dfs = function (candidates, index, sum, target, list, res) {
  if (index === candidates.length || sum > target) {
    return
  }

  if (sum === target) {
    res.push([...list])
    return
  }

  list.push(candidates[index])
  dfs(candidates, index, sum + candidates[index], target, list, res)
  list.pop()
  dfs(candidates, index + 1, sum, target, list, res)
}
posted @ 2020-06-27 02:46  墨云黑  阅读(72)  评论(0编辑  收藏  举报