leetcode 494. 目标和 三种方法 暴力递归 缓存 优化算法

package leetcode;

import java.util.HashMap;

/**
 * 494. 目标和
 * 给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。
 * <p>
 * 返回可以使最终数组和为目标数 S 的所有添加符号的方法数。
 * <p>
 * <p>
 * <p>
 * 示例：
 * <p>
 * 输入：nums: [1, 1, 1, 1, 1], S: 3
 * 输出：5
 * 解释：
 * <p>
 * -1+1+1+1+1 = 3
 * +1-1+1+1+1 = 3
 * +1+1-1+1+1 = 3
 * +1+1+1-1+1 = 3
 * +1+1+1+1-1 = 3
 * <p>
 * 一共有5种方法让最终目标和为3。
 * <p>
 * <p>
 * 提示：
 * <p>
 * 数组非空，且长度不会超过 20 。
 * 初始的数组的和不会超过 1000 。
 * 保证返回的最终结果能被 32 位整数存下。
 * 通过次数78,831提交次数173,819
 */
public class findTargetSumWays {
    public static void main(String[] args) {
        int[] nums = new int[]{1, 1, 1, 1, 1};
        System.out.println(findTargetSumWays(nums, 3));
    }

    public static int findTargetSumWays(int[] nums, int target) {
        return process3(nums, target);
    }

    private static int process(int[] nums, int start, int rest) {
        //没有数字了
        if (start == nums.length) {
            return rest == 0 ? 1 : 0;
        }
        return process(nums, start + 1, rest + nums[start]) + process(nums, start + 1, rest - nums[start]);
    }

    private static int process2(int[] nums, int index, int rest, HashMap<Integer, HashMap<Integer, Integer>> dp) {
        //如果之前的值存在，那么直接取值
        if (dp.containsKey(index) && dp.get(index).containsKey(rest)) {
            return dp.get(index).get(rest);
        }
        int ans = 0;
        //传入索引等于数组长度 就是没有数了。如果正好算完相等 返回1中方法
        if (index == nums.length) {
            ans = rest == 0 ? 1 : 0;
        } else {
            //如果还要继续计算下去 则继续递归
            ans = process2(nums, index + 1, rest + nums[index], dp) + process2(nums, index + 1, rest - nums[index], dp);
        }
        if (!dp.containsKey(index)) {
            dp.put(index, new HashMap<>());
        }
        //放入缓存
        dp.get(index).put(rest, ans);
        return ans;
    }

    private static int process3(int[] nums, int target) {
        //计算数组和
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        //如果目标大于整个数组的和，返回0  目标与数组和奇偶性不同，那么也返回0 否则再进行计算
        return sum < target || ((target & 1) ^ (sum & 1)) != 0 ? 0 : subSet(nums, (target + sum) >> 1);
    }
    //添加缓存数组
    private static int subSet(int[] nums, int s) {
        int[] dp = new int[s + 1];
        dp[0] = 1;
        for (int num : nums) {
            //从s开始到num结束填充数组中的值。
            for (int i = s; i >= num; i--) {
                dp[i] += dp[i - num];
            }
        }
        return dp[s];
    }
}