leetcode刷题---5.最长回文子串

立志每天刷leetcode一题，最近面试编程总是被屌。知耻而后勇吧！加油吧，骚年！装逼一下！

最长回文子串

题目

解题思路

动态规划思想：（参考1）

1、思考状态（重点）
状态的定义，先尝试「题目问什么，就把什么设置为状态]，然后思考「状态如何转移」，如果「状态转移方程」不容易得到，尝试修改定义，目的依然是为了方便得到「状态转移方程」。「状态转移方程」是原始问题的不同规模的子问题的联系。即大问题的最优解如何由小问题的最优解得到。

2、思考状态转移方程（核心、难点）
状态转移方程是非常重要的，是动态规划的核心，也是难点；常见的推导技巧是：分类讨论。即：对状态空间进行分类；归纳「状态转移方程」是一个很灵活的事情，通常是具体问题具体分析；除了掌握经典的动态规划问题以外，还需要多做题；如果是针对面试，请自行把握难度。
掌握常见问题的动态规划解法，理解动态规划解决问题，是从一个小规模问题出发，逐步得到大问题的解，并记录中间过程；
「动态规划」方法依然是「空间换时间」思想的体现，常见的解决问题的过程很像在「填表」。

3、思考初始化
初始化是非常重要的，一步错，步步错。初始化状态一定要设置对，才可能得到正确的结果。
角度 1：直接从状态的语义出发；
角度 2：如果状态的语义不好思考，就考虑「状态转移方程」的边界需要什么样初始化的条件；
角度 3：从「状态转移方程」方程的下标看是否需要多设置一行、一列表示「哨兵」（sentinel），这样可以避免一些特殊情况的讨论。

4、思考输出
有些时候是最后一个状态，有些时候可能会综合之前所有计算过的状态。

5、思考优化空间（也可以叫做表格复用）
「优化空间」会使得代码难于理解，且是的「状态」丢失原来的语义，初学的时候可以不一步到位。先把代码写正确是更重要；
「优化空间」在有一种情况下是很有必要的，那就是状态空间非常庞大的时候（处理海量数据），此时空间不够用，就必须「优化空间」；
非常经典的「优化空间」的典型问题是「0-1 背包」问题和「完全背包」问题。

（下面是这道问题「动态规划」方法的分析）
这道题比较烦人的是判断回文子串。因此需要一种能够快速判断原字符串的所有子串是否是回文子串的方法，于是想到了「动态规划」。
「动态规划」的一个关键的步骤是想清楚「状态如何转移」。事实上，「回文」天然具有「状态转移」性质。一个回文去掉两头以后，剩下的部分依然是回文（这里暂不讨论边界情况）；

依然从回文串的定义展开讨论：

如果一个字符串的头尾两个字符都不相等，那么这个字符串一定不是回文串；
如果一个字符串的头尾两个字符相等，才有必要继续判断下去。
如果里面的子串是回文，整体就是回文串；
如果里面的子串不是回文串，整体就不是回文串。
即：在头尾字符相等的情况下，里面子串的回文性质据定了整个子串的回文性质，这就是状态转移。因此可以把「状态」定义为原字符串的一个子串是否为回文子串。

第 1 步：定义状态

dp[i][j] 表示子串 s[i..j] 是否为回文子串，这里子串 s[i..j] 定义为左闭右闭区间，可以取到 s[i] 和 s[j]。

第 2 步：思考状态转移方程

在这一步分类讨论（根据头尾字符是否相等），根据上面的分析得到：

dp[i][j] = (s[i] == s[j]) and dp[i + 1][j - 1]
说明：

「动态规划」事实上是在填一张二维表格，由于构成子串，因此 i 和 j 的关系是 i <= j ，因此，只需要填这张表格对角线以上的部分。
看到 dp[i + 1][j - 1] 就得考虑边界情况。
边界条件是：表达式 [i + 1, j - 1] 不构成区间，即长度严格小于 2，即 j - 1 - (i + 1) + 1 < 2 ，整理得 j - i < 3。
这个结论很显然：j - i < 3 等价于 j - i + 1 < 4，即当子串 s[i..j] 的长度等于 2 或者等于 3 的时候，其实只需要判断一下头尾两个字符是否相等就可以直接下结论了。
如果子串 s[i + 1..j - 1] 只有 1 个字符，即去掉两头，剩下中间部分只有 11 个字符，显然是回文；
如果子串 s[i + 1..j - 1] 为空串，那么子串 s[i, j] 一定是回文子串。
因此，在 s[i] == s[j] 成立和 j - i < 3 的前提下，直接可以下结论，dp[i][j] = true，否则才执行状态转移。

第 3 步：考虑初始化

初始化的时候，单个字符一定是回文串，因此把对角线先初始化为 true，即 dp[i][i] = true 。
事实上，初始化的部分都可以省去。因为只有一个字符的时候一定是回文，dp[i][i] 根本不会被其它状态值所参考。

第 4 步：考虑输出

只要一得到 dp[i][j] = true，就记录子串的长度和起始位置，没有必要截取，这是因为截取字符串也要消耗性能，记录此时的回文子串的「起始位置」和「回文长度」即可。

第 5 步：考虑优化空间

因为在填表的过程中，只参考了左下方的数值。事实上可以优化，但是增加了代码编写和理解的难度，丢失可读和可解释性。在这里不优化空间。
注意事项：总是先得到小子串的回文判定，然后大子串才能参考小子串的判断结果，即填表顺序很重要。
大家能够可以自己动手，画一下表格，相信会对「动态规划」作为一种「表格法」有一个更好的理解。

整体代码思路

1.外循环控制回文子串的长度，从0开始；
2.dp边界确定有两个，子串为1或者2是条件很好确定；
3.正常条件是缩减左右两边的字符，剩下的还是回文，则这个子串必定是回文；

C++代码讲解

	class Solution {
public:
    string longestPalindrome(string s) {
       int n = s.size() ;
       vector> dp(n,vector(n));
       string ans;
       for(int l=0; l< n; l++)
       {
        //l是回文子串的首尾索引的间隔；从0开始，代表着从1个字符开始;
            for(int i = 0; i+lans.size()){
                    ans = s.substr(i,l+1);
                }
            } 
        }
        return ans;
    }
};

dp数组的定义和初始化
vector dp(n,vector(n));

python3代码讲解

class Solution:
def longestPalindrome(self, s: str) -> str:
    n = len(s)
    ans = ""
    dp = [[False] * n for _ in range(n)]
    for l in range(n):
        for i in range(n):
            if i+l >= n:
                break
            j = i + l
            if l==0:
                dp[i][j] = True
            elif l == 1:
                dp[i][j] = (s[i] == s[j])
            else:
                dp[i][j] = (dp[i+1][j-1] and s[i]==s[j])
            if dp[i][j] and l+1>len(ans):
                ans = s[i:i+l+1]
    return ans

python中二维数组的初始化
dp[[False] * n for _ in range(n)]

Java代码详解

class Solution {
public String longestPalindrome(String s) {
    int n = s.length();
    char[] charArray = s.toCharArray();
    boolean[][] dp = new boolean[n][n];
    String ans = "";
    for(int l = 0; lans.length())
                ans = s.substring(i,i+l+1);
        }
    }
    return ans;
}

}

Java中String不能直接当作数组使用，索引用不了，所以需要转成数组；
char[] charArray = s.toCharArray();

参考文献

【1】https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zhong-xin-kuo-san-dong-tai-gui-hua-by-liweiwei1419/