LeetCode-最长回文子串(动态规划)

（一）题目描述

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

（二）思路

1）暴力解法：

利用二重循环，对该字符串的每个子序列进行判断。

//直接利用二重循环，遍历每一个子串，并判断其是否为回文串
class Solution03{
    public String longestPalindrome(String s) {
        int len=s.length();
        if(len<2){
            return s;
        }
        int manLen=1;
        int begin=0;
        for (int i = 0; i < len-1; i++) {
            for (int j = i+1; j < len; j++) {
                if(i<j&&hwStr(s,i,j)){
                    if(j-i+1>manLen){
                        begin=i;
                        manLen=j-i+1;
                    }
                }
            }
        }
        return s.substring(begin,begin+manLen);
    }
    //判断是否为回文串的函数
    public boolean hwStr(String s,int begin,int end){
        char[] array=s.toCharArray();
        while (begin<end){
            if(array[begin]!=array[end]){
                return false;
            }
            begin++;
            end--;
        }
        return true;
    }
}

2）动态规划

     1、定义数组元素dp[i][j]：i、j之间的字符串是否为回文串（dp[i][j]=true或false）

     2、找出数组元素间的关系式：dp[i][j]=dp[i+1][j-1]（看中间的字符串是否为回文串）

     3、初始值：i=j时，dp[i][j]=true

class Solution {
    public String longestPalindrome(String s) {
        /**
         * (1)状态的定义
         * (2)状态转移方程
         * （3）初始状态或边界条件的定义
         */
        char[] chars = s.toCharArray();
        int len = s.length();
        //状态的定义，是一个二维数组;（1:i,j之间的串为回文串）
        int[][] dp = new int[len][len];
        //记录回文串最大长度
        int maxLen = 1;
        //记录最大回文子串起始位置
        int begin = 0;

        for (int i = 0; i < len; i++) {
            dp[i][i] = 1;
        }

        //以下内容需要画图理解
        for (int j = 1; j < len; j++) {
            for (int i = 0; i < j; i++) {
                //i,j之间的串不是回文串
                if (chars[i] != chars[j]) {
                    dp[i][j] = 0;
                } else {
                    //i、j相等：里面的串有可能是回文串
                    if (j - i < 3) {
                        dp[i][j] = 1;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

                if (dp[i][j] == 1 && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substring(begin, begin + maxLen);
    }
}

 附上解析链接：力扣

（3）中心扩展算法

找"回文中心"，然后从回文中心开始向其两边发散，进而找到最长回文子串
回文中心：长度为1或2的串（i,i）和(i,i+1)作为回文子串（因从这两种扩散可以得到所有回文子串可能的情况）