leetcode hot100 多维动态规划

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);
      }
  }
  

1143. 最长公共子序列

给定两个字符串 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];
      }
  }