leetcode5 最长回文子串

寻找最长回文子串

最新推荐文章于 2022-05-18 11:50:26 发布

原创最新推荐文章于 2022-05-18 11:50:26 发布 · 241 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#最长回文子串 #leetcode

数组和字符串专栏收录该内容

10 篇文章

订阅专栏

本文探讨了在给定字符串中查找最长回文子串的有效算法。通过两种方法实现，一种是从中间向两边扩散，另一种是利用动态规划原理。文章详细介绍了每种方法的实现过程，并提供了完整的代码示例。

题目

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。

示例 2：

输入: “cbbd”
输出: “bb”

思路

从中间往两边找，分奇对称和偶对称两种情况处理，然后截取子字符串

实现

解法一

class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.size();
        int max = 0;
        string sub_str = "";
        for (int i = 0; i < len; i++) {
            for (int j = 0; (i-j) >=0 && (i+j) < len; j++) {
                if (s[i-j] != s[i+j]) {                            
                     break;
                }
                                   
                if (max < (2*j+1)) {
                    max = 2*j + 1;
                    sub_str = s.substr(i-j, 2*j + 1);
                    //std::cout << "qishu:" << i << "\t" << j << std::endl;
                 }
            }
            for (int j = 0; (i-j) >=0 && (i+j) < len - 1; j++) {
                if (s[i-j] != s[i+j+1]) {
                        break;
                }
                                
                if (max < (2*j + 2)) {
                    max= 2*j + 2;
                    sub_str = s.substr(i-j, 2*j + 2);
                    //std::cout << "oushu:" << i << "\t" << j << std::endl;
                }
            }
        }
        return sub_tr;
    }
};

解法二

#include <algorithm>
class Solution {
public:
    string longestPalindrome(string s) {
        if (s.empty()) {
            return "";
        }
        int tmp = 1;
        int max_index = s.size() - 1;
        std::string largest;
        largest.push_back(s[0]);
        for (int i = 0; i < s.size() - 1; ++i) {
            int m = i;
            int n = i + 1;
            if (s[m == s[n]]) {
                while (s[m] == s[n]) {
                    m--;
                    n++;
                    if (m < 0 || n == s.size()) {
                        break;
                    }
                }
                int len = min(n - 1, max_index) - max (0, m + 1) + 1;
                if (tmp < len) {
                    tmp = len;
                    largest = s.substr(max (0, m + 1), len);
                }
            }
            m = i - 1;
            n = i + 1;
            if (m < 0 || n == s.size()) {
                continue;
            }
            if (s[m == s[n]]) {
                while (s[m] == s[n]) {
                    m--;
                    n++;
                    if (m < 0 || n == s.size()) {
                        break;
                    }
                }
                int len = min(n - 1, max_index) - max (0, m + 1) + 1;
                if (tmp < len) {
                    tmp = len;
                    largest = s.substr(max (0, m + 1), len);
                }
            }
        }
        return largest;
    }
};