Leetcode494. 目标和

Leetcode494. 目标和

相似题目：
Leetcode416. 分割等和子集
题目：
给你一个整数数组 $nums$ 和一个整数 $target$ 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：
例如，$nums=[2,1]$ ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 $target$ 的不同 表达式 的数目。

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 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
+1 + 1 + 1 + 1 - 1 = 3

示例 2：

输入：nums = [1], target = 1
输出：1

题解：
0-1背包问题
记数组的元素和为 $\text{sum}$，添加 $\text{-}$ 号的元素之和为 $\text{neg}$，则其余添加 $\text{+}$ 的元素之和为 $\text{sum}-\text{neg}$，得到的表达式的结果为
$(\text{sum}-\text{neg})-\text{neg}=\text{sum}-2\cdot \text{neg}=\text{target}(sum-neg)-neg=sum-2\cdot neg=target$
即
$\text{neg}=\frac{\text{sum}-\text{target}}{2}$
​
由于数组 $\text{nums}$ 中的元素都是非负整数，$\text{neg}$ 也必须是非负整数，所以上式成立的前提是 $\text{sum}-\text{target}$是非负偶数。若不符合该条件可直接返回 0。

若上式成立，问题转化成在数组 $\text{nums}$ 中选取若干元素，使得这些元素之和等于 $\text{neg}$，计算选取元素的方案数。我们可以使用动态规划的方法求解。

定义二维数组 $\text{dp}$，其中$\text{dp}[i][j]$ 表示从数组的 $[0,i]$下标范围内选取若干个正整数，使得这些元素之和等于 $j$ 的方案数。假设数组 $\text{nums}$ 的长度为 n，则最终答案为$\text{dp}[n-1][\text{neg}]$。

在定义状态之后，需要考虑边界情况。以下两种情况都属于边界情况。

• 如果不选取任何正整数，则被选取的正整数等于 0。因此对于所有 $0\le i<n$，都有$dp[i][0]=1$；
• 当 $i=0$ 时，只有一个正整数 $\text{nums}[0]$可以被选取，因此$dp[0][nums[0]]=1$；
• 当没有任何元素可以选取时，$dp[0][j]=0(j>0)$。

当 $1\le i<n$时，对于数组 $\text{nums}$中的第 $i$ 个元素 $\text{num}$（i 的计数从 1 开始），遍历 $0\le j\le \text{neg}$，计算 $\text{dp}[i][j]$ 的值：

如果 $j<\text{num}$，则不能选 $\text{num}$，此时有 $\text{dp}[i][j]=\text{dp}[i-1][j]$；

如果 $j\ge \text{num}$，则如果不选 $\text{num}$，方案数是 $\text{dp}[i-1][j]$，如果选 $\text{num}$，方案数是 $\text{dp}[i-1][j-\text{num}]$，此时有 $\text{dp}[i][j]=\text{dp}[i-1][j]+\text{dp}[i-1][j-\text{num}]$。

因此状态转移方程如下：

$\text{dp}[i][j]=\{\begin{array}{ll}\text{dp}[i-1][j],& j<\text{nums}[i]\\ \text{dp}[i-1][j]+\text{dp}[i-1][j-\text{nums}[i]],& j\ge \text{nums}[i]\end{array}$

最终得到 $\text{dp}[n-1][\text{neg}]$ 的值即为答案。

java代码：

  /**
     * @param nums
     * @param target
     * @return
     */
    public static int findTargetSumWays(int[] nums, int target) {
        int len = nums.length;
        int sum = 0;
        for (int i = 0; i < len; i++) {
            sum += nums[i];
        }

        if ((sum - target) % 2 != 0) {
            return 0;
        }

        int neg = (sum - target) / 2;
        //dp[i][j] ：在数组[0,i]中选取一些数，使得和为j
        int[][] dp = new int[len][neg + 1];

        //i=0时，只有一个正数nums[0]可以被选取
        dp[0][nums[0]] = 1;

        for (int i = 0; i < len; i++) {
            //从[0,i]中不选任何正整数
            dp[i][0] = 1;
        }

        for (int i = 1; i < len; i++) {
            for (int j = 1; j <= neg; j++) {
                if (j < nums[i]) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
                }
            }
        }
        return dp[len - 1][neg];
    }