动态规划方法论

动态规划，英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。

所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的，
动规和递归的区别是动规不是暴力的，产生的中间结果用数组记录起来，比较高效，详情可以看文章：

教你入门动态规划

动态规划的解题步骤：

确定dp数组（dp table）以及下标的含义
确定递推公式
dp数组如何初始化
确定遍历顺序
举例推导dp数组（当出现问题时用此方法调试）

个人觉得最难理解的就是遍历顺序，甚至比确定递推公式还难，如果迷糊了可以手写dp数组来理解，请注意一维和二维还是有点不一样的，可以都试试。

简单示例：

70. 爬楼梯

class Solution {
    public int climbStairs(int n) {
        if(n<=2){
            return n;
        }
        int[] count = new int[n+1]; // 1.dp[i]： 爬到第i层楼梯，有dp[i]种方法
        count[1] = 1;
        count[2] = 2;
        for(int i=3;i<=n;i++){
            count[i] = count[i-1]+count[i-2]; // 2.dp[i] = dp[i - 1] + dp[i - 2] 
        }
        return count[n];
    }
}

背包问题

在这里插入图片描述

01背包

有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。
01背包和完全背包的区别就是物品只能放一次
例如：

物品为：
物品重量价值
物品0 1 15
物品1 3 20
物品2 4 30
问背包能背的物品最大价值是多少？

二维dp数组

dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])

含义是：
遍历到物品i的时候，背包容量为j的最大价值分为放i和不放i两种情况 dp[i-1][j]为不放i，dp[i - 1][j - weight[i]] + value[i])为放i
遍历顺序都可以，可以先遍历背包再遍历物品，也可以先遍历物品再遍历背包。因为根据递推公式，求当前dp值是用的上一行的元素或者左上的元素，因此从左到右和从上到下两种方式均可。

初始化：要初始化第一行，因为递推公式有i-1。

推导dp数组
在这里插入图片描述

// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
    for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];
        else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

    }
}

一维dp数组

从二维dp数组可知，确定当前dp值只需要上面或者左上的元素，那么可以使用滚动数组的方式，只使用一个一维数组。

在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。
递推公式：dp[j]是不选后面那个是选，对应二维的上面的元素和左上的元素

dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

无需初始化
遍历顺序：跟二维不一样，先遍历物品，再方向遍历背包。反向是避免覆盖，因为如果左面的dp值更新了以后，对应二维情况是同一行左面的值，而不是上一行最面的值，会重复选取，需要重复选取的完全背包才可以正向遍历
打印dp数组

在这里插入图片描述

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

PS：之前一直认为，为什么一维情况可以直接从右向左遍历呢，右边的dp[j]难道不需要左边的值吗，后来发现确实不需要，只需要上一行同列的值和上一行左边的值，可以打印数组进行尝试理解，注意是01背包，物品只能放进去一次。

背包问题在题目中并不明显，需要自己抽象出题目的特点来：

416. 分割等和子集

给你一个只包含正整数的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

乍一看看不出来是个背包问题，但是要想分割成等和子集，一定有两部分的和要相等的，而且两部分的和为sum的一半，所以可以往容量为 sum/2的背包里装物品，看看能不能装满：

class Solution {
    public boolean canPartition(int[] nums) {
    // 背包问题的解决公式：二维 dp[i][j] = dp[i-1][j]+dp[i-1][j-nums[i]]+nums[i]
        // 一维：dp[j] = dp[j]+dp[j-nums[i]]+nums[i]
        // 1.确定dp数组和下标的含义
        // 2.确定递推公式
        // 3.确定初始化方式
        // 4.确定遍历顺序 打印验证
        int sum = 0;
        for(int i=0;i<nums.length;i++){
            
            sum+=nums[i];
        }
       
        if(sum%2!=0){
            return false;
        }
         int half = sum/2;

         int[] dp = new int[half+1];
        for(int i=1;i<nums.length;i++){
            for(int j=half;j>0;j--){
                if(j>=nums[i])
                dp[j] = Math.max(dp[j],dp[j-nums[i]]+nums[i]);
            }
        }
        if(dp[half] == half){
            return true;
        } else {
            return false;
        }

    }
}

01背包组合问题

如果让你求的是一个组合的情况怎么办，比如：

494. 目标和

给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个表达式：

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

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 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
+1 + 1 + 1 + 1 - 1 = 3

首先你得看出来这个题可以转化为背包问题：
假设加法的总和为x，那么减法对应的总和就是sum - x。所以我们要求的是 x - (sum - x) = target -> x = (target + sum) / 2
此时问题就转化为，装满容量为x的背包，有几种方法

这次是让求满足要求的组合数，使用一维dp数组解决：

dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法
dp[j] += dp[j - nums[i]]
本题我们应该初始化 dp[0] 为 1
先遍历物品，再倒序遍历背包
打印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[j] += dp[j - nums[i]]是之前本列的所有值，加上现在的dp[j - nums[i]，因为每次都加上了之前的dp[j]
比如之前只有物品1，容量j dp[j],现在多了物品2，那么所有情况就是 dp[j] = 之前只用物品1填满的 + 放入物品2后的，也就是dp[j] =dpj+dp[j - nums[i]]

组合问题记得初始化 dp[0] 因为跟计算价值不一样，如果dp[0]没有值，那么后面的数也都没有值

class Solution {
    // 背包问题求组合型
    // 设 x是正数部分，sum-x是负数部分 2x-sum = target ;  x = (target+sum)/2
    // 递推公式： dp[j]+=dp[j-nums[i]]
    // 怎么装能 装满x，有几种方法
    public int findTargetSumWays(int[] nums, int target) {
        if(nums == null || nums.length == 0 ){
            return 0;
        }
        int sum =0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
        }
        // 如果正数部分向下取整了，那就不可能，因为正数部分不可能是小数
        if((target+sum)%2 ==1){
            return 0;
        }
        int x = (target+sum)/2;
        // 如果总和的绝对值都比不过目标值，那就不可能
        if(Math.abs(sum) < Math.abs(target)){
            return 0;
        }
        // 装满容量为x的背包，有多少种方法
        int[] dp = new int[x+1];  
        dp[0] =1 ;
        for(int i=0;i<nums.length;i++){
            for(int j=x;j>=nums[i];j--){
                dp[j]+=dp[j-nums[i]];
            }   
        }
        return dp[x];

    }
}

01背包二维物品

有的时候物品维度有可能是二维的：

474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。

示例 1：

输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。
其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

主要是要想到本题用二维数组分别放 m和n的容量，那么循环就要循环三次，先物品，再倒叙循环两个背包：必须倒序，因为这个二维数组没有物品这个纬度，和之前的一维数组一样。

class Solution {
    // 还是01背包，物品是二维的，所以要用二维循环来遍历物品
    public int findMaxForm(String[] strs, int m, int n) {
      if(strs == null || strs.length == 0){
          return 0;
      }
      int[][] dp = new int[m+1][n+1];  // 最多放m个0，n个1，能最多放的子集数
      for(String s:strs){ // 遍历物品
            int oneCount = 0;
            int zeroCount = 0;
            for(char c:s.toCharArray()){
                if(c == '0'){
                    zeroCount++;
                } else {
                    oneCount++;
                }
            }
            for(int i=m;i>=zeroCount;i--){
                for(int j=n;j>=oneCount;j--){
                    dp[i][j] = Math.max(dp[i][j],dp[i-zeroCount][j-oneCount]+1);
                }
            }
      }
      return dp[m][n];
    }

}

完全背包

完全背包和01背包的区别就是一个物品可以装多次，和01背包的区别就是遍历背包的时候不是逆序而是正序：

// 先遍历物品，再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

正序遍历意味着使用的是本个物品已经更新过的dp值了，所以有添加多次的效果。

完全背包组合问题

518. 零钱兑换 II

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

示例 1：

输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1

这里是引用

5=2+1+1+1
5=1+1+1+1+1

递推公式和01背包组合问题一样，只是背包要正序遍历了：

class Solution {
    // 完全背包的组合问题
    public int change(int amount, int[] coins) {
        if(coins == null || coins.length == 0){
            return 0;
        }
        int[] dp = new int[amount+1];    // 有几种方式可以凑总金额为数组下标值的
        dp[0] = 1;
        for(int i=0;i<coins.length;i++){
            for(int j=coins[i];j<=amount;j++){
                     dp[j]+=dp[j-coins[i]];
              }
       }
       return dp[amount];
    }
}

完全背包排列问题

377. 组合总和 Ⅳ

给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

示例 1：

输入：nums = [1,2,3], target = 4
输出：7
解释：
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。

排列问题和组合问题的递推公式相同，只是遍历顺序相反，需要先遍历背包再遍历物品

class Solution {
    public int combinationSum4(int[] nums, int target) {
        // 完全背包排列问题
    if(nums ==null){
    return 0;
    }
    int[] dp = new int[target+1];
    dp[0] = 1;
    for(int j=1;j<=target;j++){
        for(int i=0;i<nums.length;i++){
            if(j>=nums[i])
            dp[j]+=dp[j-nums[i]];
        }
    }
    return dp[target];
    }
}

完全背包求最小值

322. 零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1

求最小值提醒要注意的就是初始化，初始化的时候要把dp数组设置成int的最大值，但是dp[0]要为0，要不结果就全是最大值了

class Solution {
    public int coinChange(int[] coins, int amount) {
    if(coins ==null){   
    return 0;
    }
    int[] dp = new int[amount+1];  // 装满amount容量所需最少的硬币数
    for(int i=1;i<dp.length;i++){
        dp[i] = Integer.MAX_VALUE-1;
    }
    for(int i=0;i<coins.length;i++){
        for(int j=coins[i];j<=amount;j++){
               dp[j] = Math.min(dp[j],dp[j-coins[i]]+1);
        }
    }
    return dp[amount] == Integer.MAX_VALUE-1? -1:dp[amount];   // 没找到返回-1
    }
}

完全背包布尔型

139. 单词拆分

单词拆分
给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

示例 1：

输入: s = “leetcode”, wordDict = [“leet”, “code”]
输出: true
解释: 返回 true 因为 “leetcode” 可以由 “leet” 和 “code” 拼接成。

这道题目也不完全是完全背包类型，因为遍历物品并不是遍历的字符数组，而是遍历字符串s的一部分

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
         // 类似于完全背包排列问题 boolean型 背包是s，物品是数组
        boolean[] dp = new boolean[s.length()+1]; // 字符串长度为i时，判断可不可以由词典组成
        HashSet<String> set = new HashSet<>(wordDict);
        dp[0] = true; // 0这里视为空字符 不是第一个字符，因为要保留dp[0] 为true才有后面的值
        for(int j=1;j<=s.length();j++){    // 背包
            for(int i=0;i<j && !dp[j];i++){    // 物品
             // substring是左闭右开型的    
             // 注意dp[i]这个i延后了一位，代表的是 0到i-1位能不能被词典组成，s.substring(i,j)代表i到j-1位能不能被组成，如果都可以那么这个长度为j的字符（0到j-1位都满足），就满足了
                if(set.contains(s.substring(i,j)) && dp[i]){
                    dp[j] = true;
                }
            }
        }
        return dp[s.length()];
    }
}