动态规划笔记-最长回文串

动态规划

• 题目类型：计数型（add），最值型(min, max)，可行性型/存在型(or, and)

• 化大为小，将原问题拆解为多层重叠的子问题，而子问题相比于原问题仅仅是规模变小了。每个层级的问题可理解为一个状态S。

• 一个状态S(i)的解应该可基于其子状态S(i-1)的解来求解。记录每个状态的解，在进行一个状态求解时可直接使用其子状态的解，而无需重复计算。

• 可从大到小分析相邻状态之间的转换条件，从而得到状态转换方程。一般可从最后一个状态S(n)往前进行推演，即主要关注转变成S(n)的最后一个步骤是什么，从而推出S(n-1)。动态规划求最优解，S(n)为最优状态，那么S(n-1)也应该是最优的，依次类推。因此想要求S(n)，我们需要知道S(n-1)，依次类推。而从S(n) 到 S(n-1) 的最后一步，就是转换方程的关键。

• 分析最小状态确定状态初始值，且需要注意边界条件（主要是数组不要越界）

• 计算顺序的确定，从状态转移方程中获取信息：当计算S(n) 是，S(n-1)应该已经知道了，要可以利用之前的计算结果。(大部分是从小到大进行计算)

• 状态数组维度确定：根据每个状态下的变量个数决定。

题目

回文串：一个正读和反读都一样的字符串

问题拆解：

求最长的回文串，那么得到最长的回文串的最后一步是，在一个次长的回文串的两端拼接上一样的字符。

状态数组定义：

f[i][j] 为true表示 索引 i 至 j 的子串是回文字符串；

状态转义方程：

f[i][j] = f[i+1][j-1] and s[i] == s[j] ，s为字符串

状态初始值：

• 考虑长度最短的回文串即长度为1的一个子串，当长度为1，一定是回文串:，即可得 f[i][j] = true， i==j;

• 当长度为2时，只要子串两个字符相等即为回文串： f[i][j] = true, (i+1==j, and s[i] == s[j])

状态总结：

长度为1： f[i][j] = true;

长度为2： f[i][j] = true, 其中 i+1==j and s[i] == s[j]

长度大于2：f[i][j] = f[i+1][j-1] and s[i] == s[j]

遍历顺序：

根据状态转义方程，长度 n = j-i+1， 当计算长度为n的子串是否是回文字符串时，应该需要要利用长度为 (j-1)-(i+1)+1 = j-i-1 = n-2 的结果，所以应该按照长度从小到大进行遍历。

class Solution {
    public String longestPalindrome(String s) {
        // f[i][j] 为true表示 索引 i 至 j 的子串是回文字符串
        // f[i][j] 是回文串，则f[i+1][j-1]也是回文串
        // f[i][j] = f[i+1][j-1] and s[i] == s[j]

        // 初始值，当长度为1，一定是回文串: f[i][i] = true
        // 当长度为2时，只要两个字符相等即为回文串： f[i][j] = true, (i+1==j, and s[i] == s[j])
        // 当长度大于2时， f[i][j] = f[i+1][j-1] and s[i] == s[j]
        if (s.length() == 1) {
            return s;
        }
        int maxLen = 0;
        String res = "";

        boolean[][] f = new boolean[s.length()][s.length()];
        for (int len = 1; len <= s.length(); len++) { // 长度的遍历，len 小于等于字符串长度
            for (int i = 0; i < s.length(); i++) { // 子串起始索引遍历
                int j = i + len - 1;
                if (j > s.length() - 1) {// 数组边界判断
                    continue;
                }
                if (len == 1) { // 长度为1的子串一定是回文串
                    f[i][j] = true;
                }else if (len == 2) {
                    f[i][j] = s.charAt(i) == s.charAt(j);
                }else {
                    f[i][j] = f[i+1][j-1] && s.charAt(i) == s.charAt(j);
                }
                if (f[i][j] && len > maxLen) {
                    maxLen = len;
                    res = s.substring(i, j + 1);
                }
            }
        }
        return res;
    }
}