一、题目
给你一个整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ,然后串联起所有整数,可以构造一个 表达式 :
例如,nums = [2, 1] ,可以在 2 之前添加 ‘+’ ,在 1 之前添加 ‘-’ ,然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
二、思路
1)回溯法
使用递归进行回溯,对于每个数都有+和-两种表达式,当数组所有元素都选择完毕,进行累加和的结果判断,等于target就使计数cnt自增1.
2)动态规划
设定所有元素正数和为
s
u
m
=
n
u
m
s
[
0
]
+
n
u
m
s
[
1
]
+
.
.
.
+
n
u
m
s
[
n
]
sum=nums[0]+nums[1]+...+nums[n]
sum=nums[0]+nums[1]+...+nums[n] 有在[0, n]区间的随机集合u,假定根据集合u{k1, k2,…,kx}作为下标,负数和为
n
e
g
=
−
∑
y
∈
u
n
u
m
s
[
y
]
=
−
n
u
m
s
[
k
1
]
−
n
u
m
s
[
k
2
]
−
.
.
.
−
n
u
m
s
[
k
x
]
neg=-\sum_{y\in{u}}{nums[y]}=-nums[k1]-nums[k2]-...-nums[kx]
neg=−y∈u∑nums[y]=−nums[k1]−nums[k2]−...−nums[kx] 除开负数集合的正数之和为sum+neg,那么可以得到:
t
a
g
e
t
=
s
u
m
+
n
e
g
+
n
e
g
=
s
u
m
+
2
∗
n
e
g
=
>
n
e
g
=
t
a
r
g
e
t
−
s
u
m
2
taget=sum+neg+neg=sum+2*neg~~~=>~~~neg=\frac{target-sum}{2}
taget=sum+neg+neg=sum+2∗neg => neg=2target−sum 从这个式子中可以得知,neg一定为2的倍数(编程中的neg其实为-neg),并且target-sum一定要小于0才有解。
根据上面的思路,只需要找到nums数组中有没有能挑选出来元素之和为-neg即可。(这就变成了01背包问题)
创建数组dp[i][j],代表前i个元素中和为j的方案数量,可以得到状态转移方程:
d
p
[
i
]
[
j
]
=
{
d
p
[
i
−
1
]
[
j
]
j
<
n
u
m
s
[
i
−
1
]
d
p
[
i
−
1
]
[
j
]
+
d
p
[
i
−
1
]
[
j
−
n
u
m
s
[
i
−
1
]
]
j
>
=
n
u
m
s
[
i
−
1
]
dp[i][j]= \left\{\begin{matrix} dp[i-1][j]&&j<nums[i-1]\\ dp[i-1][j]+dp[i-1][j-nums[i-1]]&&j>=nums[i-1] \end{matrix}\right.
dp[i][j]={dp[i−1][j]dp[i−1][j]+dp[i−1][j−nums[i−1]]j<nums[i−1]j>=nums[i−1]
计算最后结果dp[nums.length][neg]为所求解的值
三、代码
1)回溯法
class Solution {
public int findTargetSumWays(int[] nums, int target) {
return backtrace(nums, target, 0, 0);
}
private int backtrace(int[] nums, int target, int i, int sum) {
int cnt = 0;
if (i == nums.length) {
return sum == target ? 1 : 0;
}
cnt += backtrace(nums, target, i+1, sum + nums[i]);
cnt += backtrace(nums, target, i+1, sum - nums[i]);
return cnt;
}
}
时间复杂度为O(2),空间复杂度为O(nums.length)。
2)动态规划
class Solution {
public int findTargetSumWays(int[] nums, int target) {
int sum = 0;
for (int num : nums) {
sum += num;
}
int diff = sum - target; // 这里使用sum-target,求出来的diff就是理应为大于等于0的数
if (diff < 0 || (diff & 1) == 1) {
return 0;
}
int neg = diff/2; // 从而neg也表示的为负的负数和
int[][] dp = new int[nums.length+1][neg + 1];
dp[0][0] = 1;
for (int i = 1; i < dp.length; i++) {
for (int j = 0; j < dp[0].length; j++) {
dp[i][j] = dp[i-1][j];
if (j >= nums[i-1]) {
dp[i][j] += dp[i-1][j-nums[i-1]];
}
}
}
return dp[nums.length][neg];
}
}
时间复杂度为O(negnums.length),空间复杂度为O(negnums.length)。
3)动态规划优化
由于状态转移方程中,dp[i][j]只依赖i的状态,所以可以将二维数组压缩成一维,由于一维的情况
使用同一个一维数组,j<nums[i-1]情况的直接继承上一个状态的赋值可以省掉,节约了时间。(从高位向低遍历)
class Solution {
public int findTargetSumWays(int[] nums, int target) {
int sum = 0;
for (int num : nums) {
sum += num;
}
int diff = sum - target;
if (diff < 0 || (diff & 1) == 1) {
return 0;
}
int neg = diff/2;
int[] dp = new int[neg + 1];
dp[0] = 1;
for (int i = 0; i < nums.length; i++) {
for (int j = neg; j >= nums[i]; j--) { // 判断条件代表直接跳过j<nums[i]的部分,继承上一状态
dp[j] += dp[j-nums[i]];
}
}
return dp[neg];
}
}
时间复杂度为O(neg*nums.length),空间复杂度为O(neg)。