Leetcode 494 - Target Sum（01背包）

题意

给定一个数组，现在可以在这个数组的每个数之前添加+或者-，求和为S的所有方案数（数组内数不能交换顺序）

思路

算法1

其实，每个数之前添加+或者-，就相当于这个数是选正数还是负数，就一01背包。

状态表示：$d[i][j]$，选过第i个数后，和为j的方案数。

转移方程：$d[i][j] = d[i - 1][j - a_i] + d[i - 1][j + a_i]$。分别表示当前数前面是添+还是-，并且还要注意j可能为负数，因此要加一个偏移量ofs 。

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

空间复杂度：$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) \quad sum(P) - sum(N) = target$
$(2) \quad sum(P) + sum(N) = sum$
$(1) + (2)$得到：$2sum(P) = target + sum$
所以，我们的问题就转化成了：在nums[]找一个子集P，使P的和为$\frac{targt + sum }{2}$。

求子集

那么现在问题可以这么描述：我们有一个数组nums，我们需要求解能够组合集合P的方案数，使P的和为$S(S = \frac{targt + sum }{2})$。
就0 - 1背包
状态表示：$d[i, j]$，前i个数的和为j的方案数。
转移就分为第i个数是否加入我们的集合P。
转移方程：$d[i, j] = d[i - 1, j] + d[i - 1, j - a_i]$

注意

注意我们边界情况的初始化，即第一个点的取指。可以分别在第一个值为0和非0的时候讨论一下，可以发现直接初始化d[0][0] = 1是正确的。

细节

1. 在算法1中，注意这道题有个坑点就是：第一个数为0的时候，其实有两种方案+0和-0，但是我们代码写的是$d[0][0] = 1$，因此，设置一个flag，第一个为0的时候我们的结果应该x2。并且后续若为0不用x2。
2. 在算法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);
    }
};