题目
给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。返回可以使最终数组和为目标数 S 的所有添加符号的方法数。来自leetcode494，题目链接点击这里 。
例子
思路1、dfs（递归）
首先给的数组里面的数一定要使用，因此自然而然想到了：dfs，也就是枚举每一种可能性，一直枚举到最后一层。这种想法的示意图如下：
其实类似于一个二叉树，我们要求的其实就是这个二叉树里面的从根节点root到叶子节点的所有路径里面，路径和符合要求的有几条。代码如下：
public int findTargetSumWays(int[] nums, int S) {
if(nums==null||nums.length<1)
return -1;
return process(nums,0,S,S);
}
public int process(int[] nums,int index,int target,int sum){
if(index==nums.length){//到了最后一层
return sum==target?1:0;
}
return process(nums,index+1,target,sum+nums[index])+process(nums,index+1,target,sum-nums[index]);
}
可以计算一下时间复杂度，因为数组里面每个元素都有两种情况，因此总的时间复杂度为O（2^N），N为数组元素个数。
但是这种方法比较慢，OJ里面需要600ms，太慢了。
思路2、记忆化搜索
对暴力递归进行第一步优化，首先思考一下为什么暴力递归的速度这么慢？很简单，因为重复计算了很多子问题，只要process方法里面的index确定，sum确定，那么返回的方法数就是一定的；而原来的递归里面，即使浅层递归的index和sum确定了，依然往深层继续递归计算，但是这是不必要的计算，因此我们可以把这个结果保存下来。
也就是说只要遇到相同的index和sum，那么直接就可以返回之前保存的方法数。实现的方法就是保存在一个hashmap里面，key为index+sum字符串，value就是对应的方法数。这种优化方式一般叫做：“记忆化搜索”，优化代码如下：
HashMap<String, Integer> memo = new HashMap<>();
public int findTargetSumWays2(int[] nums, int S) {
if(nums==null||nums.length<1)
return -1;
return process2(nums,0,S,0);
}
public int process2(int[] nums,int index,int target,int sum){
if(index==nums.length){//到了最后一层
return sum==target?1:0;
}
String key=index+","+sum;
if(memo.containsKey(key))
return memo.get(key);//查询之前有没有保存过，如果有直接返回之前保存的方法数
else{
int res=process2(nums,index+1,target,sum+nums[index])+process2(nums,index+1,target,sum-nums[index]);
memo.put(key,res);
return res;
}
}
使用记忆化搜索可以显著提升速度，但是还可以进一步优化，那就是动态规划。
思路3、动态规划
首先，我们可以根据上面的暴力递归把状态传递方程给写出来：
dp[i][j]=dp[i+1][j-nums[i]]+dp[i+1][j+nums[i]]
这里的i就是index，这里的j就是sum，其实就是根据上面的process函数写的。
然后，我们可以先举个例子，来尝试画个表，看看动态规划的结果对不对，这里我们设置输入的数组为：[1,1,1,1],也就是index=4，累加和为-4~4（如-1-1-1-1=-4）。因此我们可以画出下面的二维表：
注意，这里index一共为5行，0~3表示数组有4个数，最后一行是因为之前的递归process方法里面，index必须要到nums.length才能结束：
index==nums.length;
所以表格一共的层数为：数组元素个数+1个。
可以发现，最后，（0,0）位置就是我们要求的，他的值为4，是对的。代码如下：
//二维dp
public int findTargetSumWays(int[] nums, int S) {
if(nums==null||nums.length<1)
return -1;
int row=nums.length+1;
int sum=0;
for(int num:nums)
sum+=num;
if(sum<S)
return 0;
int col=2*sum+1;
int[][] dp=new int[row][col];
dp[row-1][sum+S]=1;//初始化
for(int i=row-2;i>=0;i--){
for(int j=0;j<=col-1;j++){
//注意边界问题,超过了边界就取第一列
int l=j-nums[i]>=0?j-nums[i]:0;
int r=j+nums[i]<col?j+nums[i]:0;
dp[i][j]=dp[i+1][l]+dp[i+1][r];
}
}
return dp[0][sum];
}
时间复杂度为:O(M*N)，M表示多少个数，N表示2倍的数组累加和。相比之前的暴力递归下降了很多。至于这里的边界问题，我的意思就是如果数组下标超了，那么数组元素就是用0来代替，刚好第0列都是0，那就直接换成第0列吧。
思路4、继续优化成1维dp数组
通过上面的表格可以发现，每一行的新元素只和下面一行的旧元素有关，因此我们可以只用一维数组解决。但是因为旧元素的列一个在左，一个在右，因此需要两个一维dp数组才行（因为不管从哪个方向更新，左右两个旧元素都会被有一个被“刷新”）。因此，用一个dp数组保存旧的元素，另外一个dp数组保存新的元素。代码如下：
//一维dp
public int findTargetSumWays(int[] nums, int S) {
if(nums==null||nums.length<1)
return -1;
int row=nums.length+1;
int sum=0;
for(int num:nums)
sum+=num;
if(sum<S)
return 0;
int col=2*sum+1;
int[] dp=new int[col];
dp[sum+S]=1;//初始化
for(int i=row-2;i>=0;i--){
int[] next=new int[col];//新数组
for(int j=0;j<=col-1;j++){
//注意边界问题
int l=j-nums[i]>=0?j-nums[i]:0;
int r=j+nums[i]<col?j+nums[i]:0;
next[j]=dp[l]+dp[r];
}
dp=next;
}
return dp[sum];
}
时间复杂度和二维dp一样，但是空间复杂度又下降了。
总结
这个题是一个很典型的动态规划方向的题目，优化的套路就是，先暴力递归，然后发现有重复子问题，然后使用记忆化搜索进行优化，然后再利用动态规划降低时间复杂度，最后再使用一维动态规划降低空间复杂度。