LeeCode-最长回文子串-动态规划_最大回文子串 leecode-CSDN博客

本文链接：https://blog.csdn.net/ambi_garlic/article/details/113831312

动态规划

状态转移方程，可以说得出 result2 依赖 result1 ；
充分利用已经得到结果，做规划

状态转移方程

第i个字符和第j个字符相同，并且里面的字串是“回文字串”，那么s[ i ] [ j ] 是回文字符串；
第i个字符串和第j个字符串相同，并且 j- i=2;1;0; 其实就是< 3，也可以推出s[i] [j] 是回文字符串

dp[ i ] [ j ] = (s[i] == s[j] ) and ( dp[i+1][j-1] or j-i>3)

i+1 < = j-1 -----> j-i >=2 ------> j-i>3

可以看到 dp[i][j] 依靠 dp[i+1][j-1]的结果；在表格中体现为，右上依赖左下；

i\j	0	1	2	3	4
0	true			后
1		true	先
2			true
3				true
4					true

class Solution {
    public String longestPalindrome(String s) {
        // 用来表示结果
        int startIndex = 0;
        int maxLength = 1;
        // 整理有效条件
        int len = s.length();
        // 开始计算
        if(len<2){
            return s;
        }
            // 1.准备好 二维布尔数组 来表征 潜在的结果
        boolean[][] dp = new boolean[len][len];
            // 其实只需要把表格的右上方填好就可以了 大方向是一列一列的填（外循环），每一列在按行填即可(内层循环）；      
        char[] charArray = s.toCharArray();    
        for(int j =1; j<len; j++){
            for(int i =0; i<j ; i++){
                // 从简单的条件开始写，如果首尾字符不相等，那么肯定不是回文串，
                if(charArray[i] != charArray[j]){
                    dp[i][j] = false;
                }else{
                    if(j-i<3){
                        dp[i][j] = true;
                    }
                    if(dp[i+1][j-1]){
                        dp[i][j] = true;
                    }
                }
                // 如果填了一个true，那么就考虑更新结果吧
                if(dp[i][j] && j-i+1 > maxLength){
                    maxLength = j-i+1;
                    startIndex = i;
                }
            }
        }


        return s.substring(startIndex, startIndex + maxLength);
    }
}