组合总和IV(js三种解法)

题目：

给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

示例 1：

输入：nums = [1,2,3], target = 4
输出：7
解释：
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。
示例 2：

输入：nums = [9], target = 3
输出：0

---

题解1：(回溯)

该方法在leetcode中超时，只能通过部分用例。

解题思路：

根据题意，顺序不同的序列被视作不同的组合，这说明这道题应该是一道排列问题，因此不需要startIndex,并且每一个位置都可以重复选取，因此不需要通过used数组来记录元素是否被选取。

代码：

var combinationSum4 = function(nums, target) {
    let res = 0 , path = [] , sum = 0
    backTracking()
    return res

    function backTracking() {
        if(sum == target) {
            res++
            return 
        }
        for(let i = 0 ; i < nums.length ; i++) {
            if(sum + nums[i] > target) {
                continue
            }
            path.push(nums[i])
            sum += nums[i]
            backTracking()
            sum -= nums[i]
            path.pop()
        }
    }
};

console.log(combinationSum4([1,2,3],4))  //打印结果：7

---

题解2：(记忆化递归)

方法2在方法1的基础上进行了优化，降低了时间复杂度，可以通过leetcode上的所有用例。

解题思路：

记忆化递归主要就是通过哈希表来降低时间复杂度，不需要每次都从头到尾进行搜索。用哈希表来存储不同的target值所对应的res结果数量。当下一个需要求的target数存在于哈希表当中，那么就直接从哈希表中获取这个target数对应的res值。

代码：

var combinationSum4 = function(nums, target) {
    const map = new Map()
    return backTracking(nums,target)

    function backTracking(nums,remains) {
        //如果剩余的所需数为0，则说明找到了一种符合的组合结果，也可以理解为当传入的target为0时，只有什么都不选这一种结果，因此返回1。
        if(remains == 0) {
            return 1
        }
        if(map.has(remains)) {
            return map.get(remains)
        }
        let res = 0
        for(let i = 0 ; i < nums.length ; i++) {
            // 如果剩余的数大于或等于下一个要选择的数，那么在进行递归
            if(remains >= nums[i]) {
                res += backTracking(nums,remains - nums[i])
            }
        }
        map.set(remains,res)
        return res
    }
};

---

题解3：(动态规划)

官方题解中，本题采用的是动态规划解法，题目要求求的是结果数量，并不是求结果集，因此可以尝试采用动态规划来解题。

解题思路：

动态规划五部曲：

1、确定dp数组的含义：这里的dp数组表示的是凑成目标正整数为i的排列个数为dp[i]。

2、确定动态规划转移方程：

dp[i]（考虑nums[j]）可以由 dp[i - nums[j]]（不考虑nums[j]） 推导出来。

因为只要得到nums[j]，排列个数dp[i - nums[j]]，就是dp[i]的一部分。

递推公式为：dp[i] += dp[i-nums[j]]。

3、dp数组初始化：dp[0] = 1 , 表示当目标数位0的时候，排列的个数只有什么都不选这一种方案，因此dp[0] = 1。

4、确定遍历顺序：个数可以不限使用，说明这是一个完全背包。得到的集合是排列，说明需要考虑元素之间的顺序。如果求排列数就是外层for遍历背包，内层for循环遍历物品。

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

如果把遍历nums（物品）放在外循环，遍历target的作为内循环的话，举一个例子：计算dp[4]的时候，结果集只有 {1,3} 这样的集合，不会有{3,1}这样的集合，因为nums遍历放在外层，3只能出现在1后面！

所以本题遍历顺序最终遍历顺序：target（背包）放在外循环，将nums（物品）放在内循环，内循环从前到后遍历。

5、举例推导dp数组：

本题解参考了leetcode上的优质题解：力扣

代码：

var combinationSum4 = function(nums, target) {
    const dp = new Array(target + 1).fill(0);
    dp[0] = 1;
    for (let i = 1; i <= target; i++) {
        for (const num of nums) {
            if (num <= i) {
                dp[i] += dp[i - num];
            }
        }
    }
    return dp[target];
};