码创造者

这个屌丝很懒，什么也没留下！

热门标签

动态规划类题目专题训练 -- LeetCode上38道与动态规划相关的题_leetcode力扣动态规划(进阶版)题目

作者：码创造者 | 2024-08-23 07:51:41

踩

leetcode力扣动态规划(进阶版)题目

这个专题中的题目是我跟随代码随想录的刷题计划，在LeetCode上做的与动态规划相关的题目，用于加深对动态规划的理解！

下面的内容将会有每一道题目的题意、在代码随想录中对应的参考文章、我的思路以及我所写的Java代码，希望对你有帮助！

基础篇

1 - LeetCode 509 斐波那契数

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fibonacci-number

题意：

斐波那契数（通常用 F(n) 表示）形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1
示例 2：

输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2
示例 3：

输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

提示：

0 <= n <= 30

参考文章

思路：

每次学习动态规划都是从这道题开始。

最简单的dp。递推公式在题面上已经给出了。

本题Java代码：

class Solution {
    public int fib(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11

2 - LeetCode 70 爬楼梯

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/climbing-stairs

题意：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1 - 1 阶 + 1 阶
2 - 2 阶

示例 2：

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

提示：

1 <= n <= 45

参考文章

思路：

这道题的递推公式跟上一道题其实是一样的，都是dp[i] = dp[i - 1] + dp[i - 2]。

如何理解呢？其实想到爬楼梯的最后一步，要么是由n - 1层通过一步跨一阶抵达n层，要么是由n - 2层通过一步跨两阶抵达n层，而且这一步会导致不同的爬楼梯方式，那么结果就是dp[i] = dp[i - 1] + dp[i - 2]。

本题Java代码：

class Solution {
    public int climbStairs(int n) {
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11

3 - LeetCode 746 使用最小花费爬楼梯

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/min-cost-climbing-stairs

题意：

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。

支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

示例 2：

输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。

支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。

提示：

2 <= cost.length <= 1000
0 <= cost[i] <= 999

参考文章

思路：

这道题我觉得其实跟背包问题有点像，只不过是由想求最大的价值改为想求最小的消费的而已。

我的递推公式跟参考文章的写的不太一样，但我感觉我写的比较好理解。

dp[i]代表抵达 i 层所需的最小花费，cost[i]代表使用 i 层阶梯所需的花费

递推公式：dp[i] = Math.min(dp[i - 2] + cost[i - 2], dp[i - 1] + cost[i - 1]);

本题Java代码：

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length + 1];
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= cost.length; i++) {
            dp[i] = Math.min(dp[i - 2] + cost[i - 2], dp[i - 1] + cost[i - 1]);
        }
        return dp[cost.length];
    }
}
1
2
3
4
5
6
7
8
9
10
11

4 - LeetCode 62 不同路径

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths

题意：

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：
在这里插入图片描述
输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1- 向右 -> 向下 -> 向下
2- 向下 -> 向下 -> 向右
3- 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

1 <= m, n <= 100
题目数据保证答案小于等于 2 * 10⁹

参考文章

思路：

抵达每一个方块的方式可以由它的左边方块和由它的上边方块两个位置来抵达。那么借助上面爬楼梯问题的思路，可以很容易推出递推公式：
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

代码实现上，在地图的左边和上边用多一排罩起来，实际地图的坐标是从(1, 1)开始的，当 i 或者 j 等于 0 时，这个范围是在地图外的，在地图的左边或者上边，没有实际意义，且dp值为0，这样可以方便计算。

代码实现上，注意因为初始化了dp[1][1]的值，所以在for循环中当 i == 1且j == 1时，要跳过当前循环，不然会把dp[1][1]赋值为0。

本题Java代码：

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        dp[1][1] = 1;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == 1 && j == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m][n];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

5 - LeetCode 63 不同路径 II

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-paths-ii

题意：

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

示例 1：
在这里插入图片描述
输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1- 向右 -> 向右 -> 向下 -> 向下
2- 向下 -> 向下 -> 向右 -> 向右

示例 2：
在这里插入图片描述
输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

m == obstacleGrid.length
n == obstacleGrid[i].length
1 <= m, n <= 100
obstacleGrid[i][j] 为 0 或 1

参考文章

思路：

这道题其实跟上一题基本一致，差别就在于如果当前位置有障碍，则把抵达当前位置的方法数设为0。

这里要注意由于dp数组是跟上一题一样在地图的左边和上边多加了一排，但是obstacleGrid数组并没有，所以两个数组是有点偏移的，即dp[1][1]和obstacleGrid[0][0]分别代表坐标(1, 1)处的抵达方法数和是否有障碍。

代码上的注意点除了跟上一题一样注意for循环中 i == 1 && j == 1的情况外，还要注意有可能在obstacleGrid[0][0] == 1，这时候意味着起始点有障碍，是没有方法抵达终点，应该返回0。

本题Java代码：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        int[][] dp = new int[m + 1][n + 1];
        dp[1][1] = 1;
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == 1 && j == 1) continue;
                if (obstacleGrid[i - 1][j - 1] == 1) dp[i][j] = 0;
                else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return obstacleGrid[0][0] == 1 ? 0 : dp[m][n];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6 - LeetCode 343 整数拆分

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/integer-break

题意：

给定一个正整数 n ，将其拆分为 k 个正整数的和（ k >= 2 ），并使这些整数的乘积最大化。

返回你可以获得的最大乘积。

示例 1:

输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

示例 2:

输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

提示:

2 <= n <= 58

参考文章

思路：

dp[i]代表拆分 i 这个数可以得到的最大乘积。

这道题的递归公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));

怎么理解其中的max((i - j) * j, dp[i - j] * j)？

首先 dp[i - j] * j 这个比较好理解，这是我们把 i 这个数的拆分方法中的最后一个数字为 j 时且将剩余的和为 i - j 的整体进行拆分可以得到的最大乘积。当拆分数字中最后一个数字为 j ，剩下数字的和为 i - j ，把这个当做一个整体，这个整体可以拆分获得的最大值dp[i - j]我们已经算过了，可以直接获取。
那为什么还要考虑(i - j) * j？因为我们前面是获得的dp[i - j]是将 i - j 拆分后可以获得的最大乘积，但是还没有考虑不将 i - j 进行拆分的情况，所以也要加入(i - j) * j进行比较。

其实这道题还可以借助数学推导获得更快的性能，详情查看参考文章。

本题Java代码：

class Solution {
    public int integerBreak(int n) {
        int[] dp = new int[n + 1];
        dp[2] = 1;
        for (int i = 3; i <= n; i++) {
            for (int j = 1; j < i; j++) {
                dp[i] = Math.max(dp[i], Math.max((i - j) * j, dp[i - j] * j));
            }
        }
        return dp[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

7 - LeetCode 96 不同的二叉搜索树

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/unique-binary-search-trees

题意：

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的二叉搜索树有多少种？返回满足题意的二叉搜索树的种数。

示例 1：
在这里插入图片描述
输入：n = 3
输出：5

示例 2：

输入：n = 1
输出：1

提示：

1 <= n <= 19

参考文章

思路：

这道题建议看参考文章，思路真的好巧妙！

dp[i]代表从1到 i 为节点组成的二叉搜索树的个数

注意看此图：
在这里插入图片描述
我们发现，dp[3]就是元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量

元素1为头结点搜索树的数量
= 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量
= dp[2] * dp[0]

元素2为头结点搜索树的数量
= 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量
= dp[1] * dp[1]

元素3为头结点搜索树的数量
= 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量
= dp[0] * dp[2]

所以dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]

递推公式：dp[i] += dp[j - 1] * dp[i - j];

在这个递推公式中，在每一次迭代，以 j 作为根结点，那么左子树有从1到 j-1 一共 j-1 个节点，右子树中有从 j+1 到 i 一共 i-j 个节点，这些节点数所能构成的二叉搜索树的数量在之前的循环中已经算出了，存储在dp数组中。

本题Java代码：

class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

背包篇

8 - LeetCode 416 分割等和子集

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/partition-equal-subset-sum

题意：

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

示例 1：

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

示例 2：

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

提示：

1 <= nums.length <= 200
1 <= nums[i] <= 100

参考文章

思路：

这道题使用了01背包的思想，做这道题之前建议先阅读这两篇文章：
《关于01背包问题，你该了解这些！》
《关于01背包问题，你该了解这些！（滚动数组）》

这道题居然能联想到使用01背包的思想我是真的没想到！真的太牛逼了！

设所有数字和为sum，则目标价值target是sum/2，我们将背包最大容量设为target，进行01背包的算法，考虑为了达到当前目标值 j 时是否选取中当前数字。

如果到最后dp[target]值正是target，说明通过了这一波选用数字，成功达到了目标值，则返回true。

怎么理解递推公式dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
首先这里用到了滚动数组，关于滚动数组请参考上面的文章。
这时候 j 是我们的目标值，如果选用当前数能够帮助我们接近这个目标值，则选用！

本题Java代码：

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i : nums) sum += i;
        if (sum % 2 == 1) return false;
        int target = sum / 2;
        int[] dp = new int[target + 1];
        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]);
            }
        }
        if (dp[target] == target) return true;
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

9 - LeetCode 1049 最后一块石头的重量 II

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/last-stone-weight-ii

题意：

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

示例 1：

输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

示例 2：

输入：stones = [31,26,33,21,40]
输出：5

示例 3：

输入：stones = [1,2]
输出：1

提示：

1 <= stones.length <= 30
1 <= stones[i] <= 100

参考文章

思路：

我受不了了，刚做完上一道题，这道题没思路。

结果参考文章上来直接说道：

本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题了。

我怎么就想不到还能这样？！这样子其实跟上一道题又一模一样了！！！

设target = sum/2，那么到最后一堆石头的重量是dp[target]，另一堆石头的重量就是sum - dp[target]，结果就是(sum - dp[target]) - dp[target]

本题Java代码：

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int i : stones) sum += i;
        int target = sum / 2;
        int[] dp = new int[target + 1];
        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 - dp[target]) - dp[target];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

10 - LeetCode 494 目标和

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/target-sum

题意：

给你一个整数数组 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

示例 2：

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

提示：

1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

参考文章

思路：

这道题的难点在于两个地方：
一个是要想到第一步的思路，才能想到要用01背包
另一个是要想到递推公式dp[j]+=dp[j-nums[i]]

设所有数字的和为 sum ，作为加法的数字和为 s1 ，作为减法的数字的和为 s2（数字这时候没有取反，s2是正数），那么有 s1 + s2 = sum，那么 s2 = sum - s1
接着目标值是 target，就有 s1 - s2 = target，所以 s1 - (sum - s1) = target，得到 s1 = (sum - target) / 2。所以这样又转化为了01背包问题，需要从数字中选取组合使得组合中的数和为 s1，也即 (sum - target) / 2，到这里思路跟上面两道题就差不多了

不过这道题跟上一道题还有一个区别的地方，这道题要记录的是不同表达式的数目。所以dp[i]在这里代表的不是最接近dp[i]的值，而是可以构成和为 i 的组合的数目。
在for循环当中每次新添加入一个数来考虑是否取这个数，那么我们可以得到递推公式：dp[j] += dp[j - nums[i]]

本题Java代码：

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i : nums) sum += i;
        if (Math.abs(target) > sum || (sum + target) % 2 == 1) return 0;
        int myTarget = (sum + target) / 2;
        int[] dp = new int[myTarget + 1];
        dp[0] = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = myTarget; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[myTarget];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

11 - LeetCode 474 一和零

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ones-and-zeroes

题意：

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

参考文章

思路：

这道题关键是得想到背包是两个维度啊！！！

既然0最多有m个，1最多有n个，那么我们就搞一个两维的背包！dp[i][j]代表在能装 i 个 0 和 j 个 1 的背包最多能装下的字符串数量！那么这又转化成了一个01背包的问题！

递推公式：
dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1)

本题Java代码：

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        for (String s : strs) {
            int zeroNum = 0, oneNum = 0;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '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];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

12 - LeetCode 518 零钱兑换 II

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/coin-change-2

题意：

给你一个整数数组 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

示例 2：

输入：amount = 3, coins = [2]
输出：0
解释：只用面额 2 的硬币不能凑成总金额 3 。

示例 3：

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

提示：

1 <= coins.length <= 300
1 <= coins[i] <= 5000
coins 中的所有值互不相同
0 <= amount <= 5000

参考文章

思路：

这道题是使用的是完全背包！完全背包参考文章：《关于完全背包，你该了解这些！》

首先说一下完全背包和01背包在实现上的区别，区别在于for循环背包容量时从由大到小遍历改为由小到大遍历，这样才能达到同一个元素重复获取的效果。

本题与《LeetCode 494 目标和》类似，递推公式都是dp[j] += dp[j - coins[i]]，且注意dp[0] = 1的初始化（理解：当能由0来凑钱时，说明有对应方案，则方案数+1）

同时，完全背包模板中两个for循环顺序可改，但本题不可改，因为改了后就由求组合变成了求排列！因为改了for循环顺序，变为先在同样容量下考虑用不同硬币填充，然后再考虑不同容量的背包！这样会导致容量为6的背包有{1, 5}和{5, 1}两种排列！这个详情请见参考文章！

本题Java代码：

class Solution {
    public int change(int amount, int[] coins) {
        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];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

13 - LeetCode 377 组合总和 IV

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum-iv

题意：

给你一个由不同整数组成的数组 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)
请注意，顺序不同的序列被视作不同的组合。

示例 2：

输入：nums = [9], target = 3
输出：0

提示：

1 <= nums.length <= 200
1 <= nums[i] <= 1000
nums 中的所有元素互不相同
1 <= target <= 1000

参考文章

思路：

这道题刚好与上一道题形成对比！上一道题求的是组合，这道题求的是排列！

上一道题说道，完全背包两层for循环嵌套中，应该把背包容量遍历放在外层，物品选择放在内层的话，这种情况会导致相同背包容量考虑使用不同排列的物品来组成。那么本题就是需要使用这个排列的方式！

本题Java代码：

class Solution {
    public int combinationSum4(int[] nums, int target) {
        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 (nums[j] <= i) dp[i] += dp[i - nums[j]];
            }
        }
        return dp[target];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

14 - LeetCode 70 爬楼梯

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/climbing-stairs

题意：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

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

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

提示：

1 <= n <= 45

参考文章

思路：

这道题其实在我们这个专题中第二题就做过了！但是当时使用的是采用斐波那契数列的方式来进行dp，但是这次我们改用完全背包来做！

其实将本题转换为完全背包问题，那么它仍然是一个排列问题，有着值为1、2的物品，目标是填充满值为n的背包！那么做起来就跟上一道题几乎一模一样了！

但其实代码写完后发现，这其实还是斐波那契数列！

本题Java代码：

class Solution {
    public int climbStairs(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            dp[i] += dp[i - 1];
            if (i >= 2) dp[i] += dp[i - 2];
        }
        return dp[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11

15 - LeetCode 322 零钱兑换

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/coin-change

题意：

给你一个整数数组 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

提示：

1 <= coins.length <= 12
1 <= coins[i] <= 2³¹ - 1
0 <= amount <= 10⁴

参考文章

思路：

dp[i]代表凑齐价值为 i 的硬币最少需要的个数。

求最小方案数和最少个数的比较：
相同点：

都是在递推公式中选取较小的数值
将dp数组所有值都初始化为Integer的最大值
不同点：
- 求最小方案数：
  - dp[0]=1（因为凑齐0就是不需要所有东西，这也是一种方案）
- 求最少个数：
  - dp[0]=0（因为凑齐0就是不需要所有东西，也就是个数为0）

如果出现了能够凑齐的情况，那么会自动将硬币所需个数替换掉当前值。

所以如果最后dp[amount]仍然是Integer.MAX_VALUE，则意味着没有可以凑齐的方案，返回-1; 否则以为着可以有凑齐方案，且当前值就是硬币所需的最小个数！

本题Java代码：

class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        for (int i = 0; i < coins.length; i++) {
            for (int j = coins[i]; j <= amount; j++) {
                if (dp[j - coins[i]] != Integer.MAX_VALUE) dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
            }
        }
        return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

16 - LeetCode 279 完全平方数

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/perfect-squares

题意：

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

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

示例 1：

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

示例 2：

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

提示：

1 <= n <= 104

参考文章

思路：

这道题仍然使用到了完全背包的思想。与上一道题一样，这道题求的也是最少个数，那么对应的，初始化dp[0]=0。

将物品的值设为完全平方数，背包的容量设为n。

那么物品的种类需要多少种？只需要sqrt(n)种即可，且是向下取整！

本题Java代码：

class Solution {
    public int numSquares(int n) {
        int sqrt = (int) Math.sqrt(n);
        int[] dp = new int[n + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;
        int[] value = new int[sqrt + 1];
        for (int i = 1; i < value.length; i++) {
            value[i] = i * i;
        }
        for (int i = 1; i < value.length; i++) {
            for (int j = value[i]; j <= n; j++) {
                dp[j] = Math.min(dp[j], dp[j - value[i]] + 1);
            }
        }
        return dp[n];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

17 - LeetCode 139 单词拆分

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-break

题意：

给你一个字符串 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

提示：

1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s 和 wordDict[i] 仅有小写英文字母组成
wordDict 中的所有字符串互不相同

参考文章

思路：

这题有点不太一样啊。首先用到的仍然是完全背包的思想，但是它特别在于，还要用到HashSet以及dp数组是boolean类型的。

我们将目标字符串s从左到右的长度视为背包的容量，每个用于拼接的字符串视为物品。

在动态规划的for循环当中，目标字符串的长度从小到大，如果dp[i]为true，意味着目标字符串从左到右长度为 i 的字符串可以由字符串拼接得到、

那么我们可以发现，设 j < i，如果dp[j]为true且在用于拼接到的字符串中找到了目标字符串子串substring(j, i)，则说明目标字符串从左到右长度为 j 的字符串可以拼接得到，同时子串substring(j, i)也有，那么dp[i]就为true。

所以递推公式：if (set.contains(s.substring(j, i)) && dp[j] == true) dp[i] = true;

本题Java代码：

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        HashSet<String> set = new HashSet<>();
        for (String str : wordDict) set.add(str);
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for (int i = 1; i <= s.length(); i++) {
            for (int j = 0; j < i; j++) {
                String tmp = s.substring(j, i);
                if (set.contains(tmp) && dp[j] == true) dp[i] = true;
            }
        }
        return dp[s.length()];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

打家劫舍篇

18 - LeetCode 198 打家劫舍

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber

题意：

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

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

示例 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

参考文章

思路：

非常简单的动态规划题目，递推公式dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i])

本题Java代码：

class Solution {
    public int rob(int[] nums) {
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        if (nums.length > 1) dp[1] = 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]);
        }
        return dp[nums.length - 1];
    }
}
1
2
3
4
5
6
7
8
9
10
11

19 - LeetCode 213 打家劫舍 II

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber-ii

题意：

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

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

示例 1：

输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例 2：

输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
偷窃到的最高金额 = 1 + 3 = 4 。

示例 3：

输入：nums = [1,2,3]
输出：3

提示：

1 <= nums.length <= 100
0 <= nums[i] <= 1000

参考文章

思路：

其实就是形成一个环而已，大同小异，所有环问题都可以剪开成条形的问题。

那其实这道题，先考虑要不要拿第一个，如果不拿第一个，那么最后一个就能拿；如果拿了第一个，那么最后一个不能拿。

我一开始写的Java代码，先让dp[0] = 0，意为不拿第一个，然后计算得出dp[nums.length - 1]；接着再让dp[0] = nums[0]，意为拿了第一个，那么计算得出dp[nums.length - 2]即可，因为最后一个不能拿了，然后在结果取dp[nums.length - 2]和dp[nums.length - 1]中的较大值

这是我一开始写的Java代码：

class Solution {
    public int rob(int[] nums) {
        if (nums.length == 1) return nums[0];
        int[] dp = new int[nums.length];
        dp[0] = 0;
        dp[1] = nums[1];
        for (int i = 2; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < nums.length - 1; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return Math.max(dp[nums.length - 1], dp[nums.length - 2]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

看了参考文章中后，我发现参考文章的代码对这一段操作进行封装为一个方法，处理不同范围时往方法中传入对应参数即可。挺好的，于是我对代码进行了修改：

本题Java代码：

class Solution {
    public int rob(int[] nums) {
        if (nums.length == 1) return nums[0];
        int dp1 = robRange(nums, 0, nums.length - 2);
        int dp2 = robRange(nums, 1, nums.length - 1);
        return Math.max(dp1, dp2);
    }

    private int robRange(int[] nums, int start, int last) {
        if (start == last) return nums[start];
        int[] dp = new int[nums.length];
        dp[start] = nums[start];
        dp[start + 1] = Math.max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= last; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[last];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

20 - LeetCode 337 打家劫舍 III

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber-iii

题意：

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

给定二叉树的 root 。返回在不触动警报的情况下，小偷能够盗取的最高金额。

示例 1:

在这里插入图片描述
输入: root = [3,2,3,null,3,null,1]
输出: 7
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7

示例 2:
在这里插入图片描述

输入: root = [3,4,5,1,3,null,1]
输出: 9
解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9

提示：

树的节点数在 [1, 10⁴] 范围内
0 <= Node.val <= 10⁴

参考文章

思路：

树形DP！！！

这里用到了递归遍历二叉树的方法，同时还是使用方法返回的数组来作为dp数组。

这个dp数组只有两个元素，dp[0]代表不偷当前节点所能获得的最大值，dp[1]代表偷当前节点所能获得的最大值！

本题Java代码：

class Solution {
    public int rob(TreeNode root) {
        int[] ans = robTree(root);
        return Math.max(ans[0], ans[1]);
    }
    private int[] robTree(TreeNode root) {
        //返回数组:0-不偷当前节点，1-偷当前节点
        if (root == null) return new int[]{0, 0};
        int[] left = robTree(root.left);
        int[] right = robTree(root.right);
        int val1 = root.val + left[0] + right[0];
        int val0 = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        return new int[]{val0, val1};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

股票篇

21 - LeetCode 121 买卖股票的最佳时机

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock

题意：

给定一个数组 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。

提示：

1 <= prices.length <= 10⁵
0 <= prices[i] <= 10⁴

参考文章

思路：

注意这道题，他是只能选一天买，然后选一天卖掉，不能说我在哪几天要买，哪几天要卖。所以他其实是一道超级简单题，如果使用贪心的思想，在每一天观察当天之前最便宜的一天是多少钱，然后看看今天卖了的话能得多少钱就行。

贪心法 Java代码：

class Solution {
    public int maxProfit(int[] prices) {
        int low = prices[0];
        int ans = 0;
        for (int i = 1; i < prices.length; i++) {
            ans = Math.max(ans, prices[i] - low);
            low = Math.min(low, prices[i]);
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11

其实贪心法，性能更高。但既然我们要学的是动态规划，那我们就用动态规划来做这道题。

dp[i][0]代表在第 i 天不持有股票时的情况
dp[i][1]代表在第 i 天持有股票时的情况

那么有递推公式：

dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i])
dp[i][1] = Math.max(dp[i - 1][1], -prices[i])
1
2

我一开始写dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i])，但是这样写答案是错的。为什么？因为只能有一天购买！

动态规划法 Java代码：

class Solution {
    public int maxProfit(int[] prices) {
        int[][] dp = new int[prices.length][2];//后面的数字，0代表不持有，1代表持有
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < prices.length; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);
        }
        return dp[prices.length - 1][0];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

22 - LeetCode 122 买买过票的最佳时机 II

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii

题意：

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

在每一天，你可能会决定购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以购买它，然后在同一天出售。
返回你能获得的最大利润。

示例 1:

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

示例 2:

输入: prices = [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:

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

提示：

1 <= prices.length <= 3 * 10⁴
0 <= prices[i] <= 10⁴

参考文章

思路：

笑死，上道题我才刚说我递推公式写错了，因为只能买一次。结果这道题就是可以买多次了！不过注意，一次只能持有一股！

因此递推公式修改为：

dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i])
dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i])
1
2

直接AC！

这道题其实我们在《贪心类题目专题训练》做过，在第4题。贪心的思路其实很简单，把每两天间的利润算一下，如果利润大于0，就把这个利润就赚了！

本题Java代码：

class Solution {
    public int maxProfit(int[] prices) {
        int[][] dp = new int[prices.length][2];//后面的数字，0代表不持有，1代表持有
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < prices.length; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        }
        return dp[prices.length - 1][0];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

优化：

不难发现，其实每次操作我们只要用到当前天和前一天的dp数组元素，所以我们可以使用滚动数组。

使用滚动数组后的Java代码：

class Solution {
    public int maxProfit(int[] prices) {
        int[][] dp = new int[2][2];//后面的数字，0代表不持有，1代表持有
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < prices.length; i++) {
            dp[i%2][0] = Math.max(dp[(i-1)%2][0], dp[(i-1)%2][1] + prices[i]);
            dp[i%2][1] = Math.max(dp[(i-1)%2][1], dp[(i-1)%2][0] - prices[i]);
        }
        return dp[(prices.length - 1)%2][0];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

23 - LeetCode 123 买卖股票的最佳时机 III

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii

题意：

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

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

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

示例 1:

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

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3：

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

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

提示：

1 <= prices.length <= 10⁵
0 <= prices[i] <= 10⁵

参考文章

思路：

这题是上一题的升级版，主要是体现在允许最多购买两次，且同样最多只能持有一股。

上一题我们用一个维度来记录状态，即0代表未持有，1代表不持有。这道题我们一样整一个维度来记录状态，只不过一共是有5个状态：

0.没有操作
1.第一次买入
2.第一次卖出
3.第二次买入
4.第二次卖出

dp[i][j]表示在第 i 天时处于 j 状态下所能拥有的最多财产

那么就有递推公式：

dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i])
dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i])
dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i])
dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i])
1
2
3
4

dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i])
dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i])
这两个递推公式好理解，毕竟钱变多了

那我该怎么理解剩下两条递推公式？
dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i])
dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i])
毕竟购入的话钱不是变少了吗？
注意：他进行比较的是前一天同状态的情况，也就是说，以dp[i][3]为例，我是要考虑在今天购入我的第二股比较好，还是使用在之前就购入了第二股且未出售的情况比较好。考虑今天购入的式子是dp[i - 1][2] - prices[i]，即是在之前刚好出售第一股的最佳情况下来购入今天的股票。

本题Java代码：

class Solution {
    public int maxProfit(int[] prices) {
        int[][] dp = new int[prices.length][5];
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < prices.length; i++) {
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return Math.max(Math.max(dp[prices.length - 1][0], dp[prices.length - 1][2]), dp[prices.length - 1][4]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

同样可以使用滚动数组优化空间复杂度

使用滚动数组的Java代码：

class Solution {
    public int maxProfit(int[] prices) {
        int[] dp = new int[5];
        dp[1] = -prices[0];
        dp[3] = -prices[0];
        for (int i = 1; i < prices.length; i++) {
            dp[1] = Math.max(dp[1], dp[0] - prices[i]);
            dp[2] = Math.max(dp[2], dp[1] + prices[i]);
            dp[3] = Math.max(dp[3], dp[2] - prices[i]);
            dp[4] = Math.max(dp[4], dp[3] + prices[i]);
        }
        return Math.max(Math.max(dp[0], dp[2]), dp[4]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

24 - LeetCode 188 买卖股票的最佳时机 IV

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-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 。

提示：

0 <= k <= 100
0 <= prices.length <= 1000
0 <= prices[i] <= 1000

参考文章

思路：

这题就还是上一题的升级版啊！这道题已经在不断迭代了！

一样的，上上一道题是只能做一笔交易，就只有两种状态；上一道题只能做两笔交易，就只有五种状态；那这道题能做k笔交易，那不就能有2*k+1种状态吗？！

不多说了，直接把它AC了！

诶等等，咋没过！这题好坑啊，price数组的长度居然还可能为0！那只能再多加个判断条件，就过了！

参考文章中的代码没用滚动数组，我这里用了滚动数组。

本题Java代码：

class Solution {
    public int maxProfit(int k, int[] prices) {
        if(prices.length==0)return 0;
        int[] dp = new int[k*2+1];
        for(int i=1;i<k*2+1;i+=2){
            dp[i]=-prices[0];
        }
        for(int i=1;i<prices.length;i++){
            int tmp = -1;
            for(int j=1;j<k*2+1;j++){
                dp[j]=Math.max(dp[j],dp[j-1]+prices[i]*tmp);
                tmp=-tmp;
            }
        }
        return dp[2*k];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

25 - LeetCode 309 最佳买卖股票时机含冷冻期

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown

题意：

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

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

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

示例 1:

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

示例 2:

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

提示：

1 <= prices.length <= 5000
0 <= prices[i] <= 1000

参考文章

思路：

之前的题目有持有股票和不持有股票两种状态，这道题在不持有股票的情况下还要分为两种状态，一种是在冷冻期，一种是不在冷冻期。那直接再开一个维度就完事了。

dp[i][j][k]的表示在第 i 天的情况下：

如果 k 为1，意味着此时持有股票
如果 k 为0，意味着此时没有股票：
- j 为0：此时不在冷冻期
- j 为1：此时正在冷冻期
dp[i][1][1]没有含义，持有股票状态下不可能处于冷冻期

在dp[i][1][0]下，这时候我们处于冷冻期，意味着我们从前一天持有股票的状态下今天把股票给卖了，于是有
dp[i][1][0] = dp[i - 1][0][1] + prices[i]

那么我们就可以得到递推公式：

dp[i][1][0] = dp[i - 1][0][1] + prices[i]
dp[i][0][0] = Math.max(dp[i - 1][1][0], dp[i - 1][0][0])
dp[i][0][1] = Math.max(dp[i - 1][0][0] - prices[i], dp[i - 1][0][1])
1
2
3

得到一个经验，就是通过多开维度来记录不同状态！

本题同样可以使用滚动数组优化空间复杂度！

本题Java代码：

class Solution {
    public int maxProfit(int[] prices) {
        int[][][] dp = new int[2][2][2];
        dp[0][0][1] = -prices[0];
        for (int i = 1; i < prices.length; i++) {
            dp[i % 2][1][0] = dp[(i - 1) % 2][0][1] + prices[i];
            dp[i % 2][0][0] = Math.max(dp[(i - 1) % 2][1][0], dp[(i - 1) % 2][0][0]);
            dp[i % 2][0][1] = Math.max(dp[(i - 1) % 2][0][0] - prices[i], dp[(i - 1) % 2][0][1]);
        }
        return Math.max(dp[(prices.length - 1) % 2][0][0], dp[(prices.length - 1) % 2][1][0]);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

26 - LeetCode 714 买卖股票的最佳时机含手续费

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee

题意：

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1：

输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8

示例 2：

输入：prices = [1,3,7,5,10,3], fee = 3
输出：6

提示：

1 <= prices.length <= 5 * 10⁴
1 <= prices[i] < 5 * 10⁴
0 <= fee < 5 * 10⁴

参考文章

思路：

有点简单！与《21 - LeetCode 122 买买过票的最佳时机 II》可以说基本上一致！区别仅仅在于每笔交易需要一个手续费。

那就直接在购买时候的加上手续费的成本或者在卖出的时候减去手续费就可以了，还是很简单的。我这里写为在购买的时候成本加上手续费。

本题Java代码：

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int[][] dp = new int[2][2];
        dp[0][1] = -prices[0] - fee;
        for (int i = 1; i < prices.length; i++) {
            dp[i % 2][0] = Math.max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] + prices[i]);
            dp[i % 2][1] = Math.max(dp[(i - 1) % 2][1], dp[(i - 1) % 2][0] - prices[i] - fee);
        }
        return dp[(prices.length - 1) % 2][0];
    }
}
1
2
3
4
5
6
7
8
9
10
11

子序列篇

27 - LeetCode 300 最长递增子序列

题意：

给你一个整数数组 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

提示：

1 <= nums.length <= 2500
-10⁴ <= nums[i] <= 10⁴

参考文章

思路：

使用dp[i]表示使用当前数作为递增子序列的话，所能到达的最大长度。

遍历每一个数的同时，遍历每一个在当前数之前的数字，如果它比当前数小，则当前数可以考虑加在它的最长递增子序列上，使得最长递增子序列长度+1。

递推公式：
if (nums[i] > nums[j]) dp[i] = Math.max(dp[i], dp[j] + 1)

注意：初始化时dp数组需要全部赋值为1，因为递增子序列最小为1。

本题Java代码：

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1);
        int ans = 1;
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) dp[i] = Math.max(dp[i], dp[j] + 1);
            }
            ans = Math.max(ans, dp[i]);
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

28 - LeetCode 674 最长连续递增序列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence

题意：

给定一个未经排序的整数数组，找到最长且连续递增的子序列，并返回该序列的长度。

连续递增的子序列可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。

示例 2：

输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。

提示：

1 <= nums.length <= 10⁴
-10⁹ <= nums[i] <= 10⁹

参考文章

思路：

这题比上一题还要简单。dp[i]代表将当前数作为连续递增子序列的最后一个数的话这个子序列的长度。

递推公式：
if (nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1

注意：初始化时dp数组需要全部赋值为1，因为连续递增子序列最小为1。

本题Java代码：

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1);
        int ans = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;
            ans = Math.max(ans, dp[i]);
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

另外这题还能用贪心法来做，使用count来记录当前连续递增子序列的长度，如果当前数比上一个数大，count++，反之，count=1

贪心法 Java代码：

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int count = 1, ans = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) count++;
            else count = 1;
            ans = Math.max(ans, count);
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11

29 - LeetCode 718 最长重复子数组

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray

题意：

给两个整数数组 nums1 和 nums2 ，返回两个数组中公共的、长度最长的子数组的长度。

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。

示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 100

参考文章

思路：

最长重复子数组，要想到这个重复子数组也是个连续序列。设dp[i][j]为以下标i - 1为结尾的A，和以下标j - 1为结尾的B下的最长重复子数组长度。

递推公式：
if (A[i - 1] == B[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1

解读递推公式：如果dp[i-1][j-1]不为零，意味着A[i-2]等于B[j-2]，此时如果A[i-1]等于B[j-1]，则dp[i][j]就在dp[i-1][j-1]的基础上+1。

注意，这时候dp[0][j]和dp[i][0]都是没有意义的，以为并没有A[-1]和B[-1]的元素，这时候把它们初始化为0即可，也方便计算。

本题Java代码：

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        int ans = 0;
        for (int i = 1; i <= nums1.length; i++) {
            for (int j = 1; j <= nums2.length; j++) {
                if (nums1[i - 1] == nums2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
                ans = Math.max(ans, dp[i][j]);
            }
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

30 - LeetCode 1143 最长公共子序列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-common-subsequence

题意：

给定两个字符串 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 。

提示：

1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。

参考文章

思路：

一样的，依然是设dp[i][j]为以下标i - 1为结尾的A，和以下标j - 1为结尾的B下的最长公共子序列长度。

这题与上一题的区别在于，公共子序列可以不用连续的。上一题的递推公式if (A[i - 1] == B[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1是因为必须是连续的，dp[i][j]必须由dp[i-1][j-1]得来。

既然这题不一定要连续，我们对递推公式进行修改：

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]);
1
2

在这里插入图片描述

本题Java代码：

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] dp = new int[text1.length() + 1][text2.length() + 1];
        for (int i = 1; i <= text1.length(); i++) {
            for (int j = 1; j <= text2.length(); 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[text1.length()][text2.length()];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

31 - LeetCode 1035 不相交的线

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/uncrossed-lines

题意：

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。

现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：

nums1[i] == nums2[j]
且绘制的直线不与任何其他连线（非水平线）相交。
请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。

以这种方法绘制线条，并返回可以绘制的最大连线数。

示例 1：
在这里插入图片描述
输入：nums1 = [1,4,2], nums2 = [1,2,4]
输出：2
解释：可以画出两条不交叉的线，如上图所示。
但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。

示例 2：

输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
输出：3

示例 3：

输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
输出：2

提示：

1 <= nums1.length, nums2.length <= 500
1 <= nums1[i], nums2[j] <= 2000

参考文章

思路：

这一道题一开始还看不出是什么思路，但后来发现是我看漏了，原来这是在两条独立的水平线上来连线的，那其实跟上一题就是一样的了，都是求最长公共子序列，只不过把字符串换成数字而已！

本题Java代码：

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        for (int i = 1; i <= nums1.length; i++) {
            for (int j = 1; j <= nums2.length; j++) {
                if (nums1[i - 1] == nums2[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[nums1.length][nums2.length];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

32 - LeetCode 53 最大子数组和

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-subarray

题意：

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

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

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

1 <= nums.length <= 10⁵
-10⁴ <= nums[i] <= 10⁴

参考文章

思路：

这道题其实在贪心专题里练过，贪心的思路是一路加上来，如果当前和是0就扔掉前面所有数的和。

动态规划的思路其实是差不多的。dp[i]代表最后一个数字是下标为 i 的数的子数组的和。

递推公式：dp[i] = Math.max(dp[i-1] + nums[i], nums[i])

本题Java代码：

class Solution {
    public int maxSubArray(int[] nums) {
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int ans = dp[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
            ans = Math.max(ans, dp[i]);
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

33 - LeetCode 392 判断子序列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/is-subsequence

题意：

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

示例 1：

输入：s = “abc”, t = “ahbgdc”
输出：true

示例 2：

输入：s = “axc”, t = “ahbgdc”
输出：false

提示：

0 <= s.length <= 100
0 <= t.length <= 10⁴
两个字符串都只由小写字符组成。

参考文章

思路：

这道题是编辑距离类题目的入门题目。

dp[i][j] 表示以下标 i-1 为结尾的字符串 s，和以下标 j-1 为结尾的字符串 t，相同子序列的长度为dp[i][j]。

递推公式：

if (s.charAt(i - 1) == t.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1] + 1
else dp[i][j] = dp[i][j - 1]
1
2

本题Java代码：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int[][] dp = new int[s.length() + 1][t.length() + 1];
        for (int i = 1; i <= s.length(); i++) {
            for (int j = 1; j <= t.length(); j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = dp[i][j - 1];
            }
        }
        return dp[s.length()][t.length()] == s.length();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

34 - LeetCode 115 不同的子序列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/distinct-subsequences

题意：

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

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

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

示例 1：

输入：s = “rabbbit”, t = “rabbit”
输出：3
解释：
如下图所示, 有 3 种可以从 s 中得到 “rabbit” 的方案。
rabbbit
rabbbit
rabbbit

示例 2：

输入：s = “babgbag”, t = “bag”
输出：5
解释：
如下图所示, 有 5 种可以从 s 中得到 “bag” 的方案。
babgbag
babgbag
babgbag
babgbag
babgbag

提示：

0 <= s.length, t.length <= 1000
s 和 t 由英文字母组成

参考文章

思路：

这题是上一题的升级版，但是确实是有点难度。

首先要注意的是，参数s和t表示的意义相反了。
在上一题中，是判断s是否是t的子序列；
在这道题中，是判断t在s的字序列中出现几次。

同时dp数组代表的含义也变了。
在上一题中，dp[i][j] 表示以下标 i-1 为结尾的字符串 s，和以下标 j-1 为结尾的字符串 t，相同子序列的长度为dp[i][j]，注意表示的是长度；
在这一题中，dp[i][j]表示以 i-1 为结尾的 s 子序列中出现以 j-1 为结尾的 t 的个数，注意表示的是个数。

所以这也导致出现了初始化的差异：上一题中dp[0][j]和dp[i][0]都是0，因为毕竟有一个是空串，相同长度当然是0；
在这一题中，dp[0][j]代表的是在空串中 j 出现的次数，那当然是0；dp[i][0]代表的是在 i 中空串出现的次数，那当然就是1。所以初始化的时候要注意！

递推公式：

if (s.charAt(i - 1) == t.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
else dp[i][j] = dp[i - 1][j];
1
2

当s[i - 1] 与 t[j - 1]相等时，dp[i][j]可以有两部分组成：
一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]；
一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。
所以当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];

当s[i - 1] 与 t[j - 1]不相等时，dp[i][j]只有一部分组成，不用s[i - 1]来匹配，即：dp[i - 1][j]
所以当s[i - 1] 与 t[j - 1]不相等时，dp[i][j] = dp[i - 1][j];

本题Java代码：

class Solution {
    public int numDistinct(String s, String t) {
        int[][] dp = new int[s.length() + 1][t.length() + 1];
        for (int i = 0; i <= s.length(); i++) {
            dp[i][0] = 1;
        }
        for (int i = 1; i <= s.length(); i++) {
            for (int j = 1; j <= t.length(); j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                else dp[i][j] = dp[i - 1][j];
            }
        }
        return dp[s.length()][t.length()];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

35 - LeetCode 583 两个字符串的删除操作

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/delete-operation-for-two-strings

题意：

给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。

每步可以删除任意一个字符串中的一个字符。

示例 1：

输入: word1 = “sea”, word2 = “eat”
输出: 2
解释: 第一步将 “sea” 变为 “ea” ，第二步将 "eat "变为 “ea”

示例 2:

输入：word1 = “leetcode”, word2 = “etco”
输出：4

提示：

1 <= word1.length, word2.length <= 500
word1 和 word2 只包含小写英文字母

参考文章

思路：

虽然有参考文章，但是我这道题自己写的时候其实没怎么看参考文章。

因为这道题其实跟《30 - LeetCode 1143 最长公共子序列》几乎是一模一样，我们只需要求出两个字符串的最长公共子序列的长度，然后再将两个字符串的长度和减去两倍的最长公共子序列长度，得到的就是需要删去的字符个数了。

本题Java代码：

class Solution {
    public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        for (int i = 1; i <= word1.length(); i++) {
            for (int j = 1; j <= word2.length(); j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1] + 1;
                else dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
            }
        }
        int ans = word1.length() + word2.length() - 2 * dp[word1.length()][word2.length()];
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

36 - LeetCode 72 编辑距离

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/edit-distance

题意：

给你两个单词 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’)

提示：

0 <= word1.length, word2.length <= 500
word1 和 word2 由小写英文字母组成

参考文章

思路：

dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]。

如果word1[i] == word2[j]，则无需多余操作，dp[i][j]=dp[i-1][j-1]

如果word1[i] != word2[j]，dp[i][j]可由三个状态转换而来：

由dp[i-1][j-1]转换，即将word1[i]替换为word2[j]或word2[j]替换为word1[i]
由dp[i-1][j]转换，即在word2上加上word1[i]
由dp[i][j-1]转换，即在word1上加上word2[j]

以上每个转换都是需要消耗一步。同时注意，添加一个字母和删除一个字母，效果是一样的，都是需要一个步骤。

所以得到递推公式：

if (word1.charAt(i - 1) == word2.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1];
else dp[i][j] = Math.min(Math.min(dp[i - 1][j - 1], dp[i - 1][j]), dp[i][j - 1]) + 1;
1
2

本题Java代码：

class Solution {
    public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        for (int i = 1; i <= word1.length(); i++) dp[i][0] = i;
        for (int i = 1; i <= word2.length(); i++) dp[0][i] = i;
        for (int i = 1; i <= word1.length(); i++) {
            for (int j = 1; j <= word2.length(); j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1];
                else dp[i][j] = Math.min(Math.min(dp[i - 1][j - 1], dp[i - 1][j]), dp[i][j - 1]) + 1;
            }
        }
        return dp[word1.length()][word2.length()];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

37 - LeetCode 647 回文子串

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindromic-substrings

题意：

给你一个字符串 s ，请你统计并返回这个字符串中回文子串的数目。

回文字符串是正着读和倒过来读一样的字符串。

子字符串是字符串中的由连续字符组成的一个序列。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：

输入：s = “abc”
输出：3
解释：三个回文子串: “a”, “b”, “c”

示例 2：

输入：s = “aaa”
输出：6
解释：6个回文子串: “a”, “a”, “a”, “aa”, “aa”, “aaa”

提示：

1 <= s.length <= 1000
s 由小写英文字母组成

参考文章

思路：

这道题难是难在遍历顺序的确定上。

布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。

当s[i] == s[j]时dp[i][j]能设为true的三种情况：

i == j，两个字符是同一个字符，“a”
j - i = 1，即两个字符相邻，“aa”
dp[i+1][j-1]也是回文子串

关键来了，由于dp[i][j]是由dp[i+1][j-1]推导得来的，那么遍历顺序上，i 应该就是得从大到小，j 就应该是从小到大，同时 j 应该比 i 大，即每次 j 的遍历从 i 的值开始。

本题Java代码：

class Solution {
    public int countSubstrings(String s) {
        int result = 0;
        boolean[][] dp = new boolean[s.length()][s.length()];
        for (int i = s.length() - 1; i >= 0; i--) {
            for (int j = i; j < s.length(); j++) {
                if (s.charAt(i) != s.charAt(j)) continue;
                if (j - i <= 1 || dp[i + 1][j - 1] == true) {
                    dp[i][j] = true;
                    result++;
                }
            }
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

38 - LeetCode 516 最长回文子序列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-subsequence

题意：

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

输入：s = “bbbab”
输出：4
解释：一个可能的最长回文子序列为 “bbbb” 。

示例 2：

输入：s = “cbbd”
输出：2
解释：一个可能的最长回文子序列为 “bb” 。

提示：

1 <= s.length <= 1000
s 仅由小写英文字母组成

参考文章

思路：

注意这道题是求回文子序列，而不是回文子串。子串是连续的，子序列可以是不用连续的。

dp[i][j]代表字符串s在[i, j]范围内最长的回文子序列的长度。

首先进行初始化，所有dp[i][i]都是单个字符，都是回文子序列，都初始化为1。

递推公式：

if (s.charAt(i) == s.charAt(j)) dp[i][j] = dp[i + 1][j - 1] + 2;
else dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
1
2

注意当s[i] == s[j]时子序列的长度增加是增加2，不要写快写成+1。

遍历顺序遇上一题同理。

本题Java代码：

class Solution {
    public int longestPalindromeSubseq(String s) {
        int[][] dp = new int[s.length()][s.length()];
        for (int i = 0; i < s.length(); i++) dp[i][i] = 1;
        for (int i = s.length() - 1; i >= 0; i--) {
            for (int j = i + 1; j < s.length(); j++) {
                if (s.charAt(i) == s.charAt(j)) dp[i][j] = dp[i + 1][j - 1] + 2;
                else dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
            }
        }
        return dp[0][s.length() - 1];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/码创造者/article/detail/1020101

动态规划类题目专题训练 -- LeetCode上38道与动态规划相关的题_leetcode力扣动态规划(进阶版)题目

目录

基础篇

1 - LeetCode 509 斐波那契数

2 - LeetCode 70 爬楼梯

3 - LeetCode 746 使用最小花费爬楼梯

4 - LeetCode 62 不同路径

5 - LeetCode 63 不同路径 II

6 - LeetCode 343 整数拆分

7 - LeetCode 96 不同的二叉搜索树

背包篇

8 - LeetCode 416 分割等和子集

9 - LeetCode 1049 最后一块石头的重量 II

10 - LeetCode 494 目标和

11 - LeetCode 474 一和零

12 - LeetCode 518 零钱兑换 II

13 - LeetCode 377 组合总和 IV

14 - LeetCode 70 爬楼梯

15 - LeetCode 322 零钱兑换

16 - LeetCode 279 完全平方数

17 - LeetCode 139 单词拆分

打家劫舍篇

18 - LeetCode 198 打家劫舍

19 - LeetCode 213 打家劫舍 II

20 - LeetCode 337 打家劫舍 III

股票篇

21 - LeetCode 121 买卖股票的最佳时机

22 - LeetCode 122 买买过票的最佳时机 II

23 - LeetCode 123 买卖股票的最佳时机 III

24 - LeetCode 188 买卖股票的最佳时机 IV

25 - LeetCode 309 最佳买卖股票时机含冷冻期

26 - LeetCode 714 买卖股票的最佳时机含手续费

子序列篇

27 - LeetCode 300 最长递增子序列

28 - LeetCode 674 最长连续递增序列

29 - LeetCode 718 最长重复子数组

30 - LeetCode 1143 最长公共子序列

31 - LeetCode 1035 不相交的线

32 - LeetCode 53 最大子数组和

33 - LeetCode 392 判断子序列

34 - LeetCode 115 不同的子序列

35 - LeetCode 583 两个字符串的删除操作

36 - LeetCode 72 编辑距离

37 - LeetCode 647 回文子串

38 - LeetCode 516 最长回文子序列