最长回文子串(矩阵型动态规划)

最新推荐文章于 2023-03-05 16:29:40 发布

原创最新推荐文章于 2023-03-05 16:29:40 发布 · 245 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#字符串 #动态规划

LeeCode代码专栏收录该内容

254 篇文章

订阅专栏

这是一个关于字符串处理的算法实现，代码使用Java编写，目标是找到输入字符串中的最长回文子串。算法采用了动态规划的方法，通过二维布尔数组记录子串是否为回文，并更新最长回文子串的长度和起始位置。示例中给出了对字符串babad和cbbd的处理，分别返回了最长回文子串bab和bb。

package com.heu.wsq.leetcode.a1star;

/**
 * 最长回文子串
 * @author wsq
 * @date 2021/5/27
 * 给你一个字符串 s，找到 s 中最长的回文子串。
 *
 * 示例 1：
 * 输入：s = "babad"
 * 输出："bab"
 * 解释："aba" 同样是符合题意的答案。
 *
 * 示例 2：
 * 输入：s = "cbbd"
 * 输出："bb"
 *
 * 链接：https://leetcode-cn.com/leetbook/read/tencent/xxk4s2/
 */
public class LongestPalindrome {
    public String longestPalindrome(String s) {
        if(s == null || s.length() == 0){
            return s;
        }
        int n = s.length();
        char[] arr = s.toCharArray();
        // 动态规划状态数组
        // f[i][j] 表示从索引i到索引i对应的字符串是否是回文串
        // f[i][j]最后一步：arr[i] == arr[j]，并且f[i+1][j-1]也是回文串
        // 子问题：f[i+1][j-1]是否是回文串
        boolean[][] f = new boolean[n][n];
        int len = 0;
        int pos = -1;
        // 状态转移方程：
        // arr[i] != arr[j] : f[i][j] = false
        // arr[i] == arr[j] : f[i][j] = j + 1 >= i || f[i+1][j-1]
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= i; j++){
                if(arr[i] != arr[j]){
                    continue;
                }
                f[j][i] = j + 1 >= i || f[j + 1][i - 1];
                if(f[j][i] && i - j + 1 > len){
                    len = i - j + 1;
                    pos = i;
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        for(int i = pos - len + 1; i <= pos; i++){
            sb.append(arr[i]);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        LongestPalindrome longestPalindrome = new LongestPalindrome();
        String s = "a";
        String ans = longestPalindrome.longestPalindrome(s);
        System.out.println(ans);
    }
}