Java算法(四)：力扣：目标和、一和零、零钱兑换Ⅱ、组合总和Ⅳ、爬楼梯进阶

动态规划解决完全背包问题

1.目标和

本题可看为 01背包问题的变式：给定背包容量，求装满背包的方法有多少种。
(图出处：Bilibili @代码随想录)：

/*
        给你一个非负整数数组 nums 和一个整数 target 。
        向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

        例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。
        返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
     */

    public static void main(String[] args) {
        findTargetSumWays(new int[]{1, 1, 1, 1, 1}, 3);
        findTargetSumWays(new int[]{1}, 1);
    }

    public static int findTargetSumWays(int[] nums, int target) {
        //1.dp数组含义：装满容量为j的背包有dp[j]种方法

        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if(target < 0  && sum < -target)  return 0; //target过大，sum无法满足
        if((sum + target) % 2 != 0) return 0; //不存在满足条件的正数（负数）集合
        int size = (target + sum) / 2;

        int[] dp = new int[size + 1]; //3.dp数组初始化
        dp[0] = 1;

        for (int i = 0; i < nums.length; i++) { //4.遍历顺序：1）物品
            for (int j = size; j >= nums[i]; j--) { // 2）倒序背包（容量）
                dp[j] += dp[j - nums[i]]; //2.递推公式
            }
        }
        System.out.println(dp[size]);
        return dp[size];
    }

2.一和零

本题可看为 二维的01背包问题的变式：求装满背包（背包的容量是m个0，n个1）最多有多少个物品（物品的重量是x个0，y个1）

/*
        给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
        请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。
        如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。
     */
    public static void main(String[] args) {
        findMaxForm(new String[]{"10", "0001", "111001", "1", "0"}, 5, 3);
        findMaxForm(new String[]{"10", "0", "1"}, 1, 1);
    }

    public static int findMaxForm(String[] strs, int m, int n) {
        //1.dp[i][j]含义：装满i个0，j个1的背包，最多可以装dp[i][j]个物品

        int[][] dp = new int[m + 1][n + 1]; //3.dp数组初始化

        for (String str : strs) { //4.遍历顺序：先物品
            int oneNum = 0;
            int zeroNum = 0;
            for (char ch : str.toCharArray()) { //将字符串转化为字符数组再遍历
                if (ch == '0') zeroNum++;
                else oneNum++;
            }
            for (int i = m; i >= zeroNum; i--) { //再背包容量
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1); //2.递推公式
                }
            }
        }

        System.out.println(dp[m][n]);
        return dp[m][n];
    }

3.零钱兑换Ⅱ

本题类似为第1题的 “目标和” ，不过本题是完全背包的模型。先遍历物品，再遍历背包，求的是组合数。

/*
        给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。
        请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

        假设每一种面额的硬币有无限个。
        题目数据保证结果符合 32 位带符号整数。
     */
    public static void main(String[] args) {
        change(5, new int[]{1, 2, 5});
        change(3, new int[]{2});
        change(10, new int[]{10});
    }

    public static int change(int amount, int[] coins) {
        //1.dp[j]含义：装满容量为j的背包有多少种方法

        int[] dp = new int[amount + 1]; //3.dp数组初始化
        dp[0] = 1; //金额为0时只有一种情况，就是什么也不装。

        for (int i = 0; i < coins.length; i++) { //4.遍历顺序
            for (int j = coins[i]; j <= amount; j++) {
                dp[j] += dp[j - coins[i]]; /* 2.递推公式 */
            }
        }
        System.out.println(dp[amount]);
        return dp[amount];
    }

4.组合综合Ⅳ

本题很像上一题零钱兑换Ⅱ，区别是本题先遍历背包，在遍历物品，求的是排列数。

/*
        给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。
        题目数据保证答案符合 32 位整数范围。
     */

    public static void main(String[] args) {
        combinationSum4(new int[]{1, 2, 3}, 4);
        combinationSum4(new int[]{9}, 3);
    }

    public static int combinationSum4(int[] nums, int target) {
        //1.dp[i]含义：装满容量为i的背包有多少种方法

        int[] dp = new int[target + 1]; //3.dp数组初始化
        dp[0] = 1;

        for (int i = 0; i <= target; i++) { /* 4.注意是先遍历背包，再遍历物品 */
            for (int j = 0; j < nums.length; j++) {
                if(i >= nums[j]) { //确定背包还能放下物品
                    dp[i] += dp[i - nums[j]]; // 2.递推公式
                }
            }
        }
        System.out.println(dp[target]);
        return dp[target];

    }

5.爬楼梯进阶

本题可以看成一道求排列数的完全背包问题。
本题代码与上题组合总和Ⅳ代码几乎完全一致。

/*
        假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
        每次你可以爬至多m (1 <= m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢？
        注意：给定 n 是一个正整数。

        输入共一行，包含两个正整数，分别表示n, m。
        输出一个整数，表示爬到楼顶的方法数。
     */
    public static void main(String[] args) {
        climbStairsPlus(3, 2);
    }

    public static int climbStairsPlus(int n, int m) {
    //初始化一个包含 1到m 所有数的数组，代表每次可以爬至多m个台阶：
        int[] mArry = new int[m];
        for (int i = 1; i <= m; i++) {
            mArry[i - 1] = i;
        }

        //1.dp[i]含义：装满容量为i的背包有多少种方法

        int[] dp = new int[n + 1]; //3.dp数组初始化
        dp[0] = 1;

        for (int i = 0; i <= n; i++) { /* 4.注意是先遍历背包，再遍历物品 */
            for (int j = 0; j < mArry.length; j++) {
                if(i >= mArry[j]) { //确定背包还能放下物品
                    dp[i] += dp[i - mArry[j]]; // 2.递推公式
                }
            }
        }
        System.out.println(dp[n]);
        return dp[n];
    }