动态规划笔记

第一轮面试准备到第26题

一  解题步骤

对于动态规划问题，我将拆解为如下五步曲，这五步都搞清楚了，才能说把动态规划真的掌握了！

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

二  基础题模板

递推公式，要站dp【i】的角度去想，想象dp【i】是由哪些前面的状态推倒而来的。

. - 力扣（LeetCode）

class Solution {
    public int fib(int n) {
        // 边界处理
        if(n <= 1){
            return n;
        }

        //1 确定数组含义
        // 下标是指第几个数
        // dp[i] 指第i个数对应的值

        //2 确定递推公式
        // dp[i] = dp[i - 1] + dp[i - 2]
        
        //3 初始dp数组
        int dp[] = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;

        //4 确定遍历顺序
        for(int i = 2; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];

    }
}

三  背包类型题目总览

01背包：每件物品只能用一次

完全背包：每件物品无限用

四  0-1背包题模板

1  二维dp数组模板

遍历顺序以及循环顺序无要求

46. 携带研究材料（第六期模拟笔试） (kamacoder.com)

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int bagweight = scanner.nextInt();

        int[] weight = new int[n];
        int[] value = new int[n];

        for (int i = 0; i < n; ++i) {
            weight[i] = scanner.nextInt();
        }
        for (int j = 0; j < n; ++j) {
            value[j] = scanner.nextInt();
        }

        int[][] dp = new int[n][bagweight + 1];

        for (int j = weight[0]; j <= bagweight; j++) {
            dp[0][j] = value[0];
        }

        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= bagweight; j++) {
                if (j < weight[i]) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
                }
            }
        }

        System.out.println(dp[n - 1][bagweight]);
    }
}

2  一维dp数组模板

两次循环时，必须先循环遍历物品。再倒序遍历空间

46. 携带研究材料（第六期模拟笔试） (kamacoder.com)

import java.util.*;

public class Main{

    public static void main (String[] args) {
        // 录取 M 代表研究材料的种类， N，代表小明的行李空间。
        Scanner input = new Scanner(System.in);
        int m = input.nextInt();
        int n = input.nextInt();

        //  M 个正整数，代表每种研究材料的所占空间。 
        int weight[] = new int[m];
        for(int i = 0; i < m; i++){
            weight[i] = input.nextInt();
        }
        //  M 个正整数，代表每种研究材料的价值。
        int value[] = new int[m];
        for(int i = 0; i < m; i++){
            value[i] = input.nextInt();
        }

        //初始化dp数组
        int dp[] =  new int[n + 1];
        for(int i = 0; i <= n; i++){
            dp[i] = 0;
        }

        for(int i = 0; i < m; i++){
            for(int j = n; j >= weight[i]; j--){
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }

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

3  是否能装满一定容量背包类型

416. 分割等和子集 - 力扣（LeetCode）

class Solution {
    public boolean canPartition(int[] nums) {
        if(nums == null || nums.length == 0){
            return false;
        }
        //遍历数组计算总结果
        int sum = 0;
        for(int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        //如果结果是奇数，那么无法分割
        if(sum % 2 != 0){
            return false;
        }
        int target = sum / 2;

        //初始dp数组
        int dp[][] = new int[nums.length][target + 1];
        //第一行
        for(int i = nums[0]; i <= target; i++){
            dp[0][i] = nums[0];
        }
        //第一列
        for(int j = 0; j < nums.length; j++){
            dp[j][0] = 0;
        }

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

/*
 //边界判断
        if(nums == null || nums.length == 0){
            return false;
        }
        //遍历数组计算总结果
        int sum = 0;
        for(int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        //如果结果是奇数，那么无法分割
        if(sum % 2 != 0){
            return false;
        }
        int target = sum / 2;

        //初始01背包
        //明确含义：dp[i] 代表 从0到i 的最大价值，也就是最大的和 i是第几个数，i也是数字i的重量
        int dp[] = new int[target + 1];
        for(int i = 0; i <= target; i++){
            dp[i] = 0;
        }

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

        return dp[target] == target;
        */

4  一定容量尽可能装满背包类型

1049. 最后一块石头的重量 II - 力扣（LeetCode）

class Solution {
    public int lastStoneWeightII(int[] stones) {
        //处理边界
        if(stones.length == 0 || stones == null){
            return 0;
        }

        int n = stones.length;

        //计算总和
        int sum = 0;
        for(int i = 0; i < n; i++){
            sum += stones[i];
        }

        //一半
        int target = sum / 2;

        //初始dp数组
        int dp[] = new int[target + 1];

        for(int i = 0; i < n; 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];
    }
}

5  装满背包有多少种方法类型

. - 力扣（LeetCode）

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        // 数组的和
        int sum = 0;
        for(int num : nums){
            sum += num;
        }

        // 背包容量
        // 求背包容量公式：int bagsize = (sum + target) / 2;
        // 要先判断是否有效
        if(Math.abs(target) > sum){
            return 0;
        }
        if((sum + target) % 2 != 0){
            return 0;
        }

        // 背包容量
        int bagsize = (sum + target) / 2;

        // 定义dp数组
        int dp[] = new int[bagsize + 1];
        dp[0] = 1;

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

        return dp[bagsize];

    }
}

6  两个维度装满背包类型

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        // 定义dp数组，两个维度
        int dp[][] = new int[m + 1][n + 1];
        int zeroCount = 0;
        int oneCount = 0;

        //遍历每一个元素
        for(String s : strs){
            zeroCount = 0;
            oneCount = 0;

            // 记录0和1的数量
            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];


    }
}

五  完全背包模板

52. 携带研究材料（第七期模拟笔试） (kamacoder.com)

和0-1背包模板区别：1  完全背包在两层遍历的时候，顺序没有要求

                                  2  第二层遍历，是顺序遍历不是倒叙遍历 

import java.util.*;

public class Main{
    
    public static void main (String[] args) {
        Scanner input = new Scanner(System.in);
        
        //种类和行李空间
        int n = input.nextInt();
        int v = input.nextInt();
        
        int value[] = new int[n];
        int weight[] = new int[n];
        
        // 记录种类和对应的空间
        for(int i = 0; i < n; i++){
            int wi = input.nextInt();
            int vi = input.nextInt();
            
            value[i] = vi;
            weight[i] = wi;
        }
        
        int dp[] = new int[v + 1];
        
        for(int i = 0; i < n; i++){
            for(int j = weight[i]; j <= v; j++){
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }
        
        System.out.println(dp[v]);
        
        
    }
}

1 求装满一定容量背包的组合数类型

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

518. 零钱兑换 II - 力扣（LeetCode）

class Solution {
    public int change(int amount, int[] coins) {

        // 记录数组的长度
        int len = coins.length;
        // 背包容量
        int bigSize = amount;

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

        for(int i = 0; i < coins.length; i++){
            for(int j = coins[i]; j <= bigSize; j++){
                dp[j] += dp[j - coins[i]];
            }
        }

        return dp[bigSize];



    }
}

2  求装满一定容量背包的排列数类型

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

如果把遍历nums（物品）放在外循环，遍历target的作为内循环的话，举一个例子：计算dp[4]的时候，结果集只有 {1,3} 这样的集合，不会有{3,1}这样的集合，因为nums遍历放在外层，3只能出现在1后面！

class Solution {
    public int combinationSum4(int[] nums, int target) {

        int len = nums.length;

        int dp[] = new int[target + 1];
        dp[0] = 1;

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

        return dp[target];



    }
}