5 Longest Palindromic Substring

最新推荐文章于 2024-10-11 23:48:39 发布

dongbeier

最新推荐文章于 2024-10-11 23:48:39 发布

阅读量101

点赞数

CC 4.0 BY-SA版权

分类专栏： MicroSoft LeetCode

本文链接：https://blog.youkuaiyun.com/dongbeier/article/details/80317548

LeetCode 同时被 2 个专栏收录

146 篇文章

订阅专栏

MicroSoft

85 篇文章

订阅专栏

本文介绍了一种寻找字符串中最长回文子串的经典算法，提供了两种思路：一是暴力枚举，通过从每个元素出发向两边扩展来查找；二是动态规划，利用状态转移方程高效解决问题。附带Java实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example 1:

Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2:

Input: "cbbd"
Output: "bb"

最长回文子串，非常经典的题。

思路一：暴力枚举，以每个元素为中间元素，同时从左右出发，复杂度O(n^2)。

思路二：动规，复杂度O(n^2)。设状态为f(i,j)，表示区间[i,j]是否为回文串，则状态转移方程为

$f(i,j)=\begin{cases} true & ,i=j\\ S[i]=S[j] & , j = i + 1 \\ S[i]=S[j] \text{ and } f(i+1, j-1) & , j > i + 1 \end{cases}$

class Solution {
    public String longestPalindrome(String s) {
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int len1 = expand(s, i, i);
            int len2 = expand(s, i, i + 1);
            int len = Math.max(len1, len2);
            if (len > (end - start)) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        
            return s.substring(start, end + 1);
    }
    
    private int expand(String s, int left, int right) {
        int l = left, r = right;
        while (l >= 0 && r < s.length() &&
              s.charAt(l) == s.charAt(r)) {
            l--;
            r++;
        }
        return r - l - 1;
    }
}

class Solution {
    public String longestPalindrome(String s) {
        int maxLen = 1, start = 0;
        int n = s.length();
        boolean[][] f = new boolean[n][n];
        
        for (int i = 0; i < n; i++) {
            f[i][i] = true;
            for (int j = 0; j < i; j++) {
                f[j][i] = (s.charAt(i) == s.charAt(j) &&
                          (i - j < 2 || f[j + 1][i - 1]));
                    
                    if (f[j][i] && maxLen < (i - j + 1)) {
                        maxLen = i - j + 1;
                        start = j;
                    }
            }
        }
        return s.substring(start, start + maxLen);
    }
}