第六章：动态规划

DEMO

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;
import java.util.Comparator;

/**
 * Comparator接口(比较器)的Java8 Lambda表达式写法
 */
public class demo {
    public static void main(String[] args) {
        // 一维数组
        Integer[] ints = new Integer[]{12, 4, 6, 7, 2, 8, 3, 9};// 按数字
        Arrays.sort(ints, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
//        Arrays.sort(ints, (o1, o2) -> o2 - o1);
        System.out.println(Arrays.toString(ints));

        // 二维数组
        int[][] people = {{7, 0}, {4, 4}, {7, 1}, {5, 0}, {6, 1}, {5, 2}};
        Arrays.sort(people, (o1, o2) -> o1[0] != o2[0] ? o2[0] - o1[0] : o1[1] - o2[1]);
        System.out.println(Arrays.deepToString(people));
    }
}

一、基本动态规划：一维

1、爬楼梯

问题：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

package LeetCode.test6_dongtaiguihua;

/**
 * 思路：第i阶可以从第i-1或i-2阶到达     dp[i] = dp[i-1] + dp[i-2]
 * 解释：到达第i阶 = （到达第i-2阶的方法数 + 2步）||（到达第i-1阶的方法数 + 1步）
 * -> 走到第i阶的方法数即为走到第i-1阶的方法数加上走到第i-2阶的方法数
 */
public class ques_70_爬楼梯 {
    public int climbStairs(int n) {
        if (n <= 2) {
            return n;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

class Test_70 {
    public static void main(String[] args) {
        int n = 3;
        ques_70_爬楼梯 s = new ques_70_爬楼梯();
        System.out.println(s.climbStairs(n));
    }
}

2、打家劫舍

问题：

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。偷窃到的最高金额 = 2 + 9 + 1 = 12 。

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

/**
 * 思路：dp[i] = max(dp[i-1],nums[i-1] + dp[i-2])
 * dp[i-1] -> 不抢    nums[i-1] + dp[i-2] -> 抢
 */
public class ques_198_打家劫舍 {
    public int rob(int[] nums) {
        if (nums.length == 0){
            return 0;
        }
        if (nums.length == 1){
            return nums[0];
        }
        int[] dp = new int[nums.length + 1];
        dp[1] = nums[0];
        dp[2] = Math.max(nums[0], nums[1]);
        for (int i = 2; i <= nums.length; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);
        }
        Arrays.sort(dp);
        return dp[nums.length];
    }
}

class Test_198 {
    public static void main(String[] args) {
//        int[] nums = {2, 7, 9, 3, 1};
//        int[] nums = {2};
//        int[] nums = {2,7};
        int[] nums = {};
        ques_198_打家劫舍 s = new ques_198_打家劫舍();
        System.out.println(s.rob(nums));
    }
}

3、等差数列划分

问题：

如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。

例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。
给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。

子数组 是数组中的一个连续序列。

示例 1：

输入：nums = [1,2,3,4]
输出：3
解释：nums 中有三个子等差数组：[1, 2, 3]、[2, 3, 4] 和 [1,2,3,4] 自身。
示例 2：

输入：nums = [1]
输出：0

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

/**
 * 思路：dp[i]表示以nums[i]为结尾的等差递增子区间的个数。
 * dp[2] = 1               [0, 1, 2]
 * dp[3] = dp[2] + 1 = 2   [0, 1, 2, 3] [1, 2, 3]
 * dp[4] = dp[3] + 1 = 3   [0, 1, 2, 3, 4] [1, 2, 3, 4] [2, 3, 4]
 * 因为递增子区间不一定以最后一个元素为结尾，可以是任意一个元素结尾，因此需要返回dp数组累加的结果。
 */
public class ques_413_等差数列划分 {
    public int numberOfArithmeticSlices(int[] nums) {
        if (nums.length < 3) {
            return 0;
        }
        int[] dp = new int[nums.length];
        for (int i = 2; i < nums.length; i++) {
            if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) {
                dp[i] = dp[i - 1] + 1;
            }
        }
        System.out.println(Arrays.toString(dp));
        return Arrays.stream(dp).sum();
    }
}

class Test_413 {
    public static void main(String[] args) {
//        int[] nums = {1, 2, 3, 4};
//        int[] nums = {1, 1, 2, 3, 4, 6};
        int[] nums = {1, 2, 3, 4, 5};
        ques_413_等差数列划分 s = new ques_413_等差数列划分();
        System.out.println(s.numberOfArithmeticSlices(nums));
    }
}

二、基本动态规划：二维

4、最小路径和

问题：

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例 1：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。
示例 2：

输入：grid = [[1,2,3],[4,5,6]]
输出：12

package LeetCode.test6_dongtaiguihua;

public class ques_64_最小路径和 {
    public int minPathSum(int[][] grid) {
        int[][] dp = new int[grid.length][grid[0].length];
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (i == 0 && j == 0) {
                    dp[0][0] = grid[0][0];
                } else if (i == 0) {
                    dp[0][j] = dp[0][j - 1] + grid[0][j];
                } else if (j == 0) {
                    dp[i][0] = dp[i - 1][0] + grid[i][0];
                } else {
                    dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
                }
            }
        }
        return dp[grid.length - 1][grid[0].length - 1];
    }

    public int minPathSum2(int[][] grid) {
        /*
         * 空间压缩:对于第i行，在遍历到第j列的时候，因为第j-1列已经更新过了，所以dp[j-1]代表dp[i][j-1]的值;
         *         而dp[j]待更新，当前存储的值是在第i-1行的时候计算的，所以代表dp[i-1][j]的值。
         *      eg: 1 ,3 ,1   i = 2时  dp[2] = min(dp[2],dp[1]) + grid[2][2]    dp -> [6, 8, 7]
         *          1 ,5 ,1             min中的dp[2] ->  1 ,3 ,1 这部分的dp[2]
         *          4 ,2 ,1                             1 ,5 ,1
         *                              min中的dp[1] ->  1 ,3 这部分的dp[1]
         *                                               1 ,5
         *                                               4 ,2
         */
        int[] dp = new int[grid[0].length];
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (i == 0 && j == 0) {
                    dp[j] = grid[i][j];
                } else if (i == 0) {
                    dp[j] = dp[j - 1] + grid[i][j];
                } else if (j == 0) {
                    dp[j] = dp[j] + grid[i][j];
                } else {
                    dp[j] = Math.min(dp[j], dp[j - 1]) + grid[i][j];
                }
            }
        }
        return dp[grid[0].length - 1];
    }
}

class Test_64 {
    public static void main(String[] args) {
        int[][] grid = {{1, 3, 1},
                {1, 5, 1},
                {4, 2, 1}};
        ques_64_最小路径和 s = new ques_64_最小路径和();
        System.out.println(s.minPathSum(grid));
        System.out.println(s.minPathSum2(grid));
    }
}

5、01矩阵

问题：

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。

两个相邻元素间的距离为 1 。

示例 1：

输入：mat = [[0,0,0],[0,1,0],[0,0,0]]
输出：[[0,0,0],[0,1,0],[0,0,0]]
示例 2：

输入：mat = [[0,0,0],[0,1,0],[1,1,1]]
输出：[[0,0,0],[0,1,0],[1,2,1]]

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

/**
 思路：从左上到右下进行一次动态搜索，再从右下到左上进行一次动态搜索。
 */
public class ques_542_01矩阵 {
    public int[][] updateMatrix(int[][] mat) {
        int m = mat.length;
        int n = mat[0].length;
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            Arrays.fill(dp[i], Integer.MAX_VALUE - 1);
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (mat[i][j] == 0) {
                    dp[i][j] = 0;
                } else {
                    if (i > 0) {
                        dp[i][j] = Math.min(dp[i][j], dp[i - 1][j] + 1);
                    }
                    if (j > 0) {
                        dp[i][j] = Math.min(dp[i][j], dp[i][j - 1] + 1);
                    }
                }
            }
        }

        for (int i = m - 1; i >= 0; i--) {
            for (int j = n - 1; j >= 0; j--) {
                if (mat[i][j] != 0) {
                    if (i < m - 1) {
                        dp[i][j] = Math.min(dp[i][j], dp[i + 1][j] + 1);
                    }
                    if (j < n - 1) {
                        dp[i][j] = Math.min(dp[i][j], dp[i][j + 1] + 1);
                    }
                }
            }
        }
        return dp;
    }
}

class Test_542 {
    public static void main(String[] args) {
//        int[][] mat = {{0, 0, 0},
//                {0, 1, 0},
//                {1, 1, 1}};
        int[][] mat = {{1, 1, 0, 0, 1, 0, 0, 1, 1, 0},
                {1, 0, 0, 1, 0, 1, 1, 1, 1, 1},
                {1, 1, 1, 0, 0, 1, 1, 1, 1, 0},
                {0, 1, 1, 1, 0, 1, 1, 1, 1, 1},
                {0, 0, 1, 1, 1, 1, 1, 1, 1, 0},
                {1, 1, 1, 1, 1, 1, 0, 1, 1, 1},
                {0, 1, 1, 1, 1, 1, 1, 0, 0, 1},
                {1, 1, 1, 1, 1, 0, 0, 1, 1, 1},
                {0, 1, 0, 1, 1, 0, 1, 1, 1, 1},
                {1, 1, 1, 0, 1, 0, 1, 1, 1, 1}};
        ques_542_01矩阵 s = new ques_542_01矩阵();
        System.out.println(Arrays.deepToString(s.updateMatrix(mat)));
    }
}

6、最大正方形

问题：

在一个由 '0' 和 '1' 组成的二维矩阵内，找到只包含 '1' 的最大正方形，并返回其面积。

示例 1：

输入：matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
输出：4
示例 2：

输入：matrix = [["0","1"],["1","0"]]
输出：1

package LeetCode.test6_dongtaiguihua;


/**
 * 思路：假设dp[i][j] = k的平方 ，其充分条件为 dp[i-1][j-1]、dp[i][j-1] 和 dp[i-1][j] 的值必须
        都不小于 (k − 1)的平方 ，否则 (i, j) 位置不可以构成一个边长为 k 的正方形。同理，如果这三个值中的
        的最小值为 k − 1，则 (i, j) 位置一定且最大可以构成一个边长为 k 的正方形。
 */
public class ques_221_最大正方形 {
    public int maximalSquare(char[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] dp = new int[m + 1][n + 1];
        int max_side = 0;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (matrix[i - 1][j - 1] == '1') {
                    dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i][j - 1], dp[i - 1][j])) + 1;
                }
                max_side = Math.max(max_side, dp[i][j]);
            }
        }
        /*
            [0, 0, 0, 0, 0, 0]
            [0, 1, 0, 1, 0, 0]
            [0, 1, 0, 1, 1, 1]
            [0, 1, 1, 1, 2, 2]
            [0, 1, 0, 0, 1, 0]0
            注意：只有matrix[i][j]=1的时候，对应的dp值才有可能变。
        */
        return max_side * max_side;
    }
}

class Test_221 {
    public static void main(String[] args) {
        char[][] matrix = {{'1', '0', '1', '0', '0'},
                {'1', '0', '1', '1', '1'},
                {'1', '1', '1', '1', '1'},
                {'1', '0', '0', '1', '0'}};
//        char[][] matrix = {{'1', '0', '0', '0', '0'},
//                {'0', '0', '0', '0', '0'},
//                {'0', '0', '0', '0', '0'},
//                {'0', '0', '0', '0', '0'}};
        ques_221_最大正方形 s = new ques_221_最大正方形();
        System.out.println(s.maximalSquare(matrix));
    }
}

三、分割类型题

7、完全平方数

问题：

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

示例 1：

输入：n = 12
输出：3
解释：12 = 4 + 4 + 4
示例 2：

输入：n = 13
输出：2
解释：13 = 4 + 9

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

/**
 * 思路：位置i只依赖i-k的平方的位置，如i-1、i-4、i-9等等，才能满足完全平方分割
 * 的条件，因此dp[i]可以取的最小值即为1+min(dp[i-1], dp[i-4], dp[i-9] ···)。
 */
public class ques_279_完全平方数 {
    public int numSquares(int n) {
        int[] dp = new int[n + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j * j <= i; j++) {
                dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
            }
        }
        System.out.println(Arrays.toString(dp));

        return dp[n];
    }
}

class Test_279 {
    public static void main(String[] args) {
        int n = 12;
        ques_279_完全平方数 s = new ques_279_完全平方数();
        System.out.println(s.numSquares(n));
    }
}

8、解码方法

问题：

一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：

'A' -> "1"
'B' -> "2"
...
'Z' -> "26"
要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，"11106" 可以映射为：

"AAJF" ，将消息分组为 (1 1 10 6)
"KJF" ，将消息分组为 (11 10 6)
注意，消息不能分组为  (1 11 06) ，因为 "06" 不能映射为 "F" ，这是由于 "6" 和 "06" 在映射中并不等价。

给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。

题目数据保证答案肯定是一个 32 位 的整数。

示例 1：

输入：s = "12"
输出：2
解释：它可以解码为 "AB"（1 2）或者 "L"（12）。
示例 2：

输入：s = "226"
输出：3
解释：它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。
示例 3：

输入：s = "0"
输出：0
解释：没有字符映射到以 0 开头的数字。
含有 0 的有效映射是 'J' -> "10" 和 'T'-> "20" 。
由于没有字符，因此没有有效的方法对此进行解码，因为所有数字都需要映射。

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

public class ques_91_解码方法 {
    public int numDecodings(String s) {
        int m = s.length();
        if (s.charAt(0)=='0'){
            return 0;
        }
        int[] dp = new int[m + 1];
        Arrays.fill(dp, 1);
        dp[1] = 1;
        for (int i = 2; i <= m; i++) {
            int num = Integer.parseInt(s.charAt(i - 2) + String.valueOf(s.charAt(i - 1)));
            if ((s.charAt(i - 1) - '0' == 0 && num > 26) || num==0) {
                dp[i] = 0;
            }else if (s.charAt(i - 1) - '0' == 0 && num <= 26) {
                dp[i] = dp[i - 2];
            }
            else if ((s.charAt(i - 2) - '0' == 0) || num > 26) {
                dp[i] = dp[i - 1];
            } else {
                dp[i] = dp[i - 1] + dp[i - 2];
            }
        }
        return dp[m];
    }
}

class Test_91 {
    public static void main(String[] args) {
        String s = "10011";
        ques_91_解码方法 q = new ques_91_解码方法();
        System.out.println(q.numDecodings(s));
    }
}

9、单词拆分

问题：

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

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

示例 1：

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

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
  注意，你可以重复使用字典中的单词。
示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;
import java.util.List;

/**
    思路：s = "applepenapple"; wordDict = {"apple", "pen"};
        dp[5] = dp[5]||dp[0] = true;
        dp[8] = dp[8]||dp[5] = true;
        如果不匹配，则dp[8] = dp[8]||dp[?] = false,后面的则都为false
        dp[13] = dp[13]||dp[8] = true;
 */
public class ques_139_单词拆分 {
    public boolean wordBreak(String s, List<String> wordDict) {
        int m = s.length();
        boolean[] dp = new boolean[m + 1];
        dp[0] = true;
        for (int i = 1; i <= m; i++) {
            for (String word : wordDict) {
                int len = word.length();
                if (i >= len && s.substring(i - len, i).equals(word)) {
                    dp[i] = dp[i] || dp[i - len];
                }
            }
        }
        return dp[m];
    }
}


class Test_139 {
    public static void main(String[] args) {
        String s = "leetcode";
        String[] word = {"leet", "code"};
        List<String> wordDict = Arrays.asList(word);
        ques_139_单词拆分 p = new ques_139_单词拆分();
        System.out.println(p.wordBreak(s, wordDict));
    }
}

四、子序列问题

10、最长递增子序列

问题：

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4
示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

package LeetCode.test6_dongtaiguihua;


import java.util.Arrays;

public class ques_300_最长递增子序列 {
    public int lengthOfLIS(int[] nums) {
        int m = nums.length;
        int[] dp = new int[m];
        Arrays.fill(dp, 1);
        int max_length = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            max_length = Math.max(max_length, dp[i]);
        }
        return max_length;
    }
}

class Test_300 {
    public static void main(String[] args) {
        int[] nums = {10, 9, 2, 5, 3, 7, 101, 18};
        ques_300_最长递增子序列 s = new ques_300_最长递增子序列();
        System.out.println(s.lengthOfLIS(nums));
    }
}

11、最长公共子序列

问题：

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = "abcde", text2 = "ace"
输出：3
解释：最长公共子序列是 "ace" ，它的长度为 3 。
示例 2：

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc" ，它的长度为 3 。
示例 3：

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0 。

package LeetCode.test6_dongtaiguihua;

public class ques_1143_最长公共子序列 {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[m][n];
    }
}

class Test_1143 {
    public static void main(String[] args) {
        String text1 = "abcde";
        String text2 = "ace";
        ques_1143_最长公共子序列 s = new ques_1143_最长公共子序列();
        System.out.println(s.longestCommonSubsequence(text1, text2));
    }
}

五、 背包问题

Demo1、01背包问题

package LeetCode.test6_dongtaiguihua;

/*
口诀：0-1背包对物品的迭代放在外层，里层的体积或价值逆向遍历；
     完全背包对物品的迭代放在里层，外层的体积或价值正向遍历。
 */

/**
 * 思路： dp[i][j]表示前i件物品体积不超过j的情况下能达到的最大价值。
 * 在当前背包总容量为j的情况下，如果不将物品i放入背包，那么dp[i][j]=dp[i-1][j]，
 * 即前i个物品的最大价值等于只取前i-1个物品时的最大价值；如果将物品i放入背包，
 * 假设第i件物品体积为w，价值为v，那么得到dp[i][j] = dp[i-1][j-w] + v。
 */
public class demo_01背包问题 {
    public int knapsack(int[] weights, int[] values, int N, int W) {  //N:个数 W:容量
        int[][] dp = new int[N + 1][W + 1];
        for (int i = 1; i <= N; i++) {
            int w = weights[i - 1];
            int v = values[i - 1];
            for (int j = 1; j <= W; j++) {
                if (j >= w) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - w] + v);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[N][W];
    }

    public int knapsack2(int[] weights, int[] values, int N, int W) {
        int[] dp = new int[W + 1];
        for (int i = 1; i <= N; i++) {
            int w = weights[i - 1];
            int v = values[i - 1];
            for (int j = W; j >= w; j--) {
                dp[j] = Math.max(dp[j], dp[j - w] + v);
            }
        }
        return dp[W];
    }
}

class Test_01背包问题 {
    public static void main(String[] args) {
        int[] weights = {5, 4, 3, 2, 1};
        int[] values = {1, 2, 3, 4, 5};
        int N = 5;
        int W = 10;
        demo_01背包问题 s = new demo_01背包问题();
        System.out.println(s.knapsack(weights, values, N, W));
        System.out.println(s.knapsack2(weights, values, N, W));
    }
}

Demo2、完全背包问题

package LeetCode.test6_dongtaiguihua;

public class demo_02完全背包问题 {
    public int knapsack(int[] weights, int[] values, int N, int W) {
        int[][] dp = new int[N + 1][W + 1];
        for (int i = 1; i <= N; i++) {
            int w = weights[i - 1];
            int v = values[i - 1];
            for (int j = 1; j <= W; j++) {
                if (j >= w) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - w] + v);
                    // 与0-1背包问题的差别仅仅是把状态转移方程中的第二个i-1变成了i。
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[N][W];
    }

    public int knapsack2(int[] weights, int[] values, int N, int W) {
        // 遍历每一行的时候必须正向遍历，因为需要利用当前物品在第j-w列的信息。
        int[] dp = new int[W + 1];
        for (int i = 1; i <= N; i++) {
            int w = weights[i - 1];
            int v = values[i - 1];
            for (int j = w; j <= W; j++) {
                dp[j] = Math.max(dp[j], dp[j - w] + v);
            }
        }
        return dp[W];
    }
}

class Test_02完全背包问题 {
    public static void main(String[] args) {
        int[] weights = {5, 4, 3, 2, 1};
        int[] values = {1, 2, 3, 4, 5};
        int N = 5;
        int W = 10;
        demo_02完全背包问题 s = new demo_02完全背包问题();
        System.out.println(s.knapsack(weights, values, N, W));
        System.out.println(s.knapsack2(weights, values, N, W));
    }
}

12、分割等和子集

问题：

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

示例 1：

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

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

/**
 * 思路：1、不选 nums[i]，那么就从前i - 1个数中选，看是否使得这些数字的和恰好等于j，即 f[i][j] = f[i - 1][j]。
 * 2、选择nums[i] ，在背包可以装下的情况下，那么相应的背包容量就要减去nums[i] ,
 * f[i][j]的状态就可以从f[i - 1][j - nums[i]]转移过来，即f[i][j] = f[i - 1][j - nums[i]]。
 * 综上，两种情况只要有一个为true，f[i][j]就为true。因此状态转移方程为f[i][j] = f[i - 1][j] | f[i - 1][j - nums[i]]。
 * 初始化：f[0][0] = true：在前0个数中，我们可以一个数都不去选，因此从前0个数中选，使得这些数字的和恰好等于0的状态为true，
 * 其余的状态都初始化为false。
 */
public class ques_416_分割等和子集 {
    public boolean canPartition(int[] nums) {
        int sum = Arrays.stream(nums).reduce(0, Integer::sum);
        if (sum % 2 != 0) {
            return false;
        }
        int m = nums.length;
        int target = sum / 2;
        boolean[][] dp = new boolean[m + 1][target + 1];
        //dp[i][j]表示从前i个数中选若干个数，是否使得这些数字的和恰好等于j。
        dp[0][0] = true;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= target; j++) {
                if (j >= nums[i-1]) {
                    dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i-1]];
                }else {
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        return dp[m][target];
    }
}


class Test_416 {
    public static void main(String[] args) {
//        int[] nums = {1, 5, 11, 5};
        int[] nums = {1, 5, 10, 6};
        ques_416_分割等和子集 s = new ques_416_分割等和子集();
        System.out.println(s.canPartition(nums));
    }
}

13、一和零

问题：

给你一个二进制字符串数组 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 。
示例 2：

输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。

package LeetCode.test6_dongtaiguihua;

public class ques_474_一和零 {
    public int findMaxForm(String[] strs, int m, int n) {
        int len = strs.length;
        int[][][] dp = new int[len + 1][m + 1][n + 1];
        for (int i = 1; i <= len; i++) {
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    int countZero = countOneAndZero(strs[i - 1])[0];
                    int countOne = countOneAndZero(strs[i - 1])[1];
                    if (j >= countZero && k >= countOne) {
                        dp[i][j][k] = Math.max(dp[i - 1][j][k], dp[i - 1][j - countZero][k - countOne] + 1);
                    } else {
                        dp[i][j][k] = dp[i - 1][j][k];
                    }
                }
            }
        }
        return dp[len][m][n];
    }

    /**
     * 由于dp[i][][]的每个元素值的计算只和dp[i−1][][]的元素值有关，因此可以使用滚动数组的方式，
     * 去掉dp的第一个维度，将空间复杂度优化到 O(mn)。
     * 实现时，内层循环需采用倒序遍历的方式，这种方式保证转移来的是dp[i−1][][]中的元素值。
     */
    public int findMaxForm2(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        for (String str : strs) {
            int countZero = countOneAndZero(str)[0];
            int countOne = countOneAndZero(str)[1];
            for (int j = m; j >= countZero; j--) {
                for (int k = n; k >= countOne; k--) {
                    dp[j][k] = Math.max(dp[j][k], dp[j - countZero][k - countOne] + 1);
                }
            }
        }
        return dp[m][n];
    }

    public int[] countOneAndZero(String strs) {
        int[] res = new int[2];
        for (char str : strs.toCharArray()) {
            res[str - '0']++;
        }
        return res;
    }
}


class Test_474 {
    public static void main(String[] args) {
//        String[] strs = {"10", "0001", "111001", "1", "0"};
//        int m = 5;
//        int n = 3;

        String[] strs = {"10", "0", "1"};
        int m = 1;
        int n = 1;
        ques_474_一和零 s = new ques_474_一和零();
//        System.out.println(s.findMaxForm(strs, m, n));
        System.out.println(s.findMaxForm2(strs, m, n));
    }
}

14、零钱兑换

问题：

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

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

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

示例 1：

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

输入：coins = [2], amount = 3
输出：-1
示例 3：

输入：coins = [1], amount = 0
输出：0

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

/**
 * 思路：（完全背包问题）
 * 以amount==11，coins[1,2,5]为例，总金额11可以由dp[10] + 1、dp[9] + 1、dp[6] + 1得来，
 * 假设用1的硬币，那么就需要先凑齐10块钱，该方案下的dp[11] = dp[10] + 1；
 * 假设用2的硬币，那么需要先凑齐9块钱，该方案下的dp[11] = dp[9] + 1；
 * 同理，用5的硬币，dp[11] = dp[6] + 1。
 * 所以，取他们的最小值即可，dp[i]也起到缓存的作用
 */
public class ques_322_零钱兑换 {
    public int coinChange(int[] coins, int amount) {
        int m = coins.length;
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, amount + 2);
        dp[0] = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= amount; j++) {
                if (j >= coins[i - 1]) {
                    dp[j] = Math.min(dp[j], dp[j - coins[i - 1]] + 1);
                }
            }
        }
        return dp[amount] == amount + 2 ? -1 : dp[amount];
    }
}

class Test_322 {
    public static void main(String[] args) {
//        int[] coins = {1, 2, 5};
        int[] coins = {2};
//        int amount = 11;
        int amount = 3;
        ques_322_零钱兑换 s = new ques_322_零钱兑换();
        System.out.println(s.coinChange(coins, amount));
    }
}

六、 字符串编辑

15、编辑距离

问题：

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数  。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

示例 1：

输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')
示例 2：

输入：word1 = "intention", word2 = "execution"
输出：5
解释：
intention -> inention (删除 't')
inention -> enention (将 'i' 替换为 'e')
enention -> exention (将 'n' 替换为 'x')
exention -> exection (将 'n' 替换为 'c')
exection -> execution (插入 'u')

package LeetCode.test6_dongtaiguihua;

/**
 * 思路：dp[i][j]代表word1到i位置转换成word2到j位置需要最少步数。
 * 当 word1[i] == word2[j]，dp[i][j] = dp[i-1][j-1]；
 * 当 word1[i] != word2[j]，dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1
 * 其中，dp[i-1][j-1]表示替换操作，dp[i-1][j] 表示插入j位置/删除i位置操作，dp[i][j-1] 表示插入i位置/删除j位置操作。
 */
public class ques_72_编辑距离 {
    public int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= n; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1.charAt(i-1)==word2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1];
                }else {
                    dp[i][j] = Math.min(dp[i-1][j-1],Math.min(dp[i][j-1],dp[i-1][j])) + 1;
                }
            }
        }
        return dp[m][n];
    }
}

class Test_72 {
    public static void main(String[] args) {
//        String word1 = "horse";
//        String word2 = "ros";

        String word1 = "intention";
        String word2 = "execution";
        ques_72_编辑距离 s = new ques_72_编辑距离();
        System.out.println(s.minDistance(word1, word2));
    }
}

16、只有两个键的键盘

问题：

最初记事本上只有一个字符 'A' 。你每次可以对这个记事本进行两种操作：

Copy All（复制全部）：复制这个记事本中的所有字符（不允许仅复制部分字符）。
Paste（粘贴）：粘贴 上一次 复制的字符。
给你一个数字 n ，你需要使用最少的操作次数，在记事本上输出 恰好 n 个 'A' 。返回能够打印出 n 个 'A' 的最少操作次数。

示例 1：

输入：3
输出：3
解释：
最初, 只有一个字符 'A'。
第 1 步, 使用 Copy All 操作。
第 2 步, 使用 Paste 操作来获得 'AA'。
第 3 步, 使用 Paste 操作来获得 'AAA'。
示例 2：

输入：n = 1
输出：0

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

/**
 * 思路：设dp[i]表示打印出i个A的最少操作次数。
 * 由于只能使用「复制全部」和「粘贴」两种操作，那么要想得到i个A，必须首先拥有j个A，
 * 使用一次「复制全部」操作，再使用若干次「粘贴」操作得到i个A。
 * 因此，这里的j必须是i的因数，「粘贴」操作的使用次数即为i/j-1,可以枚举j进行状态转移，
 * 这样就可以得到状态转移方程：dp[i] = min(dp[j] + i/j)
 * 在[1, sqrt{i}]的范围内枚举j，并用j和i/j分别作为因数进行状态转移.
 * eg: dp[6] = dp[3] + 6 / 3 (copy+paste)
 */
public class ques_650_只有两个键的键盘 {
    public int minSteps(int n) {
        int[] dp = new int[n + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j * j <= i; j++) {
                if (i % j == 0) {
                    dp[i] = Math.min(dp[i], dp[j] + i / j); //前半部分
                    dp[i] = Math.min(dp[i], dp[i / j] + j); //后半部分
                }
            }
        }
        return dp[n];
    }
}

class Test_650 {
    public static void main(String[] args) {
        int n = 18;
        ques_650_只有两个键的键盘 s = new ques_650_只有两个键的键盘();
        System.out.println(s.minSteps(n));
    }
}

17、正则表达式匹配

问题：

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

示例 1：

输入：s = "aa", p = "a"
输出：false
解释："a" 无法匹配 "aa" 整个字符串。
示例 2:

输入：s = "aa", p = "a*"
输出：true
解释：因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3：

输入：s = "ab", p = ".*"
输出：true
解释：".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。

package LeetCode.test6_dongtaiguihua;

public class ques_10_正则表达式匹配 {
    public boolean isMatch(String s, String p) {
        int m = s.length();
        int n = p.length();
        boolean[][] dp = new boolean[m + 1][n + 1];
        dp[0][0] = true;
        for (int i = 2; i <= n; i++) {
            if (p.charAt(i - 1) == '*') {
                dp[0][i] = dp[0][i - 2];
            }
        }
        // eg：s = "aab", p = "c*a*b"
        //    假设i=2,p[1]='*',dp[0][2] = dp[0][0] = true
        //    如果p = "dc*a*b" 则假设i=3,p[2]='*',dp[0][3] = dp[0][1] = false
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (p.charAt(j - 1) == '.') {
                    dp[i][j] = dp[i - 1][j - 1];  // eg：s = "ab", p = "a."
                } else if (p.charAt(j - 1) != '*') {
                    dp[i][j] = dp[i - 1][j - 1] && (p.charAt(j - 1) == s.charAt(i - 1));
                    // eg：s = "cab", p = "ca."   其中以a为例
                } else if (p.charAt(j-2) != s.charAt(i-1) && p.charAt(j-2) != '.'){
                    dp[i][j] = dp[i][j-2];
                    // eg：s = "cdb", p = "ca."   j=3  c!=d&&a!='.'
                    // dp[2][3] = dp[2][1]  s = "cd", p = "ca." <-> s = "cd", p = "c"
                } else {
                    dp[i][j] = dp[i][j-1] || dp[i-1][j] || dp[i][j-2];
                    //  dp[i][j-1]  重复0次,前一个匹配  dp[i-1][j]  s除去1个   dp[i][j-2] 重复0次,前一个不匹配
                }
            }
        }
        return dp[m][n];
    }
}

class Test_10 {
    public static void main(String[] args) {
        String s = "aa";
        String p = "a";
        ques_10_正则表达式匹配 q = new ques_10_正则表达式匹配();
        System.out.println(q.isMatch(s, p));
    }
}

七、 股票交易

18、买卖股票的最佳时机

问题：

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

package LeetCode.test6_dongtaiguihua;

/**
 * dp[i][j]表示天数[0, i]区间里，下标i这一天状态为j的时候能够获得的最大利润。其中：j=0表示当前不持股,j=1表示当前持股。
 * dp[i][0]：规定了今天不持股，有以下两种情况：昨天不持股，今天什么都不做；       昨天持股，今天卖出股票（现金数增加），
 * dp[i][1]：规定了今天持股，有以下两种情况：昨天持股，今天什么都不做（现金数与昨天一样）；
 *           昨天不持股，今天买入股票（注意：只允许交易一次，因此手上的现金数就是当天的股价的相反数）。
 */
public class ques_121_买卖股票的最佳时机 {
    public int maxProfit(int[] prices) {
        int m = prices.length;
        if (m < 2) {
            return 0;
        }
        int[][] dp = new int[m + 1][2];
        dp[1][0] = 0; // 第一天不持股显然为0
        dp[1][1] = -prices[0];  // 持股就需要减去第1天的股价
        for (int i = 2; i <= m; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i - 1]);
            dp[i][1] = Math.max(dp[i - 1][1], -prices[i - 1]);
        }
        return dp[m][0];
    }
}

class Test_121 {
    public static void main(String[] args) {
        int[] prices = {7, 1, 5, 3, 6, 4};
        ques_121_买卖股票的最佳时机 s = new ques_121_买卖股票的最佳时机();
        System.out.println(s.maxProfit(prices));
    }
}

19、买卖股票的最佳时机IV

问题：

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1：

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
示例 2：

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

package LeetCode.test6_dongtaiguihua;

import java.util.Arrays;

/**
 * 思路：用buy[i][j]表示对于数组prices[0..i]中的价格而言，进行恰好j笔交易，并且当前手上持有一支股票，这种情况下的最大利润；
 * 用sell[i][j]表示恰好进行j笔交易，并且当前手上不持有股票，这种情况下的最大利润。
 * buy[i][j]：考虑当前手上持有的股票是否是在第i天买入的。
 * 如果是第i天买入的，那么在第i−1天时，手上不持有股票，对应状态sell[i−1][j]，并且需要扣除prices[i]的买入花费；
 * 如果不是第i天买入的，那么在第i−1天时，手上持有股票，对应状态buy[i−1][j]。
 * sell[i][j]：如果是第i天卖出的，那么在第i−1天时，手上持有股票，对应状态 buy[i−1][j−1]，并且需要增加prices[i]的卖出收益；
 * 如果不是第i天卖出的，那么在第i−1天时，手上不持有股票，对应状态sell[i−1][j]。
 */
public class ques_188_买卖股票的最佳时机IV {
    public int maxProfit(int k, int[] prices) {
        int days = prices.length;
        if (days < 2) {
            return 0;
        }
        k = Math.min(k, days / 2); // n天最多只能进行|n/2|笔交易。
        int[][] buy = new int[days + 1][k + 1];
        int[][] sell = new int[days + 1][k + 1];
        buy[1][0] = -prices[0];
        sell[1][0] = 0;
        for (int i = 1; i <= k; ++i) {
            buy[1][i] = sell[1][i] = Integer.MIN_VALUE / 2;
            // 第一天不可能完成任何交易，所以buy[1][1..k]设置为一个非常小的值，表示不合法的状态;
            // 同理将所有的sell[0][1..k]设置为一个非常小的值，表示不合法的状态.
        }
        for (int i = 2; i <= days; i++) {
            buy[i][0] = Math.max(buy[i - 1][0], sell[i - 1][0] - prices[i - 1]);
            // 先有buy,才能有sell,二维数组初始化.
            for (int j = 1; j <= k; j++) {
                buy[i][j] = Math.max(sell[i - 1][j] - prices[i - 1], buy[i - 1][j]);
                sell[i][j] = Math.max(buy[i - 1][j - 1] + prices[i - 1], sell[i - 1][j]);
            }
        }
        return Arrays.stream(sell[days]).max().getAsInt();
    }

    public int maxProfit2(int k, int[] prices) { //buy[i][j]和sell[i][j]都从buy[i−1][..]以及sell[i−1][..]转移而来.
        int days = prices.length;
        if (days < 2) {
            return 0;
        }
        k = Math.min(k, days / 2); // n天最多只能进行|n/2|笔交易。
        int[] buy = new int[k + 1];
        int[] sell = new int[k + 1];
        buy[0] = -prices[0];
        sell[0] = 0;
        for (int i = 1; i <= k; ++i) {
            buy[i] = sell[i] = Integer.MIN_VALUE / 2;
        }
        for (int i = 2; i <= days; i++) {
            buy[0] = Math.max(buy[0], sell[0] - prices[i - 1]);
            for (int j = 1; j <= k; j++) {
                buy[j] = Math.max(sell[j] - prices[i - 1], buy[j]);
                sell[j] = Math.max(buy[j - 1] + prices[i - 1], sell[j]);
            }
        }
        return Arrays.stream(sell).max().getAsInt();
    }
}


class Test_188 {
    public static void main(String[] args) {
//        int k = 2;
//        int[] prices = {2, 4, 1};
        int k = 2;
        int[] prices = {3, 2, 6, 5, 0, 3};
        ques_188_买卖股票的最佳时机IV s = new ques_188_买卖股票的最佳时机IV();
        System.out.println(s.maxProfit(k, prices));
        System.out.println(s.maxProfit2(k, prices));
    }
}

20、最佳买卖股票时机含冷冻期

问题：

给定一个整数数组prices，其中第  prices[i] 表示第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: prices = [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
示例 2:

输入: prices = [1]
输出: 0

package LeetCode.test6_dongtaiguihua;

/**
 * 思路：用 f[i]表示第i天结束之后的累计最大收益。
 * 目前持有一支股票：f[i][0]
 * 目前不持有任何股票，并且处于冷冻期中：f[i][1]
 * 目前不持有任何股票，并且不处于冷冻期中：f[i][2]
 * f[i][0]：目前持有的这一支股票可以是在第i−1天就已经持有的，对应的状态为f[i−1][0]；
 * 或者是第i天买入的，那么第i−1天就不能持有股票并且不处于冷冻期中，对应的状态为f[i−1][2]加上买入股票的负收益prices[i]。
 * f[i][1]：在第i天结束之后处于冷冻期的原因是在当天卖出了股票，那么说明在第i−1天时必须持有一支股票，
 * 对应的状态为f[i−1][0]加上卖出股票的正收益prices[i]。
 * f[i][2]：在第i天结束之后不持有任何股票并且不处于冷冻期，说明当天没有进行任何操作，即第i−1天时不持有任何股票：
 * 如果处于冷冻期，对应的状态为f[i−1][1]；如果不处于冷冻期，对应的状态为f[i−1][2]。
 */
public class ques_309_最佳买卖股票时机含冷冻期 {
    public int maxProfit(int[] prices) {
        int days = prices.length;
        int[][] dp = new int[days + 1][3];
        dp[1][0] = -prices[0];
        for (int i = 2; i <= days; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][2] - prices[i - 1]);
            dp[i][1] = dp[i - 1][0] + prices[i - 1];
            dp[i][2] = Math.max(dp[i - 1][1], dp[i - 1][2]);
        }
        return Math.max(dp[days][1], dp[days][2]);
    }
}

class Test_309 {
    public static void main(String[] args) {
        int[] prices = {1, 2, 3, 0, 2};
        ques_309_最佳买卖股票时机含冷冻期 s = new ques_309_最佳买卖股票时机含冷冻期();
        System.out.println(s.maxProfit(prices));
    }
}

练习

1、不同的子序列

问题：

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）

示例 1：

输入：s = "rabbbit", t = "rabbit"
输出：3
示例 2：

输入：s = "babgbag", t = "bag"
输出：5
思路：

dp[i][j]:字符串s的前j个字符组成的子序列中，和字符串t的前i个字符组成的字符串一样的有多少个

（1）字符串t的第i个字符和字符串s的第j个字符一样

 

 （2）字符串t的第i个字符和字符串s的第j个字符不一样

计算字符串s的前j-1个字符构成的子序列中包含字符串t的前i个字符组成的字符串的个数。

class Solution {
    public int numDistinct(String s, String t) {
        int s_len = s.length();
        int t_len = t.length();
        // 字符串s的前j个字符组成的子序列中，和字符串t的前i个字符组成的字符串一样的有多少个
        int[][] dp = new int[t_len+1][s_len+1];  // eg:    5,8 -> dp[5][8] -> 5+1,8+1

        for(int j=0;j<=s_len;j++){
            dp[0][j] = 1;
        }

        for(int i=1;i<=t_len;i++){
            for(int j=1;j<=s_len;j++){
                if(t.charAt(i-1)==s.charAt(j-1)){  // t的第i个字符索引为i-1  s的第j个字符索引为j-1
                    dp[i][j] = dp[i-1][j-1] + dp[i][j-1];
                }else{
                    dp[i][j] = dp[i][j-1];
                }
            }
        }
        return dp[t_len][s_len];
    }
}