最长回文字串

题目描述

直接进入主题。

给你一个字符串 s，找到 s 中最长的回文子串。
如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

解法

最简单粗暴的方式就是暴力求解，估计这在力扣过不了，至少py3是不行。那就试试C，C若不行，那彻底换种解法。
由于C没有string类型，笔者折腾许久（很久都不写C了），总算是在本地运行成功。

int is_palindrome(char *str, int start, int end) {
    while (start < end) {
        if (str[start++] != str[end--]) {
            return 0;
        }
    }
    return 1;
}
char* longestPalindrome(char *str) {
	
    int len = strlen(str);
    int max_len = 0;
    int start_index = 0;

    for (int i = 0; i < len; i++) {
        for (int j = i; j < len; j++) {
            if (is_palindrome(str, i, j)) {
                if (j - i + 1 > max_len) {
                    max_len = j - i + 1;
                    start_index = i;
                }
            }
        }
    }

	char* palindrome = (char*) malloc((max_len + 1) * sizeof(char));
	strncpy(palindrome,str + start_index , max_len);
	return palindrome;
}

没什么过多解释的，两个函数，第一个函数判断是否回文，第二个函数取得回文字符串。
这在本地是没有问题的，

okay,提交！ 结果报了个堆溢出:
原来是没有加上终止符！！！
再重新补上：

palindrome[max_len] = '\0';

再提交，过了, 不愧是C！

优化解法

可以利用回文字符串的对称性，从对称中心开始，左右字符相等则再向两边延展。
需要注意的是：
分类讨论奇数长和偶数长字符串。
左指针的位置是索引减去字符串长度-1的一半，避免偶数长字符串的指针越界。

 public String longestPalindrome(String s) {
        //判断是否非空字符串
        if(s==null||s.length()==0){
            return "";
        }
        //初始化左右双指针
        int start = 0;
        int end = 0;
        for (int i = 0; i < s.length(); i++) {
            //奇数长串
            int len1 = expandFromMiddle(s,i,i);
            //偶数长串
            int len2 = expandFromMiddle(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);
    }
    public int expandFromMiddle(String s,int left,int right){
        //判断左指针和右指针字符是否相等，相等则向两边延展
        while (left >= 0 && right < s.length() && s.charAt(left)==s.charAt(right)){
            left--;
            right++;
        }
        //去除边界长
        return (right - 1)-(left + 1) + 1;
    }

提交之后，发现还有13%的大神比这更快的做法。事实上，我觉得这个解法已经是比较优的解法了，也很好理解。

Manacher解法

据说这是最高效率的解法，在这就不讨述了。
有兴趣可以参考力扣官解：
leetcode

这里还是附上一份题解：

public String longestPalindrome4(String s) {
        // 如果输入字符串为空或长度小于1，返回空字符串
        if (s == null || s.length() < 1) {
            return "";
        }
        // 在字符串的前后分别添加一个特殊字符'#'，用于处理字符串边界情况
        s = "#" + String.join("#", s.split("")) + "#";

        // 获取字符串的长度
        int n = s.length();
        // 创建一个数组，用于存储以每个位置为右端点的回文子串的长度
        int[] p = new int[n];
        // 初始化中心标志位、右边界和回文子串长度
        int c = 0, r = 0;
        // 遍历字符串，计算以每个位置为右端点的回文子串的长度
        for (int i = 1; i < n ; i++) {
            // 如果当前位置小于右边界
            if (r > i) {
                // 更新当前位置的回文子串长度为右边界距离的最小值
                p[i] = Math.min(r - i, p[2 * c - i]);
            }
            // 向左和向右扩展，判断是否为回文子串
            while (i - p[i] >= 0 && i + p[i] < n && s.charAt(i + p[i] ) == s.charAt(i - p[i] )) {
                p[i]++;
            }
            // 更新右边界
            if (i + p[i] > r) {
                c = i;
                r = i + p[i];
            }
        }
        // 初始化最大回文子串长度和中心位置
        int maxLen = 0, center = 0;
        // 遍历计算回文子串长度数组，找到最大回文子串长度和中心位置
        for (int i = 1; i < n - 1; i++) {
            if (p[i] > maxLen) {
                maxLen = p[i];
                center = i;
            }
        }
        // 根据中心位置和最大回文子串长度，截取最大回文子串并去除特殊字符'#'
        return s.substring(center - maxLen+1, center + maxLen ).replace("#", "");
    }

提交之后，发现时间更长了，并没有带来效率上的提升，看来还是需要改进。
另外附上一份
py3:

 def longestPalindrome(self, s: str) -> str:
        s = '#' + '#'.join(s) + '#'
        n = len(s)
        p = [0] * n
        c = r = 0
        for i in range(1, n - 1):
            if r > i:
                p[i] = min(r - i, p[2 * c - i])
            while i + p[i] + 1 < n and s[i + p[i] + 1] == s[i - p[i] - 1]:
                p[i] += 1
            if i + p[i] > r:
                c, r = i, i + p[i]
        max_len, center = max((n, i) for i, n in enumerate(p))
        return s[center - max_len -1// 2:center + max_len +1 // 2 + 1].replace('#', '')