leetcode-java 组合总和 IV

组合总和 IV

题目描述：

给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。

示例:

nums = [1, 2, 3]
target = 4

所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)

请注意，顺序不同的序列被视作不同的组合。

因此输出为 7。
进阶：
如果给定的数组中含有负数会怎么样？
问题会产生什么变化？
我们需要在题目中添加什么限制来允许负数的出现？

问题分析：

两种方法
	递归回溯：
		按照递归回溯流程，就算出所有满足条件的数组，然后return 数组的元素个数
		但是在提交的时候 可能会超时
	
	动态规划： 
		这里状态定义就是题目要求的，并不难，状态转移方程要动点脑子，也不难：
	    状态转移方程：dp[i]= dp[i - nums[0]] + dp[i - nums[1]] + dp[i - nums[2]] + ... （当 [] 里面的数 >= 0）
	    特别注意：dp[0] = 1，表示，如果那个硬币的面值刚刚好等于需要凑出的价值，这个就成为 1 种组合方案
	    
	    再举一个具体的例子：nums=[1, 2, 3], target=4;
	    dp[0] = 1
	    dp[1] = dp[1-1] = 1
	    dp[2] = dp[2-1] + dp[2-2] = 1 + 1 = 2
	    dp[3] = dp[3-1] + dp[3-2] + dp[3-3] = 2 + 1 + 1 = 4
	    dp[4] = dp[4-1] + dp[4-2] + dp[4-3] = 4 + 2 + 1 = 7
	    即：7 的组合数可以由三部分组成，1 和 dp[6]，3 和 dp[4], 4 和dp[3],然后再次往下分
	    
	    最终，dp[target] 的值 就是 满足条件的所有方案的个数

代码展示(已验证)：

递归回溯

//leetcode-java 377.组合总和 IV
class Solution {
    public int combinationSum4(int[] nums, int target) {
        if(nums.length==0)
            return 0;
        else
            return combinationsum4(nums,target).size(); //返回数组的长度
    }
    static List<List<Integer>> combinationsum4(int[] candidates, int target)
	{
//		创建一个return 的大数组
//		创建一个 小数组，数据是满足情况的组成数组，然后加入到大数组中去
		List<List<Integer>> listAll = new ArrayList<List<Integer>>();
		List<Integer> list = new ArrayList<Integer>();
		
		Arrays.sort(candidates);
		find(listAll,list,candidates,target,0);
		return listAll;
	}
	static void find(List<List<Integer>> listAll, List<Integer> tmp, int[] candidates, int target,int num)
	{
//		递归终点
		if(target ==0)
		{
			listAll.add(tmp);
			return;
		}
        
		if(target < candidates[0])
			return;
		for(int i=num; i<candidates.length && candidates[i] <= target; i++ )
		{
//			拷贝一份，不影响下次递归
			List<Integer> list = new ArrayList<>(tmp);
			list.add(candidates[i]);
//			递归运算，将 i 传递至下一次运算是为了避免结果重复
			find(listAll,list,candidates,target-candidates[i],0);
		}
	}

动态规划

//leetcode-java 377.组合总和 IV
class Solution {
    public int combinationSum4(int[] nums, int target) {
        int len = nums.length;
        if (len == 0) {
            return 0;
        }
        int[] dp = new int[target + 1];

        // 注意：理解这一句代码的含义
        dp[0] = 1;
        for (int i = 1; i <= target; i++) {
            for (int j = 0; j < len; j++) {
                if (i - nums[j] >= 0) {
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
}

类似题目：

组合总和 I
组合总和 II
组合总和 III

泡泡：

使用递归回溯解答这个题，完全就是遵循以往思路，不可取，因为 明显里面的很多东西是不必要的

使用动态规划的话确实能够减少一些时间，但是这种使用方式仍然算不上高效