当前位置：首页 > news >正文

leetcode hot100 多维动态规划

news 来源：原创 2025/6/10 3:14:32

1️⃣2️⃣ 多维动态规划（区间 DP、状态机 DP）

62. 不同路径

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？

题解:数组, 动态规划

由一维转为二维了, 其实规划式子还是和前面的状态有关. 比如dp[i][j]表示到达(i,j)的所有路径, 又(i,j)只会从(i-1,j)&(i,j-1)移动而来, 那么, dp[i][j]=dp[i-1][j]+dp[i][j-1]

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for(int i=0;i<m;i++){
            dp[i][0]=1;
        }
        for(int j=0;j<n;j++){
            dp[0][j]=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];
    }
}

64. 最小路径和

给定一个包含非负整数的 *m* x *n* 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。说明：每次只能向下或者向右移动一步。

题解:数组, 动态规划

跟前面那题一样, 其实走一遍图就知道了. dp[i][j]代表点(i,j)最小路径和, 那么第0排和第0列的数据是遍历一遍可以计算出来的: 当前grid值+前一位置的dp值
那么其余位置可以计算了, dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j]

class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        dp[0][0] = grid[0][0];
        for(int i=1;i<m;i++){
            dp[i][0] = dp[i-1][0]+grid[i][0];
        }
        for(int j=1;j<n;j++){
            dp[0][j] = dp[0][j-1]+grid[0][j];
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j] = Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
}

5. 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

题解:子串, 递归, 动态规划

如果一个字符串为回文串, 那么左右各缩减1的子串也为回文串
dp[][]存储的是(i,j)处的串是否为回文串, 如果是, 那么s[i] == s[j] &&dp[i+1][j-1]同时也是回文串
怎么根据上面的式子找出动态规划呢, 我们最后肯定要维护一个最长回文子串大小以及begin处, 这样返回的才是s.substring(begin,begin+mL)
dp[i][i]肯定是回文的, 因为只有一个字符, 初始化以下; 计算是否回文, 或许可以用双指针, 一个指向头, 一个指向假定len的尾, 那么这个len要从多大开始呢–第二条可以得出: dp[i][j] = s[i]==s[j] && dp[i+1][j-1]
我们需要先得出内部子串是否为回文, 那么len要从最小判断: for(int len = 2;i<=s.length();l++), 然后遍历s,从s的索引i处到i+len-1处, 看当前子串是否为回文的即可

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        if(n < 2) return s;
        int mL=1;
        int begin = 0;
        boolean[][] dp = new boolean[n][n];
        char[] chs = s.toCharArray();
        for(int l = 2;l<=n;l++){
            for(int i=0;i<n;i++){
                int j = i+l-1;
                if(j >= n) break;
                if(chs[i] != chs[j]){
                    dp[i][j] = false;
                }else{
                    if(j-i < 3) dp[i][j] = true;
                    else{
                        dp[i][j] = dp[i+1][j-1];
                    }
                }
                if(j-i+1 > mL&dp[i][j]){
                    mL = j-i+1;
                    begin = i;
                }
            }
        }
        return s.substring(begin,begin+mL);
    }
}

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的公共子序列是这两个字符串所共同拥有的子序列。

题解:子串, 动态规划

其实这题我建议记下来, 因为很久不用这题的逻辑总会忘记, 但是代码又是很简单的

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();
        int[][] dp = new int[m+1][n+1];
        char[] chs1 = text1.toCharArray();
        char[] chs2 = text2.toCharArray();
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(chs1[i-1] == chs2[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];
    }
}

72. 编辑距离

给你两个单词 word1 和 word2，请返回将 word1 转换成 word2 所使用的最少操作数。你可以对一个单词进行如下三种操作：插入一个字符; 删除一个字符; 替换一个字符

题解:最长公共子序列, 动态规划

本题需要维护的是dp[i][j] , 表示A的前i个字母与B的前j个字母之间的编辑距离

class Solution {
    public int minDistance(String word1, String word2) {
        int n = word1.length();
        int m = word2.length();
        if(n*m == 0) return n+m;
        int[][] dp = new int[n+1][m+1];
        for(int i=0;i<=n;i++){
            dp[i][0]=i;
        }
        for(int j=0;j<=m;j++){
            dp[0][j] = j;
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                int left = dp[i-1][j]+1;
                int down = dp[i][j-1]+1;
                int left_down = dp[i-1][j-1];
                if(word1.charAt(i-1)!= word2.charAt(j-1)){
                    left_down+=1;
                }
                dp[i][j] = Math.min(left,Math.min(down,left_down));
            }
        }
        return dp[n][m];
    }
}