494. 目标和

最新推荐文章于 2026-01-05 22:36:07 发布

原创最新推荐文章于 2026-01-05 22:36:07 发布 · 78 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

刷题心得专栏收录该内容

41 篇文章

订阅专栏

这篇博客介绍了如何使用回溯和动态规划两种算法解决LeetCode上的数组目标和问题。首先展示了一个回溯法的实现，虽然时间效率较低但思路清晰。接着优化为动态规划，大幅提高了执行速度，并进一步压缩空间复杂度。每种方法都包含了详细的代码解释和执行效率分析。

题目链接：leetcode.

回溯

/*
执行用时：1660 ms, 在所有 C++ 提交中击败了9.53%的用户
内存消耗：8.6 MB, 在所有 C++ 提交中击败了98.33%的用户
*/ 
class Solution {
	int ans; 
	
	void dfs(const vector<int>& nums, int index, int sum, int target)
	{
		if(index >= nums.size())
		{
            if(sum == target)
			    ans++;
			return;
		}
        dfs(nums, index + 1, sum + nums[index], target);
        dfs(nums, index + 1, sum - nums[index], target);
	}
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        ans = 0;
        dfs(nums, 0, 0, target);
        return ans;
    }
};

动态规划，算出数组总和为sum，设那些前面为-的数之和为neg，则前面为+的数之和为sum-neg
则 （sum - neg）- neg = target，算得neg = （sum - target）/ 2
neg一定为整数，所以可以先判断 sum - target的奇偶性
原题变为找出nums 中和为neg的方案数，背包问题 dp[i][j]表示前i个数里和为j的方案
初始dp[0][0] = 1

/*
执行用时：16 ms, 在所有 C++ 提交中击败了65.72%的用户
内存消耗：11.9 MB, 在所有 C++ 提交中击败了30.72%的用户
*/
class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int N = nums.size();
        int sum = 0;
        for(int i = 0;i < N;++i)
        {
        	sum += nums[i];
        }
        if(sum < target || (sum - target) % 2 != 0)//sum要大于target 
        	return 0;
        int neg = (sum - target) / 2;
        vector<vector<int>> dp(N + 1, vector<int>(neg + 1, 0));
        dp[0][0] = 1;
        for(int i = 1;i <= N;++i)
        {
        	for(int j = 0;j <= neg;++j)
        	{
        		if(j < nums[i - 1])
        		{
        			dp[i][j] = dp[i - 1][j];
        		}
        		else
        		{
        			dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i - 1]];
        		}
        	}
        }
        return dp[N][neg];
    }
};

优化空间

/*
执行用时：12 ms, 在所有 C++ 提交中击败了77.36%的用户
内存消耗：8.9 MB, 在所有 C++ 提交中击败了65.00%的用户
*/
class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int N = nums.size();
        int sum = 0;
        for(int i = 0;i < N;++i)
        {
        	sum += nums[i];
        }
        if(sum < target || (sum - target) % 2 != 0)//sum要大于target 
        	return 0;
        int neg = (sum - target) / 2;
        vector<int> dp(neg + 1, 0);
        dp[0] = 1;
        for(int i = 1;i <= N;++i)
        {
        	for(int j = neg;j >= 0;--j)
        	{
        		if(j >= nums[i - 1])
        		{
        			dp[j] += dp[j - nums[i - 1]];
        		}
        	}
        }
        return dp[neg];
    }
};