题意
给定一个数组,现在可以在这个数组的每个数之前添加+或者-,求和为S的所有方案数(数组内数不能交换顺序)
思路
算法1
其实,每个数之前添加+或者-,就相当于这个数是选正数还是负数,就一01背包。
状态表示: d[i][j] ,选过第i个数后,和为j的方案数。
转移方程: d[i][j]=d[i−1][j−ai]+d[i−1][j+ai] 。分别表示当前数前面是添+还是-,并且还要注意j可能为负数,因此要加一个偏移量ofs 。
时间复杂度: O(n2)
空间复杂度: O(mn) (可以优化到 O(m) )
算法2
在Solution里面看到一个很好的算法。
转化问题
我们是在一些数前面添加+,一些数前面添加-。我们把添加+的数记为集合P,添加-的数记为集合N。
比如{1, 2, 3, 4, 5}, target = 3。如果我们这么添加:+1 - 2 + 3 - 4 + 5 = 3。则P = {1, 3, 5}, N = {2, 4}。
那么,我们可以得到如下公式:
(1)sum(P)−sum(N)=target
(2)sum(P)+sum(N)=sum
(1)+(2)
得到:
2sum(P)=target+sum
所以,我们的问题就转化成了:在nums[]
找一个子集P,使P的和为
targt+sum2
。
求子集
那么现在问题可以这么描述:我们有一个数组nums,我们需要求解能够组合集合P的方案数,使P的和为
S(S=targt+sum2)
。
就0 - 1背包
状态表示:
d[i,j]
,前i个数的和为j的方案数。
转移就分为第i个数是否加入我们的集合P。
转移方程:
d[i,j]=d[i−1,j]+d[i−1,j−ai]
注意
注意我们边界情况的初始化,即第一个点的取指。可以分别在第一个值为0和非0的时候讨论一下,可以发现直接初始化d[0][0] = 1是正确的。
细节
- 在算法1中,注意这道题有个坑点就是:第一个数为0的时候,其实有两种方案+0和-0,但是我们代码写的是 d[0][0]=1 ,因此,设置一个flag,第一个为0的时候我们的结果应该x2。并且后续若为0不用x2。
- 在算法2中,滚动数组优化空间。
代码
algorithm 1
const int maxn = 25;
const int maxm = 5005;
#define ofs 2003
int d[maxn][maxm];
class Solution {
public:
int findTargetSumWays(vector<int>& nums, int S) {
if (S > 1000) return 0;
bool flag = !(nums[0]);
memset(d, 0, sizeof(d));
d[0][nums[0] + ofs] = d[0][-nums[0] + ofs] = 1;
for (int i = 1; i < nums.size(); i++) {
for (int j = -1000; j <= S + 1000; j++) {
d[i][j + ofs] = d[i - 1][j - nums[i] + ofs] + d[i - 1][j + nums[i] + ofs];
}
}
return flag == true ? d[nums.size() - 1][S + ofs] * 2 : d[nums.size() - 1][S + ofs];
}
};
algorithm 2
class Solution {
public:
int findSubsetNum(vector<int>& a, int S) {
vector<int> d(S + 1, 0);
d[0] = 1;
for (int i = 0; i < a.size(); i++) {
for (int j = S; j >= a[i]; j--) {
d[j] += d[j - a[i]];
}
}
return d[S];
}
int findTargetSumWays(vector<int>& nums, int S) {
int sum = accumulate(nums.begin(), nums.end(), 0);
return (sum + S) & 1 || (sum < S) ? 0 : findSubsetNum(nums, (sum + S) >> 1);
}
};