dp：回文子串，回文子序列

回文子串

https://leetcode-cn.com/problems/palindromic-substrings/
给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

思路

法1：暴力，遍历区间起始位置和终止位置，判断是否为回文串，时间复杂度O(n^3)
法2：dp

1. dp[i][j]表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。
2. 推导分情况：
   i，j 位置字符不相等，false
   i，j 位置字符相等。
   • i == j ，true
   • j - i == 1， true
   • j - i > 1，则除去这两个字符的中间串是否是回文串 决定了 当前串是否是回文串，即dp[i + 1][j - 1]
3. 初始化：一开始全为false，因为遍历过程中对于 j - i <= 1 的情况都已经进行直接判断，并没有依赖于未遍历的结果，所以当 j - i > 1的时候，所依赖的dp结果已经被推导过了。
4. 遍历顺序：左下角到右上角，所以倒序遍历 i ，正序遍历 j 。
5. 举例推导

法3：双指针
找到回文串的中心，对每个中心进行向两边扩散，越界或者不相等则退出此次扩散
中心确定时有两种情况，一个字符作为中心，两个字符作为中心

代码

dp

public int countSubstrings2(String s) {
   boolean[][] dp = new boolean[s.length()][s.length()];
    int ans = 0;
    for (int i = s.length() - 1; i >= 0; i--) {
        for(int j = i; j < s.length(); j++) {
            if(s.charAt(i) == s.charAt(j) && (j - i <= 1 || dp[i + 1][j - 1])) {
                ans++;
                dp[i][j] = true;
            }
        }
    }
    return ans;
}

双指针

public int countSubstrings(String s) {
    int ans = 0;
    for (int i = 0; i < s.length(); i++) {
        ans += extend(s, i, i, s.length());
        ans += extend(s, i, i + 1, s.length());
    }
    return ans;
}
public int extend(String s, int i, int j, int n) {
    int result = 0;
    while (i >= 0 && j < n && s.charAt(i) == s.charAt(j)) {
        i--;
        j++;
        result++;
    }
    return result;
}

最长回文子序列

https://leetcode-cn.com/problems/longest-palindromic-subsequence/
给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。

思路

求回文子序列，可以不连续，回文子串，要连续

1. dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。
2. 如果s[i]与s[j]相同，那么dp[i][j] = dp[i + 1][j - 1] + 2;
   如果s[i]与s[j]不相同，说明s[i]和s[j]的同时加入 并不能增加[i,j]区间回文子串的长度，那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。
   加入s[j]的回文子序列长度为dp[i + 1][j]。
   加入s[i]的回文子序列长度为dp[i][j - 1]。
   取较大者
3. 当i与j相同，那么dp[i][j]一定是等于1的，即：一个字符的回文子序列长度就是1。
   其他情况dp[i][j]初始为0就行，这样递推公式：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]); 中dp[i][j]才不会被初始值覆盖。
4. 从下往上，从左往右
5. 返回头到尾的最长子序列 dp[0][s.length() - 1]

代码

public int longestPalindromeSubseq(String s) {
   int[][] dp = new int[s.length()][s.length()];
    for (int i = 0; i < s.length(); i++) {
        dp[i][i] = 1;
    }
    for (int i = s.length() - 1; i >= 0; i--) {
        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];
}

总结

• 求回文子序列，可以不连续，回文子串，要连续
• 求回文串，一般是定义dp[i][j]为 i 到 j 的子序列，主要是因为回文串的性质每次需要比较对称的两个位置
• 此类题目一般推导dp方程时都是通过 i j 位置字符是否相等来进行分类讨论

参考

Carl：https://mp.weixin.qq.com/s/jbd3p4QPm5Kh1s2smTzWag