LeetCode刷题--- 目标和

前言：这个专栏主要讲述动态规划算法，所以下面题目主要也是这些算法做的  

我讲述题目会把讲解部分分为3个部分：
1、题目解析

2、算法原理思路讲解

3、代码实现

---

目标和

题目链接：目标和
题目

给你一个非负整数数组 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

提示：

• 1 <= nums.length <= 20
• 0 <= nums[i] <= 1000
• 0 <= sum(nums[i]) <= 1000
• -1000 <= target <= 1000

---

解法

算法原理与解析

我们这题使用动态规划，我们做这类题目可以分为以下五个步骤

1. 状态显示
2. 状态转移方程
3. 初始化（防止填表时不越界）
4. 填表顺序
5. 返回值

本题可以直接⽤「暴搜」的方法解决。但是稍微用数学知识分析⼀下，就能转化成我们常见的「背

包模型」的问题。 设我们最终选取的结果中，前⾯加 + 号的数字之和为 a ，前⾯加 - 号的数字之和为 b ，整个数组的总和为 sum ，于是我们有

• a + b = sum
• a - b = target

上⾯两个式子消去 b 之后，可以得到 a = (sum + target) / 2 。也就是说，我们仅需在 nums 数组中选择⼀些数，将它们凑成和为 (sum + target) / 2 即可。

• 状态显示

dp[i][j] ：表示在前 i 个数中选，总和正好等于 j ，⼀共有多少种选法。

• 状态转移方程

• 不选 nums[i] ：那么我们凑成总和 j 的总⽅案，就要看在前 i - 1 个元素中选，凑成总和为 j 的方案数。根据状态表示，此时 dp[ i ] [ j ] = dp[ i - 1 ] [ j ] ；
• 选择 nums[i] ：这种情况下是有前提条件的，此时的 nums[i] 应该是小于等于 j 。 因为如果这个元素都比要凑成的总和大，选择它就没有意义呀。那么我们能够凑成总和为 j 的方案数，就要看在前 i - 1 个元素中选，能否凑成总和为 j - nums[i] 。根据状态表示，此时 dp[ i ] [ j ] = dp[ i - 1 ] [ j - nums[ i ] ]。

综上所述，两种情况如果存在的话，应该要累加在⼀起。因此，状态转移方程为：

dp[ i ][ j ] = dp[ i - 1 ] [ j ]

if(nums[i - 1] <= j) dp[ i ] [ j ] = dp[ i ][ j ] += dp[ i - 1 ] [ j - nums[ i - 1] ]

• 初始化（防止填表时不越界）

由于需要用到「上⼀行」的数据，因此我们可以先把第⼀行初始化。 第⼀行表示不选择任何元素，要凑成目标和 j 。只有当目标和为 0 的时候才能做到，因此第一行仅需初始化第⼀个元素 dp[0][0] = 1。

• 填表顺序

根据「状态转移方程」，我们需要「从上往下」填写每⼀行，每⼀行的顺序是「无所谓的」。

• 返回值

根据「状态表示」，返回 dp[n][aim] 的值。

 

---

代码实现

#include <iostream>
#include <vector>

using namespace std;

int findTargetSumWays(vector<int>& nums, int target) 
{
	int sum = 0;					
	for (auto x : nums) sum += x;
	int aim = (sum + target) / 2;
	// 处理⼀下边界条件
	if (aim < 0 || (sum + target) % 2) return 0;
	int n = nums.size();
	vector<vector<int> > dp(n + 1, vector<int>(aim + 1));	// 表示在前i个数中选，总和等于j，有多少种选法
	dp[0][0] = 1;											// 初始化
	for (int i = 1; i <= n; i++)
		for (int j = 0; j <= aim; j++)
		{
			dp[i][j] = dp[i - 1][j];
			if (j >= nums[i - 1])
			{
				dp[i][j] += dp[i - 1][j - nums[i - 1]];
			}
		}
	return dp[n][aim];
}

---

代码优化

所有的「背包问题」，都可以进行空间上的优化。

对于 01背包类型的，我们的优化策略是：

• 删掉第⼀维；
• 修改第⼆层循环的遍历顺序即可

 

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) 
    {
        int sum = 0;
        for (auto x : nums) sum += x;
        int aim = (sum + target) / 2;
        // 处理⼀下边界条件
        if (aim < 0 || (sum + target) % 2) return 0;
        int n = nums.size();
        vector<int> dp(aim+1);	// 表示在前i个数中选，总和等于j，有多少种选法
        dp[0] = 1;				// 初始化
        for (int i = 1; i <= n; i++)
            for (int j = aim; j >= nums[i - 1]; j--)
            {
                dp[j] += dp[j - nums[i - 1]];
            }
        return dp[aim];
    }
};