组合总和.md

组合总和

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

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

说明：

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

示例：

输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
  [7],
  [2,2,3]
]

输入：candidates = [2,3,5], target = 8,
所求解集为：
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

提示：

• 1 <= candidates.length <= 30
• 1 <= candidates[i] <= 200
• candidate 中的每个元素都是独一无二的。
• 1 <= target <= 500

回溯算法-粗暴Map去重

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
  // 先升序排
  candidates.sort((a, b) => a - b)
  const res = []
  const map = new Map()
  const recursion = (sets, left) => {
    if (left === 0) {
      // 做去重处理
      const sortSets = [...sets].sort()
      if (!map.get(sortSets.join())) {
        res.push(sortSets)
        map.set(sortSets.join(), true)
      }
      return
    }
    for (let i = 0; i < candidates.length; i++) {
      if (candidates[i] > left) {
        break;
      }
      sets.push(candidates[i])
      recursion(sets, left - candidates[i])
      sets.pop()
    }
  }
  recursion([], target)
  return res
};

回溯算法-进阶去重

/**
 * @param {number[]} candidates
 * @param {number} target
 * @return {number[][]}
 */
var combinationSum = function(candidates, target) {
  // 先升序排
  candidates.sort((a, b) => a - b)
  const res = []
  const recursion = (sets, left, start) => {
    if (left === 0) {
      res.push([...sets])
    }
    // 不走比自己小的值，实现去重
    for (let i = start; i < candidates.length; i++) {
      if (candidates[i] > left) {
        break;
      }
      sets.push(candidates[i])
      recursion(sets, left - candidates[i], i)
      sets.pop()
    }
  }
  recursion([], target, 0)
  return res
};