LeetCode部分习题解答记录－动态规划
动态规划
一般来说，碰到一个问题，可以先自顶向下的思考，然后使用动态规划来解决问题。在实际中，记忆化搜索一般都可以满足代码的需求，但是DP的代码更加简洁。
- 最优子结构：通过求解子问题的最优解，可以获得原问题的最优解。
120.三角形最小路径和
方法：递归+记忆化
- 思路：
- 代码演示：
class Solution {
//整形数组默认初始化为0，因此用Integer
Integer[][] memo;
public int minimumTotal(List<List<Integer>> triangle) {
int len = triangle.size();
this.memo = new Integer[len][len];
return dfs(triangle,0,0);
}
public int dfs(List<List<Integer>> triangle,int i ,int j){
if(i == triangle.size()){
return 0;
}
if(memo[i][j] != null){
return memo[i][j];
}
return memo[i][j] = Math.min(dfs(triangle,i+1,j),dfs(triangle,i+1,j+1)) + triangle.get(i).get(j);
}
}
方法2:DP
- 代码演示：
class Solution {
public int minimumTotal(List<List<Integer>> triangle) {
int len = triangle.size();
//dp长度多一个，因此当处理最后一个数，不用进行边界判断。
int[] dp = new int[len+1];
for(int i = len -1 ; i >= 0; i--){
for(int j = 0; j <= i ; j++){
dp[j] = Math.min(dp[j],dp[j+1]) + triangle.get(i).get(j);
}
}
return dp[0];
}
}
64.最小路径和
看讲解：https://leetcode-cn.com/problems/minimum-path-sum/solution/hui-su-dao-dong-tai-gui-hua-zai-dao-kong-swk9/
方法1:递归
- 递归树：
- 代码演示1：未使用记忆化搜索
class Solution{
private int minPathSum = Integer.MAX_VALUE;
private int[][] dirs = {{1, 0}, {0, 1}};
public int minPathSum(int[][] grid) {
dfs(grid, 0, 0, grid[0][0]);
return minPathSum;
}
//每次到达叶子节点后，跟当前的最小值进行比较取最小。
private void dfs(int[][] grid, int row, int col, int sum) {
if (row == grid.length - 1 && col == grid[0].length - 1) {
minPathSum = Math.min(minPathSum, sum);
return;
}
for (int[] dir : dirs) {
int nextRow = row + dir[0];
int nextCol = col + dir[1];
if (nextRow < 0 || nextCol < 0
|| nextRow >= grid.length
|| nextCol >= grid[0].length) continue;
sum += grid[nextRow][nextCol];
dfs(grid, nextRow, nextCol, sum);
sum -= grid[nextRow][nextCol];
}
}
}
- 递归树：
- 代码演示2：使用记忆化搜索
class Solution {
int[][] DIRECTIONS = new int[][]{{0,1},{1,0}};
Integer[][] memo;
int rows;
int cols;
int[][] grid;
public int minPathSum(int[][] grid) {
this.grid = grid;
this.rows = grid.length;
this.cols = grid[0].length;
this.memo = new Integer[rows][cols];
return dfs(0,0);
}
public int dfs(int x , int y){
if(x == rows-1 && y == cols-1){
return grid[x][y];
}
//因为可能会多次到达某一节点进行求最小路径，因此可以进行判断当前节点是否已经处理过
if(memo[x][y] != null){
return memo[x][y];
}
/*
min:当前节点的下一个节点到终点的最小路径和
curSim:当前节点的某一方向的下一个节点到终点的最小路径和，经过方向比较，可以得出min
return：返回当前节点到终点的最小路径和，min+grid[x][y]。也就是下一个节点的最小路径和加上本节点的值
*/
int min = Integer.MAX_VALUE;
for(int[] direct : DIRECTIONS){
int newX = x + direct[0];
int newY = y + direct[1];
if(!judge(newX,newY)){
continue;
}
int curSum = dfs(newX,newY);
min = Math.min(min,curSum);
}
return memo[x][y] = min + grid[x][y];
}
public boolean judge(int x,int y){
return x>=0 && x < rows && y >=0 && y < cols;
}
}
方法2:DP
从终点到起点，逐步更新
- 代码演示
class Solution {
int[][] DIRECTIONS = new int[][]{{0,1},{1,0}};
Integer[][] memo;
int rows;
int cols;
int[][] grid;
public int minPathSum(int[][] grid) {
this.grid = grid;
this.rows = grid.length;
this.cols = grid[0].length;
//memo,存储的（i,j）到终点的最小路径和
this.memo = new Integer[rows][cols];
memo[rows-1][cols-1] = grid[rows-1][cols-1];
for(int i = rows-1 ; i >= 0 ;i--){
for(int j = cols - 1 ; j >= 0 ; j--){
//最后一行
if(i == rows-1 && j != cols-1){
memo[i][j] = grid[i][j] + memo[i][j+1];
}
//最后一列
else if(i != rows-1 && j == cols-1){
memo[i][j] = grid[i][j] + memo[i+1][j];
}else if(i != rows - 1 && j != cols -1){
memo[i][j] = grid[i][j] + Math.min(memo[i][j+1],memo[i+1][j]);
}
}
}
return memo[0][0];
}
}
从起点到终点，逐步更新
- 代码演示
public int minPathSum(int[][] grid) {
int m = grid.length;
int n = grid[0].length;
// 状态定义：dp[i][j] 表示从 [0,0] 到 [i,j] 的最小路径和
int[][] dp = new int[m][n];
// 状态初始化
dp[0][0] = grid[0][0];
// 状态转移
for (int i = 0; i < m ; i++) {
for (int j = 0; j < n ; j++) {
if (i == 0 && j != 0) {
dp[i][j] = grid[i][j] + dp[i][j - 1];
} else if (i != 0 && j == 0) {
dp[i][j] = grid[i][j] + dp[i - 1][j];
} else if (i != 0 && j != 0) {
dp[i][j] = grid[i][j] + Math.min(dp[i - 1][j], dp[i][j - 1]);
}
}
}
// 返回结果
return dp[m - 1][n - 1];
}
从上两种方式可以看到，每一次状态更新只与上一层的状态相关。因此，状态转移矩阵可定义为一维数组。
- 代码演示:
public int minPathSum(int[][] grid) {
int m = grid.length;
int n = grid[0].length;
// 状态定义：dp[i] 表示从 (0, 0) 到达第 i - 1 行的最短路径值
int[] dp = new int[n];
// 状态初始化
dp[0] = grid[0][0];
// 状态转移
for (int i = 0; i < m ; i++) {
for (int j = 0; j < n ; j++) {
if (i == 0 && j != 0) {
dp[j] = grid[i][j] + dp[j - 1];
} else if (i != 0 && j == 0) {
dp[j] = grid[i][j] + dp[j];
} else if (i != 0 && j != 0) {
dp[j] = grid[i][j] + Math.min(dp[j], dp[j - 1]);
}
}
}
// 返回结果
return dp[n - 1];
}
- 注意事项：在二维DP数组的相应算法中，其实可以用原始的grid数组作为DP数组。因为遍历过的数组值改变为DP状态值，对整个结果并无影响。
public int minPathSum(int[][] grid) {
int m = grid.length;
int n = grid[0].length;
for (int i = 0; i < m ; i++) {
for (int j = 0; j < n ; j++) {
if (i == 0 && j != 0) {
grid[i][j] = grid[i][j] + grid[i][j - 1];
} else if (i != 0 && j == 0) {
grid[i][j] = grid[i][j] + grid[i - 1][j];
} else if (i != 0 && j != 0) {
grid[i][j] = grid[i][j] + Math.min(grid[i - 1][j], grid[i][j - 1]);
}
}
}
return grid[m - 1][n - 1];
}
343.整数拆分
题解：https://leetcode-cn.com/problems/integer-break/solution/bao-li-sou-suo-ji-yi-hua-sou-suo-dong-tai-gui-hua-/
自顶向底
- 代码演示
class Solution {
int[] memo;
public int integerBreak(int n) {
this.memo = new int[n+1];
return dfs(n);
}
public int dfs(int n){
if(n == 2){
return 1;
}
if(memo[n] != 0){
return memo[n];
}
//记录当前最大值，依次更新
int res = -1;
for(int i = 1 ; i < n ;i++){
res = Math.max(res,Math.max(i * (n-i),i * (dfs(n-i))));
}
//将最大存入
memo[n] = res;
return memo[n];
}
}
方法2：DP，自底向上
- 代码演示
class Solution {
public int integerBreak(int n) {
//长度为n+1，题目定义n<=2
int[] dp = new int[n+1];
dp[2] = 1;
for(int i = 3;i<=n;i++){
int curMax = 0;
for(int j = 1; j < i;j++){
curMax = Math.max(curMax,Math.max(j * (i-j),j * dp[i-j]));
}
dp[i] = curMax;
}
return dp[n];
}
}
279.完全平方数
方法1-4：在栈与队列篇
方法5：DP
class Solution {
public int numSquares(int n) {
int[] dp = new int[n + 1];
dp[1] = 1;
for(int i = 2; i <= n ;i++){
int count = Integer.MAX_VALUE;
for(int j = 1 ; i - j * j >= 0 ;j ++){
count = Math.min(count,dp[i-j*j]+1);
}
dp[i] = count;
}
return dp[n];
}
}
91.解码方法
方法1：DP
-
思路：这个问题有点像 「力扣」第 70 题：爬楼梯，背后的思想是「分类计数加法原理」和「分步计数乘法原理」。
-
代码中所示情况如图所示。
-
代码演示：
class Solution {
public int numDecodings(String s) {
int len = s.length();
if(s.charAt(0) == '0'){
return 0;
}
//dp[i]前i位，也就是s[i-1]能够组成多少种编码
int[] dp = new int[len+1];
//初始状态，dp[0]=1，为了方便计算dp[2] += dp[0];
dp[0] = 1;
dp[1] = 1;
for(int i = 2; i <= len ; i++){
//如果第i位是一个有效编码位，则dp[i] = dp[i-1] * 1;
if(s.charAt(i-1) != '0'){
dp[i] = dp[i-1];
}
//如果第i位可以与第i-1位组成有效编码，则的dp[i] += dp[i-2];
int num = 10 * (s.charAt(i-2) - '0') + (s.charAt(i-1) - '0');
if(num >= 10 && num <= 26){
dp[i] += dp[i-2];
}
}
return dp[len];
}
}
62.不同路径
- 题解：https://leetcode-cn.com/problems/unique-paths/solution/dong-tai-gui-hua-di-gui-gong-shi-deng-3z-9mp1/
方法1：DP
- 思路：状态转移矩阵定义为起点到当前点的路径数。则分为三种情况。
- 当前位置在最左边。 dp[i][j] = 1，从起点开始只能往下走才能到达该位置
- 当前位置在最上面。 dp[i][j] = 1，从起点开始只能往右走才能到达该位置
- 其他位置。 dp[i][j] = dp[i-1][j] + dp[i][j-1];
- 代码演示：
class Solution {
int[][] dp;
public int uniquePaths(int m, int n) {
//dp表示起点到改点共有多少种路径
this.dp = new int[m][n];
dp[0][0] = 1; //初始状态
//第一列
for(int i = 0;i < m;i++){
dp[i][0] = 1;
}
for(int i = 0;i < n;i++){
dp[0][i] = 1;
}
for(int i = 1; i < m ;i++){
for(int j = 1; j < n ;j++){
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
return dp[m-1][n-1];
}
}
方法2：在DP上进行空间的优化
- 思路由方法1可知，当前dp状态只与左边与上边的dp状态值有关。因此，二维数组dp可改为1维。
- 代码演示：
class Solution {
public int uniquePaths(int m, int n) {
int[] dp = new int[n];
//全以1填充，表示第一行的n个位置路径数都为1
Arrays.fill(dp, 1);
for (int j = 1; j < m; j++)
//j从1开始取，因为第一列的状态值全为1，因为只能往下走才能到达。
for (int i = 1; i < n; i++)
dp[i] += dp[i - 1];
return dp[n - 1];
}
}
方法3：递归+记忆化搜索
- 思路：由下图可以看到，运用递归的方法。从起点到终点的过程中，会产生大量的重复计算，因此需要采用记忆化。
- 代码演示：时间消耗相比于前两种较高
class Solution {
int m;
int n;
Map<String,Integer> memo = new HashMap<>();
public int uniquePaths(int m, int n) {
this.m = m;
this.n = n;
return dfs(0,0);
}
public int dfs(int x ,int y){
if(x >= m || y >= n){
return 0;
}
if(x == m -1 && y == n-1){
return 1;
}
String key = x + "*" + y;
if(!memo.containsKey(key)){
int right = dfs(x +1,y);
int down = dfs(x,y+1);
int total = right+down;
memo.put(key,total);
}
return memo.get(key);
}
}
63.不同路径 II
- 思路：运用62的思路，对障碍物位置进行特殊判断即可。
- 代码演示
class Solution {
int[][] dp;
int m;
int n;
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
if(obstacleGrid[0][0] == 1){
return 0;
}
this.m = obstacleGrid.length;
this.n = obstacleGrid[0].length;
dp = new int[m][n];
dp[0][0] = 1;
//第一行
for(int i = 1 ;i < n ; i ++){
if(obstacleGrid[0][i] == 1){
break;
}
dp[0][i] = 1;
}
//第一列
for(int j = 1; j < m ;j++){
if(obstacleGrid[j][0] == 1){
break;
}
dp[j][0] = 1;
}
for(int i = 1 ; i < m; i ++){
for(int j = 1; j < n; j++){
if(obstacleGrid[i][j] == 1){
continue;
}
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
return dp[m-1][n-1];
}
}
198.打家劫舍
方法1：DP
- 代码演示：
class Solution {
int[] dp;
public int rob(int[] nums) {
int len = nums.length;
this.dp = new int[len+1];
//状态初始值设置，dp记录到达当前房间我们所计算出的最大值。dp[i]代表前i个房间所盗取的最大值
dp[0] = 0;
dp[1] = nums[0];
int max = nums[0];
for(int i = 2 ; i <= len ;i++){
for(int j = 0 ; j < i - 1 ;j ++){
/*
内循环遍历，寻找 当前房间+以往dp值 与 之前的最大值进行比较。
记录最大值，为到达当前房间的最大值，也就为dp[i]的值
注意事项，房间不能相邻，因此循环条件为j<i-1
*/
max = Math.max(max,dp[j] + nums[i-1]);
}
dp[i] = max;
}
return dp[len];
}
}
方法2：方法1的优化
- 思路：在方法1中，我们是使用max依次进行比较，实际上。dp[i]状态数组存储的就是前i个房间能抢到的最大金额值。因此，内循环比较可以省去。只需要判断的当前房间+隔一个房间的dp值，与前一个房间的dp值大小，以此来进行dp的更新。Math.max(dp[i-1],dp[i-2] + nums[i-1])。
- 由于不可以在相邻的房屋闯入，所以在当前位置 n 房屋可盗窃的最大值，要么就是前 n-1 房屋可盗窃的最大值，要么就是 前n-2 房屋可盗窃的最大值加上当前房屋的值，二者之间取最大值。
class Solution {
int[] dp;
public int rob(int[] nums) {
int len = nums.length;
this.dp = new int[len+1];
//状态初始值设置，dp记录到达当前房间我们所计算出的最大值
dp[0] = 0;
dp[1] = nums[0];
for(int i = 2 ; i <= len ;i++){
/*
dp[i-1]可能是由dp[i-3]+nums[i-1]所得。
dp[i-2]肯定不包括nums[i]的相邻房间。
*/
dp[i] = Math.max(dp[i-1],dp[i-2] + nums[i-1]);
}
return dp[len];
}
}
方法3：递归+记忆化搜索
- 思路：自底向上，如下图。
- 代码演示：
class Solution {
//memo[i] 表示考虑抢劫nums[i...n)所能获得的最大收益
Integer[] memo;
int len;
int[] nums;
public int rob(int[] nums) {
this.len = nums.length;
this.memo = new Integer[len];
this.nums = nums;
return dfs(0);
}
//考虑抢劫nums[index...n)这个范围内的房间
public int dfs(int index){
if(index >= len){
return 0;
}
if(memo[index] != null){
return memo[index];
}
int res = -1;
for(int i = index ; i < len ; i++){
res = Math.max(res,nums[i] + dfs(i+2));
}
memo[index] = res;
return res;
}
}
- 类似修改的递归代码：
213.打家劫舍 II
方法1：DP
- 思路：因为首尾不能连接。因此，我们将当前房间分为两组，一组为为nums[0…len-2]，一组为nums[1…len-1]。分别求出这两组所能盗取的最大值，然后取最大即可。
- 代码演示：
class Solution {
public int rob(int[] nums) {
int len = nums.length;
if(len == 1){
return nums[0];
}
int res1 = maxValue(nums,0,len-2);
int res2 = maxValue(nums,1,len-1);
return Math.max(res1,res2);
}
public int maxValue(int[] nums, int start,int end){
if(start == end){
return nums[start];
}
int len = nums.length;
//dp[i]:表示第i天所偷到的最大金额
int[] dp = new int[len+1];
dp[start] = 0;
dp[start+1] = nums[start];
/*
原循环格式为
for(int i = 2 ; i <= len;i++){
dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i-1]);
}
因为起始位置与结束位置发生变化，因此循环的起始于终止位置也需要改变
*/
for(int i = start + 2 ; i <= end+1;i++){
dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i-1]);
}
return dp[end+1];
}
}
337.打家劫舍 III
- 题解：https://leetcode-cn.com/problems/house-robber-iii/solution/shu-xing-dp-ru-men-wen-ti-by-liweiwei1419/
方法1：动态规划
- 思路：
- 这里最关键的是理解：在设计状态的时候，在后面加一维，消除后效性，打家劫舍第 1 题，股票系列问题 6 个问题，都是这样的思路；
- 树的问题，很多时候采用后序遍历。
- 代码演示：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rob(TreeNode root) {
int[] res = dfs(root);
return Math.max(res[0],res[1]);
}
public int[] dfs(TreeNode root){
if(root == null){
return new int[]{0,0};
}
// 分类讨论的标准是：当前结点偷或者不偷
// 由于需要后序遍历，所以先计算左右子结点，然后计算当前结点的状态值
int[] left = dfs(root.left);
int[] right = dfs(root.right);
// dp[0]：以当前 node 为根结点的子树能够偷取的最大价值，规定 node 结点不偷
// dp[1]：以当前 node 为根结点的子树能够偷取的最大价值，规定 node 结点偷
int[] dp = new int[2];
dp[0] = Math.max(left[0],left[1]) + Math.max(right[0],right[1]);
//当前结点偷，则左右孩子节点都不偷。 则root.val + left[0] + right[0]，当前值+左不偷+右不偷
dp[1] = root.val + left[0] + right[0];
return dp;
}
}
152. 乘积最大子数组（理解无后效性）
- 思路：与337题类似，337题dp[i][0]或者dp[i][1]是考虑当前节点选还是不选。而此题dp[i][0]或者dp[i][1]是考虑nums[0…i]中的最大乘序列与最小乘序列。
- 总结而言：也就是说，每个位置可能有对应的两种状况，且这两种状况都是有意义的，对结果有影响的。就可以二维，来分别对应其中的一种状况。实际上就是两个一维数组放在了一起而已。
- 代码演示：
class Solution {
int[][] dp;
public int maxProduct(int[] nums) {
int len = nums.length;
if(len == 0){
return 0;
}
this.dp = new int[len][2];
dp[0][0] = nums[0];
dp[0][1] = nums[0];
int max = dp[0][1];
for(int i = 1; i < len ; i++){
if(nums[i] >= 0){
//如果当前nums[i]>=0，且dp[i-1][0]>0,则最小值为nums[i]。因此需要做Math.min的比较。以下同理。
dp[i][0] = Math.min(nums[i],dp[i-1][0] * nums[i]);
dp[i][1] = Math.max(nums[i],dp[i-1][1] * nums[i]);
}else{
dp[i][0] = Math.min(nums[i],dp[i-1][1] * nums[i]);
dp[i][1] = Math.max(nums[i],dp[i-1][0] * nums[i]);
}
//取最大
max = Math.max(max,dp[i][1]);
}
return max;
}
}
面试题 17.16. 按摩师
- 题解：https://leetcode-cn.com/problems/the-masseuse-lcci/solution/dong-tai-gui-hua-by-liweiwei1419-8/
- 思路：DP。与打家劫舍一致
- 代码演示：
class Solution {
int dp[];
public int massage(int[] nums) {
int len = nums.length;
this.dp = new int[len+1];
if(len == 0){
return 0;
}
dp[0] = 0;
dp[1] = nums[0];
for(int i = 2; i <= len;i++){
dp[i] = Math.max(dp[i-1],dp[i-2] + nums[i-1]);
}
return dp[len];
}
}
-
运用消除后效性的方法
-
思路：
- dp[i][0] 表示：区间 [0…i] 里接受预约请求，并且下标为 i 的这一天不接受预约的最大时长；
- dp[i][1] 表示：区间 [0…i] 里接受预约请求，并且下标为 i 的这一天接受预约的最大时长。
- 今天不接受预约：昨天不接受预约，或者昨天接受了预约，取二者最大值，即：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1])；
- 今天接受预约：只需要从昨天不接受预约转移而来，加上今天的时常，即：dp[i][1] = dp[i - 1][0] + nums[i]。
-
代码演示：
class Solution {
int[][] dp;
public int massage(int[] nums) {
int len = nums.length;
this.dp = new int[len][2];
if(len == 0){
return 0;
}
dp[0][0] = 0;
dp[0][1] = nums[0];
for(int i = 1; i < len;i++){
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]);
dp[i][1] = dp[i-1][0] + nums[i];
}
return Math.max(dp[len-1][0],dp[len-1][1]);
}
}
309. 最佳买卖股票时机含冷冻期
- 题解：
- https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/solution/zhuang-tai-ji-mo-xing-dp-by-acw_wangdh15/
- https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/solution/dong-tai-gui-hua-by-liweiwei1419-5/
方法1：DP+消除后效性
- 思路:如图所示，在一天中有三个状态。
- 0：手中无股票。这个状态可以是前一天就没有股票，也可以是刚卖出（处于冷冻期休息一天）。
- 1：手工有股票。这个状态可以前一天刚买入，也可以是前一天手中就有股票。
- 2：冷冻期：这个状态表示前一天刚卖出。
- 需要对每一天的每个状态都取最优值
- 代码演示：
class Solution {
int[][] dp;
int len;
public int maxProfit(int[] prices) {
this.len = prices.length;
if(len == 0){
return 0;
}
//dp[i]表示[0...i]手上的现金数
this.dp = new int[len+1][3];
//初始状态矩阵，
dp[0][0] = 0;
dp[0][1] = -prices[0];
dp[0][2] = 0;
for(int i = 1 ; i < len ;i++){
//分别对应三种状态的计算
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][2]);
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0] - prices[i]);
dp[i][2] = dp[i-1][1] + prices[i];
}
//因为每一步都是最优值，因此最后一天手中还存有股票，现金肯定会低会其余状态低。因此只需要比较状态0与状态2
return Math.max(dp[len-1][0],dp[len-1][2]);
}
}
121.买卖股票的最佳时机
方法1：DP+无后效性
- 与309题类似。只是注意，这次交易只允许买卖一次。
- 代码演示：
class Solution {
int[][] dp;
public int maxProfit(int[] prices) {
int len = prices.length;
if(len == 0){
return 0;
}
this.dp = new int[len+1][2];
dp[0][0] = 0;
dp[0][1] = -prices[0];
for(int i = 1 ; i <= len ;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[len][0];
}
}
122. 买卖股票的最佳时机 II
方法1：DP+无后效性
- 思路：类似于上题
- 代码演示：
class Solution {
int[][] dp;
public int maxProfit(int[] prices) {
int len = prices.length;
if(len == 0){
return 0;
}
this.dp = new int[len+1][2];
dp[0][0] = 0;
dp[0][1] = -prices[0];
for(int i = 1 ; i <= len ;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],dp[i-1][0] - prices[i-1]);
}
return dp[len][0];
}
}
方法2：贪心算法，暂留
714. 买卖股票的最佳时机含手续费
方法1：DP+无后效性
-
思路:dp[i]表示[0…i]天所拥有的现金总额。
- 当前有两种状态，有股和无股。根据状态转移画出状态图
- 当前有两种状态，有股和无股。根据状态转移画出状态图
-
代码演示：
class Solution {
int[][] dp;
public int maxProfit(int[] prices, int fee) {
int len = prices.length;
if(len == 0){
return 0;
}
this.dp = new int[len][2];
dp[0][0] = 0;
dp[0][1] = -prices[0];
for(int i = 1; i < len ;i++){
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1] + prices[i] - fee);
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0] - prices[i]);
}
return dp[len-1][0];
}
}
方法2：贪心算法，暂留
0-1背包问题
方法1：递归+记忆化
- 状态转移方程。
自顶向下
- 代码演示：
public class Knapsack01 {
public static Integer[][] memo;
public static void main(String[] args) {
int[] w = new int[]{1,2,3};
int[] v = new int[]{6,10,12};
int c = 5;
System.out.println(knapsack01(w,v,c));
}
/**
*
* @param w 物品的重量数组
* @param v 物品的价值数组
* @param c 背包的容积为c
* @return
*/
public static int knapsack01(int[] w,int[] v,int c){
int len = w.length;
memo = new Integer[len][c+1];
return bestVale(w,v,len-1,c);
}
//用[0...index]的商品，填充容器为c的背包的最大价值
private static int bestVale(int[] w, int[] v, int index, int c) {
//终止条件，物品搜索结束或者当前背包已满
if(index < 0 || c <= 0){
return 0;
}
if(memo[index][c] != null){
return memo[index][c];
}
int res = bestVale(w,v,index-1,c);
//当当前容量大于物品的重量时，才考虑放入
if(c >= w[index]){
res = Math.max(res,v[index] + bestVale(w,v,index-1,c-w[index]));
}
memo[index][c] = res;
return res;
}
}
方法2：递归
-
思路：dp中有两个状态组成二维数组。行：为考虑的物品；列，为背包的剩余容量。
-
代码演示：
public static int dp(int[] w,int[] v,int c){
//i:物品，j：背包的剩余重量
for(int i = 0 ; i < w.length;i++){
for(int j = 1 ; j <= c ;j++){
//因为第一行只有一个物品，因此第一行特殊处理
if(i == 0){
//dp[i][j] = v[i];
//当前背包容量可以放下物品，填充物品价值，否则填充0
dp[i][j] = weights[i] <= j ? values[i] : 0;
}else{
//若当前物品的重量大于背包的剩余重量，则直接取上一行数值
if(w[i] > j){
dp[i][j] = dp[i-1][j];
}else{
//放入当前物品的价值与剩余容量所能容纳的物品价值，与不放入当前物品的价值（直接取上一行）作比较，取最大值
dp[i][j] = Math.max(v[i] + dp[i-1][j-w[i]],dp[i-1][j]);
}
}
}
}
return dp[w.length-1][c];
}
- 代码优化：
public static int dp2(int[] w,int[] v,int c){
for(int i = 1 ; i <= c ;i++){
dp[0][i] = (i>= w[0] ? v[0] : 0);
}
//i:物品，j：背包的剩余重量
for(int i = 1 ; i < w.length;i++){
for(int j = 1 ; j <= c ;j++){
if(w[i] > j){
dp[i][j] = dp[i-1][j];
} else {
dp[i][j] = Math.max(v[i] + dp[i - 1][j - w[i]], dp[i - 1][j]);
}
}
}
return dp[w.length-1][c];
}
- 代码优化，空间优化:因为每个位置只有前一行有关，因此dp数组进行空间优化。
private static int dp3(int[] w, int[] v, int c) {
dp1 = new int[c+1];
//第一行
for(int i = 1; i <= c ;i++){
dp1[i] = (i > w[0] ? v[0] : 0);
}
for(int i = 1 ; i < w.length ; i++){
for(int j = 1 ; j <= c; j++){
if(w[i] <= j){
dp1[j] = Math.max(dp1[j],v[i] + dp1[j-w[i]]);
}
}
}
return dp1[c];
}
300.最长递增子序列
- 题解：https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/dong-tai-gui-hua-er-fen-cha-zhao-tan-xin-suan-fa-p/
方法1：DP
- 思路：
- 因为题目要求输出的为最长上升子序列的长度，因此当前状态与之前的所有状态都相关。定义dp[i]为以第i个数字为结尾的最长上升子序列的长度，因此状态转移需要进行内部循环。
- 代码演示：
class Solution {
int[] dp;
public int lengthOfLIS(int[] nums) {
int len = nums.length;
if(len == 0){
return 0;
}
//dp[i]表示以i为结尾的最长上升子序列
this.dp = new int[len];
//初始值都为1，都是以自己构成最长子序列
Arrays.fill(dp,1);
int max = 1;
//当前选择的数
for(int i = 1;i < len ;i++){
//判断当前选择的数与之前的数的大小
for(int j = 0 ; j < i ;j++){
//如果大于，则说明当前数可以与之前数构成最长子序列
if(nums[i] > nums[j]){
dp[i] = Math.max(dp[i],dp[j] + 1);
//记录当前子序列长度的最大值
max = Math.max(dp[i],max);
}
}
}
return max;
}
}
方法2：TreeSet
- 思路：
- 利用更简单的API TreeSet的Ceiling方法，应该是logN？？但是最坏情况下会退化
- TreeSet.ceiling(x)方法可以直接找出set中大于x的最小数字，如果不存在则返回null。
- 如果这个数字存在，则删除这个数字，然后把x插入set中，相当于代替该数字。
- 如果这个数字不存在，说明x大于set中任何数字，直接把x插入set中。
- 最后返回set的大小即可
class Solution {
public int lengthOfLIS(int[] nums) {
TreeSet<Integer> set = new TreeSet<>();
//set.size()一直都是为当前的最大长度。
//假设8，9，1，2,3。此时set中有89，长度为2。遍历1时，弹出8。此时长度还为2。遍历2时，弹出9，此时set为12，长度还为2。
for (int i = 0; i < nums.length; i++) {
Integer c = set.ceiling(nums[i]);
//如果set中没有大于nums[i]的最小数字，那么就符合最长上升子序列，加入
//如果有，把让那个移除那个数字，换做这个nums[i]，因为nums[i]更小
//其实这边先判断 c!=null代码会更为简洁一点
if (c == null) {
set.add(nums[i]);
} else {
set.remove(c);
set.add(nums[i]);
}
}
return set.size();
}
}
方法3：贪心算法。暂留
376.摇摆序列
方法1：DP
- dp[i]代表[0…i]内的最长摇摆子序列长度。
- 因为当前状态的转移只与当前值与前一个值的大小相关，所以当前状态是从前一个值的状态转移而来。
- [i][0]代表当前状态属于递减序列。
- [i][1]代表当前状态属于递增序列。
- 代码演示：
class Solution {
int[][] dp;
public int wiggleMaxLength(int[] nums) {
int len = nums.length;
if(len == 0){
return 0;
}
this.dp = new int[len][2];
for(int i = 0 ; i<len ;i++){
Arrays.fill(dp[i],1);
}
for(int i = 1 ; i < len ; i++){
int num = nums[i] - nums[i-1];
if(num == 0){
dp[i][0] = dp[i-1][0];
dp[i][1] = dp[i-1][1];
}else if (num < 0){
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+1);
dp[i][1] = dp[i-1][1];
}else{
dp[i][0] = dp[i-1][0];
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+1);
}
}
return Math.max(dp[len-1][0],dp[len-1][1]);
}
}
方法2：方法1的优化
- 思路：由方法可以看出，当前状态只与前一个状态相关。因此，定义两个常数来分别记录上升序列与下降序列的最大值。
- 代码演示：
class Solution {
public int wiggleMaxLength(int[] nums) {
int len = nums.length;
if(len < 2){
return len;
}
int up = 1;
int down = 1;
for(int i = 1; i < len ;i++){
int num = nums[i] - nums[i-1];
if(num < 0){
down = Math.max(up+1,down);
}else if (num > 0){
up = Math.max(down+1,up);
}
}
return Math.max(down,up);
}
}
1143.最长公共子序列
- 题解：https://leetcode-cn.com/problems/longest-common-subsequence/solution/1143-zui-chang-gong-gong-zi-xu-lie-dong-zde2v/
方法1：DP
-
思路：
- 树形
- 树形
-
代码演示：
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
int len1 = text1.length();
int len2 = text2.length();
char[] array1 = text1.toCharArray();
char[] array2 = text2.toCharArray();
int[][] dp = new int[len1 + 1][len2 +1];
for(int i = 1 ; i <= len1 ;i++){
for(int j = 1 ; j <= len2;j++){
if(array1[i-1] == array2[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]);
}
}
}
return dp[len1][len2];
}
}
1083
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
