2022.4.11 力扣647，516，583，72

学习：动态规划

follow:代码随想录

---

647. 回文子串

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

解析：
该题需要两个dp数组来保存状态

• dp[i]：下标为0到i的字符串包含的回文子串的数目
• flag[I]：从下标为i到当前处理到的字符，该字符串是否为回文串

确定递推公式：
j为从0到i-1的每个字符

• 如果j和i相等
  • j+1到i-1为回文串 dp[i] ++，flag[j] = true
  • j+1到i-1不是回文串 dp[i]不变，flag[j] = false
• 如果j和i不等：dp[i]不变，flag[j] = false
  最后dp[i] + dp[i - 1] + 1

public int countSubstrings(String s) {
        //用来保存回文串的数目
        int[] dp = new int[s.length()];
        //用来保存从i到目标位置是否为回文串
        boolean[] flag = new boolean[s.length()];
        //初始化
        dp[0] = 1;
        flag[0] = true;
        for(int i = 1; i < s.length(); i++){
            dp[i] = dp[i - 1] + 1;
            flag[i] = true;
            for(int j = 0; j < i; j++){
                if(s.charAt(i) == s.charAt(j)){
                    if(flag[j + 1] == true){
                        dp[i]++;
                        flag[j] = true;
                    }else{
                        flag[j] = false;
                    }
                }else{
                    flag[j] = false;
                }
            }
        }
        return dp[s.length() - 1];
    }

516 最长回文子序列

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

解析：
本题要求的是不连续！

• 确定dp数组的含义
  dp[i][j]：下标从i到j的字符串中最长的回文子序列
• 确定递推公式
  如果i和j不相等：dp[i][j] = Max(dp[i - 1][j], dp[i][j-1])，也就是要么舍弃前一个，要么舍弃后一个
  

如果i和j相等：dp[i][j] = dp[i + 1][j - 1] + 2

• 遍历顺序
  因为dp[i][j]需要左边和下边的，所以遍历顺序从下至上，从左至右

public int longestPalindromeSubseq(String s) {
        int[][] dp = new int[s.length()][s.length()];
        //初始化对角线为1
        for(int i = s.length() - 1; i >= 0; i--){
            dp[i][i] = 1;
            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];
    }

583 两个字符串删除操作

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

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

解析：

• 确定dp数组及其含义

dp[i][j]：表示word1前I个字符和word2前j个字符，所需要的最小步骤

• 递推公式

如果最后一个字符串相同，则最后一个字符不用删，与前一个状态相同
dp[i][j] = dp[i - 1][j - 1]

如果最后一个字符不同，则看应该删除哪个字符，才能使用最小步骤
dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + 1

 public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length() + 1][word2.length() + 2];
        for(int i = 0; i <= word1.length(); i++){
            dp[i][0] = i;
        }
        for(int j = 0; j <= word2.length(); j++){
            dp[0][j] = j;
        }

        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(dp[i - 1][j], dp[i][j - 1]) + 1;
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }

72. 编辑距离

题目解析：
给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

• 插入一个字符
• 删除一个字符
• 替换一个字符

示例：

输入：word1 = “horse”, word2 = “ros”
输出：3
解释：
horse -> rorse (将 ‘h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’)
rose -> ros (删除 ‘e’)

解析：

• 确定dp数组及其含义

dp[i][j]：代表下标为0-i-1和0-j-1的两个词，所需要的最小步数

• 递推公式

从一个词到另外一个词有三种操作：插入、删除、替换，对于插入和删除，可以看做成一种，因为word1删除，就等于word2添加

• 如果i和j相等：则不用进行操作

dp[i][j] = dp[i - 1][j - 1]

• 如果i和j不相等，则需要进行三种操作

第一种：删除第一个，也就是看word1删除完了最后一个与word2进行比较
dp[i][j] = dp[i - 1][j ] + 1

第二种：删除第二个，也就是增加第一个，看word2删除完了最后一个与word1进行比较
dp[i][j] = dp[i ][j + 1] + 1

第三种替换：将word1的最后一个元素替换为word2，然后在比较前面的
dp[i][j] = dp[i - 1][j - 1] + 1

public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        for(int i = 0; i <= word1.length(); i++){
            dp[i][0] = i;
        }
        for(int j = 0; j <= word2.length(); j++){
            dp[0][j] = j;
        }

        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][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
                }
            }
        }

        return dp[word1.length()][word2.length()];
    }