代码随想录Day36：动态规划（最后一块石头的重量 II、目标和、一和零）

​

package org.example.DP;

public class lastStoneWeightII1049 {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;//计算数组中所有相加总和
        for (int i : stones) {
            sum += i;
        }

        int target = sum / 2;//最终目标值
        int[] dp = new int[target + 1];//其实可以直接15000+1，但是用target能节省更多的空间
        for (int i = 0; i < stones.length; i++)//外层物品
            for (int j = target; j >= stones[i]; j--)//内层倒序+重量,有位置放，位置不够无需处理
            {
                //两种情况，要么放，要么不放
                dp[j] = Math.max(
                        dp[j],
                        dp[j - stones[i]] + stones[i]
                );
            }

        return sum-2*dp[target];
    }
}

494目标和

494. 目标和 - 力扣（LeetCode）

本题要如何使表达式结果为target，将数组分为两个集合，正数集合left，减数集合right，一定有 left组合 - right组合 = target。left + right = sum，而sum是固定的。right = sum - left

left - (sum - left) = target 推导出 left = (target + sum)/2 。target是固定的，sum是固定的，left就可以求出来。此时问题就是在集合nums中找出和为left的组合。如果(target + sum)/2不是偶数，也就是(target + sum) % 2为1的情况，则找不到答案。

1. dp数组含义。

这里dp[j]表示容量为j的背包，装满的方法最大有几种。注意不是最大价值，是方法的数量！！

2. 确定递推公式

二维DP数组递推公式： dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];（dp[i][j]：使用 下标为[0, i]的nums[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种方法。）

去掉维度i 之后，递推公式：dp[j] = dp[j] + dp[j - nums[i]] ，即：dp[j] += dp[j - nums[i]]

这个公式在后面在讲解背包解决排列组合问题的时候还会用到！

3. dp数组如何初始化

这里dp[0]初始为1 ,即装满背包为0的方法有一种，放0件物品。如果设置为0，在递推公式累加的情况下一直为0，再结合具体情况，所以初始为1。

#4. 确定遍历顺序

在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new window)中系统讲过对于01背包问题一维dp的遍历。遍历物品放在外循环，遍历背包在内循环，且内循环倒序（为了保证物品只使用一次）。

#5. 举例推导dp数组

输入：nums: [1, 1, 1, 1, 1], target: 3

bagSize = (target + sum) / 2 = (3 + 5) / 2 = 4

dp数组状态变化如下：

拓展
关于一维dp数组的递推公式解释，也可以从以下维度来理解。（但还是从二维DP数组到一维DP数组这样更容易理解一些）

只要搞到nums[i]，凑成dp[j]就有dp[j - nums[i]] 种方法。

例如：dp[j]，j 为5，

已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 容量为5的背包。
已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 容量为5的背包。
已经有一个3（nums[i]） 的话，有 dp[2]种方法 凑成 容量为5的背包
已经有一个4（nums[i]） 的话，有 dp[1]种方法 凑成 容量为5的背包
已经有一个5 （nums[i]）的话，有 dp[0]种方法 凑成 容量为5的背包
那么凑整dp[5]有多少方法呢，也就是把 所有的 dp[j - nums[i]] 累加起来。

所以求组合类问题的公式，都是类似这种：

dp[j] += dp[j - nums[i]]

package org.example.DP;

public class findTargetSumWays494 {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;//计算数组中所有相加总和
        for (int i : nums) {
            sum += i;
        }

        //如果target的绝对值大于sum，那么是没有方案的
        if (Math.abs(target) > sum) return 0;
        //如果(target+sum)除以2的余数不为0，也是没有方案的
        if ((target + sum) % 2 == 1) return 0;

        int bag=(target + sum)/2;
        int[] dp=new int[bag+1];
        dp[0]=1;

        for(int i=0;i<nums.length;i++)
        {
            for(int j=bag;j>=nums[i];j--)
            {
                dp[j]+=dp[j-nums[i]];
            }
        }

        return dp[bag];
    }
}

package org.example.DP;

public class findMaxForm474 {
    public int findMaxForm(String[] strs, int m, int n) {
        //dp[i][j]表示i个0和j个1时的最大子集,也就是最大个数
        int[][] dp = new int[m + 1][n + 1];
        int oneNum, zeroNum;

        for (String str : strs) {
            oneNum = 0;
            zeroNum = 0;
            //统计每个中0和1的个数
            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);
                }
            }
        }
        return dp[m][n];
    }

}