【算法练习】leetcode算法题合集之动态规划篇

作者：我家小花儿 | 2024-06-05 10:56:09

踩

普通动规系列

LeetCode343. 整数拆分

将10的结果存在索引为10的位置上，需要保证数组长度是n+1，索引的最大值是n，索引是从0开始的。

n的拆分，可以拆分为i和n-i，当然i可以继续拆分。而且拆分为n-1和1的结果和n-2和2的结果的大小也是不一定的。

class Solution {
   
    public int integerBreak(int n) {
   
        int[] dp = new int[n + 1];
        for (int i = 2; i <= n; i++) {
   
            int max = 0;
            for (int j = 1; j < i; j++) {
   
                max = Math.max(max, Math.max(dp[i - j] * j, (i - j) * j));
            }
            dp[i] = max;
        }
        return dp[n];

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

LeetCode70. 爬楼梯

需要考虑n==1的情况。

class Solution {
   
    public int climbStairs(int n) {
   
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[0] = 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
12
13
14

LeetCode96. 不同的二叉搜索树

n==3的时候，可以分为左0右2，左1右1的情况，左2右0的情况。如果左边有2个组合，右边有3个组合，那么总共有6个组合。

子节点需要占用1个节点，所以j的范围在[1,i]。

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

路径规划系列

LeetCode62. 不同路径

在边上，路径为1；

在中心点，路径为左边+上边。

class Solution {
   
    public int uniquePaths(int m, int n) {
   
        int[][] res = new int[m][n];
        for (int i = 0; i < m; i++) {
   
            for (int j = 0; j < n; j++) {
   
                if (i == 0 || j == 0) {
   
                    res[i][j] = 1;
                } else {
   
                    res[i][j] = res[i - 1][j] + res[i][j - 1];
                }
            }
        }
        return res[m - 1][n - 1];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

LeetCode63. 不同路径 II

如果开始节点和末尾节点都是障碍物，那么是没有结果的。

初始化第一排和第一列的数据，遇到障碍物后面的所有结果都是0。

package com.charles.dp;

class Solution {
   
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
   
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] res = new int[m][n];
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) {
   
            return 0;
        }
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
   
            res[i][0] = 1;
        }
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
   
            res[0][j] = 1;
        }
        for (int i = 1; i < m; i++) {
   
            for (int j = 1; j < n; j++) {
   
                if (obstacleGrid[i][j] == 1) {
   
                    res[i][j] = 0;
                } else {
   
                    res[i][j] = res[i - 1][j] + res[i][j - 1];
                }
            }
        }
        return res[m - 1][n - 1];

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

LeetCode64.最小路径和

上边和左边的最小值加上当前节点的值。

class Solution {
   
    public int minPathSum(int[][] grid) {
   
        int m = grid.length;
        int n = grid[0].length;
        int[][] memo = new int[m][n];
        for (int i = 0; i < m; i++) {
   
            memo[i][0] = i == 0 ? grid[0][0] : memo[i - 1][0] + grid[i][0];
        }
        for (int j = 0; j < n; j++) {
   
            memo[0][j] = j == 0 ? grid[0][0] : memo[0][j - 1] + grid[0][j];
        }
        for (int i = 1; i < m; i++) {
   
            for (int j = 1; j < n; j++) {
   
                memo[i][j] = Math.min(memo[i - 1][j], memo[i][j - 1]) + grid[i][j];
            }
        }
        return memo[m - 1][n - 1];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

LeetCode221. 最大正方形

以[i,j]为右下角的最大正方形的边长是上边，左边，斜上方的最小值+1。

class Solution {
   
    public int maximalSquare(char[][] matrix) {
   
        int m = matrix.length;
        int n = matrix[0].length;
        int max = 0;
        int[][] memo = new int[m][n];
        for (int i = 0; i < m; i++) {
   
            for (int j = 0; j < n; j++) {
   
                if (matrix[i][j] == '1') {
   
                    if (i == 0 || j == 0) {
   
                        memo[i][j] = 1;
                    } else {
   
                        memo[i][j] = Math.min(Math.min(memo[i][j - 1], memo[i - 1][j]), memo[i - 1][j - 1]) + 1;
                    }
                }
                max = Math.max(memo[i][j], max);
            }
        }
        return max * max;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

LeetCode1277. 统计全为 1 的正方形子矩阵

1277. 统计全为 1 的正方形子矩阵

边长为4的正方形以右下角为顶点存在的正方形是有4个的。

这题就可以转变成求最大正方形的思路，求以某点为右下角顶点的正方形的边长最大是多少。

class Solution {
   
    public int countSquares(int[][] matrix) {
   
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] memo = new int[m][n];
        int ans = 0;
        for (int i = 0; i < m; i++) {
   
            for (int j = 0; j < n; j++) {
   
                if (matrix[i][j] == 1) {
   
                    if (i == 0 || j == 0) {
   
                        memo[i][j] = 1;
                    } else {
   
                        memo[i][j] = Math.min(Math.min(memo[i - 1][j
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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