Leetcode 494. 目标和

Leetcode 494. 目标和

中等题

题目

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

解法

可以使用哈希表存储遍历到第i个数字可以组成的所有和的个数，在遍历下一个的时候，以此为基础，生成下一个状态的所有可以得到和的个数；

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        dp = [{} for _ in range(len(nums)+1)]
        dp[0], n = {0:1}, len(nums) #存储 可以得到的和 ：不同表达式数目
        for i in range(1,n+1):
            for tsum in dp[i-1]:
                res, c1, c2 = dp[i-1][tsum], tsum+nums[i-1], tsum-nums[i-1]
                if c1 not in dp[i]: dp[i][c1] = 0
                if c2 not in dp[i]: dp[i][c2] = 0
                dp[i][c1] +=  res
                dp[i][c2] +=  res
        return dp[n][target] if target in dp[n] else 0

• 时间复杂度 $O(n^2)$
• 空间复杂度 $O(n^2)$

01背包

注意到所有的数均在0-1000之间，neg 表示设置为负数的数字和，则有sum(nums)-2*neg = target 则有neg = (sum(nums)-target)/2，如果无法得到整数则直接返回0，而后进行查询，可将其视作0-1背包问题，在数组中找寻和为neg的情况，。

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        target += sum(nums)
        if target < 0 or target % 2:
            return 0
        neg = target//2
        dp = [1] + [0] * neg
        for i in range(len(nums)):
            for j in range(neg,-1,-1):
                if j-nums[i]>=0: dp[j] += dp[j-nums[i]]
        return dp[neg]

时间复杂度：O(n⋅(target+S))，其中 n 为 numss 的长度，S 为 nums 的元素之和。其实这里省略了除以二；
空间复杂度：O(target+S)，省略了除以二；

递归调用+记忆化搜索

@cache可以记忆化搜索，记忆化搜索就是递归版动态规划，基本原理都是将计算过的值保存然后直接返回。

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        n, self.res = len(nums), 0
        @cache
        def dfs(depths, tsum):
            if depths>n: return 0
            if depths==n: return 1 if tsum==target else 0
            else: return dfs(depths+1,tsum+nums[depths])+dfs(depths+1,tsum-nums[depths])
        return dfs(0, 0)