这是我参与2022首次更文挑战的第25天，活动详情查看：2022首次更文挑战

目标和

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

题解

算法一：动态规划（Java）

• 1 确定dp数组以及下标含义 dp[j]表示要装满容量为j的背包，一共有dp[j]种方法

• 2 确定递推公式 那么如何推导出dp[j]呢？我们知道，要装满容量为j-nums[i]的背包，一共有dp[j-nums[i]]种方法,那么只要找到nums[i]，自然就能填满容量为j的背包，也就是说此时有dp[j-nums[i]]种方法可以填满容量为j的背包；以此类推，将多个dp[j-nums[i]]累加起来就得到dp[j]。所以递推公式就是dp[j] += dp[j-nums[i]]

• 3 初始化dp数组 首先，dp[0] = 1，这个很好理解，装满容量为0的背包，有1种方法，就是装0件物品。dp数组长度即为p+1

• 4 确定遍历顺序 一维数组遍历顺序，是先遍历物品，再遍历背包，且遍历背包时必须是倒序

class Solution {
    public int findTargetSumWays(int[] nums, int S) {
        if (nums == null || nums.length == 0) {
            return 0;
        }

        int[][] dp = new int[nums.length][2001];
        dp[0][nums[0] + 1000] = 1;
        dp[0][-nums[0] + 1000] += 1;

        for (int i = 1; i < nums.length; i++) {
            for (int sum = -1000; sum <= 1000; sum++) {
                if (dp[i - 1][sum + 1000] > 0) {
                    dp[i][sum + nums[i] + 1000] += dp[i - 1][sum + 1000];
                    dp[i][sum - nums[i] + 1000] += dp[i - 1][sum + 1000];
                }
            }
        }
        return S > 1000 ? 0 : dp[nums.length - 1][S + 1000];
    }
}

时间复杂度：O（n * (sum - target)）

空间复杂度：O（sum - target）

算法一：动态规划（Go）

思路同上

func findTargetSumWays(nums []int, target int) int {
    sum := SumOfArray(nums)
    // target的绝对值比数组和还大，是不可能有结果的
    if Abs(target) > sum{
        return 0
    }
    if (sum + target) % 2 == 1{
        return 0
    }
    p := (sum + target) / 2
    dp := make([]int, p+1)
    dp[0] = 1
    for i:=0;i<len(nums);i++{
        for j:=p;j>=nums[i];j--{
            dp[j] += dp[j-nums[i]]
        }
    }
    return dp[p]
}


func SumOfArray(array []int) int {
	sum := 0
	n := len(array)
	for i := 0; i < n; i++ {
		sum += array[i]
	}
	return sum
}

func Abs(x int) int {
	if x < 0 {
		return -1 * x
	}
	return x
}

时间复杂度：O（n * (sum - target)）

空间复杂度：O（sum - target）