动态规划 最长回文子串

题目

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

---

示例 1：
输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。

---

示例 2：
输入：s = “cbbd”
输出：“bb”

---

示例 3：
输入：s = “a”
输出：“a”

---

示例 4：
输入：s = “ac”
输出：“a”

提示：

1 <= s.length <= 1000
s 仅由数字和英文字母（大写和/或小写）组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

状态转移方程

dp[i][j] = dp[i+1][j-1] && s.charAt(i) == s.charAt(j);

dp[i][j]表示字符串s的index值i到j的子串是不是回文，是的话为true，不是为false，i和j的关系有几种情况。

1. i == j，此时只包含一个字母

dp[i][j] = true

2. i == j-1，此时包含两个字母

dp[i][j] = s.charAt(i) == s.charAt(j);

3. i <= j-2，此时包含三个及以上字母

dp[i][j] = dp[i+1][j-1] && s.charAt(i) == s.charAt(j);

Base

由状态转移方程可知
i == j，此时只包含一个字母

for (int i = 0; i < s.length(); i++) {
    dp[i][i] = true;
}

答案

class Solution {
    // i, j 是回文
    // 
    public String longestPalindrome(String s) {
        char[] cs = s.toCharArray();
        int m = cs.length;
        int maxLength = 1;
        int begin = 0;
        if (m < 2) {
            return s;
        }

        boolean[][] dp = new boolean[s.length()][s.length()];

        for (int i = 0; i < m; i++) {
            dp[i][i] = true;
        }
		// 这里采用斜着遍历，因为dp[i][j]依赖dp[i+1][j-1]
		// 直接一点dp[0][3]在charAt(0) == charAt(3)依赖dp[1][2]
		// 如果正常从左到右，从上到下遍历dp[0][3]时，dp[1][2]还没初始化，
		// 这里从对角线向右上遍历
        for (int l = 1; l < m; l++) {
            for (int i = 0; i + l < m; i++) {
                int j = i + l;
                if (j - i < 2) {
                    dp[i][j] = cs[i] == cs[j];
                } else {
                    dp[i][j] = dp[i+1][j-1] && cs[i] == cs[j];    
                }
                if (dp[i][j]) {
                    if (j - i + 1 > maxLength) {
                        maxLength = j - i + 1;
                        begin = i;
                    }
                }
            }
        }

        return new String(cs, begin, maxLength);
    }
}

由下表可以看出来对角线的差为固定值0，右上差为固定值1，再为2，最后为(0, 4)为4
。可知斜着遍历写法时差值递增

i \ j	0	1	2	3	4
0
1
2
3
4