leetcode494 目标和

给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。

返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

示例 1:

输入: nums: [1, 1, 1, 1, 1], S: 3
输出: 5
解释: 

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

一共有5种方法让最终目标和为3。

方法1：递归

       我们从第一个数字，调用递归函数，在递归函数中，分别对目标值进行加上当前数字调用递归，和减去当前数字调用递归，这样会涵盖所有情况，并且当所有数字遍历完成后，我们看若目标值为0了，则结果res自增1。

public int findTargetSumWays(int[] nums, int S) {
    return helper(nums, 0, S, 0);
}
private int helper(int[] nums, int index, int S, int sum) {
    int res = 0;
    if (index == nums.length) {
        return sum == S ? ++res : res;
    }
    res += helper(nums, index + 1, S, sum + nums[index]);
    res += helper(nums, index + 1, S, sum - nums[index]);
    return res;
}

方法2：动态规划

原文：https://blog.csdn.net/hit0803107/article/details/54894227 

【问题分析】

1、该问题求解数组中数字只和等于目标值的方案个数，每个数字的符号可以为正或负(减整数等于加负数)。

2、该问题和矩阵链乘很相似，是典型的动态规划问题

3、举例说明: nums = {1,2,3,4,5}, target=3, 一种可行的方案是+1-2+3-4+5 = 3

     该方案中数组元素可以分为两组，一组是数字符号为正(P={1,3,5})，另一组数字符号为负(N={2,4})

     因此: sum(1,3,5) - sum(2,4) = target

              sum(1,3,5) - sum(2,4) + sum(1,3,5) + sum(2,4) = target + sum(1,3,5) + sum(2,4)

              2sum(1,3,5) = target + sum(1,3,5) + sum(2,4)

              2sum(P) = target + sum(nums)

              sum(P) = (target + sum(nums)) / 2

     由于target和sum(nums)是固定值，因此原始问题转化为求解nums中子集的和等于sum(P)的方案个数问题

4、求解nums中子集合只和为sum(P)的方案个数(nums中所有元素都是非负)

      该问题可以通过动态规划算法求解

      举例说明：给定集合nums={1,2,3,4,5}, 求解子集，使子集中元素之和等于9 = new_target = sum(P) = (target+sum(nums))/2

              定义dp[10]数组, dp[10] = {1,0,0,0,0,0,0,0,0,0}

              dp[i]表示子集合元素之和等于当前目标值的方案个数, 当前目标值等于9减去当前元素值

              当前元素等于1时，dp[9] = dp[9] + dp[9-1]

                                            dp[8] = dp[8] + dp[8-1]

                                            ...

                                            dp[1] = dp[1] + dp[1-1]

              当前元素等于2时，dp[9] = dp[9] + dp[9-2]

                                            dp[8] = dp[8] + dp[8-2]

                                            ...

                                            dp[2] = dp[2] + dp[2-2]

              当前元素等于3时，dp[9] = dp[9] + dp[9-3]

                                            dp[8] = dp[8] + dp[8-3]

                                            ...

                                            dp[3] = dp[3] + dp[3-3]

              当前元素等于4时，

                                            ...

              当前元素等于5时，

                                           ...

                                           dp[5] = dp[5] + dp[5-5]

             最后返回dp[9]即是所求的解.

public int findTargetSumWays(int[] nums, int S) {
    int sum = 0;
    for (int i = 0; i < nums.length; i++) {
	    sum += nums[i];
     }
	if (S > sum || (sum + S) % 2 == 1)
		return 0;
	return subsetSum(nums, (sum + S) / 2);
}
private int subsetSum(int[] nums, int S) {
	int[] dp = new int[S + 1];
	dp[0] = 1;
	for (int i = 0; i < nums.length; i++) {
		for (int j = S; j >= nums[i]; j--) {
			dp[j] += dp[j - nums[i]];
		}
	}
	return dp[S];
}