算法分析与设计第六周

思路：简单直接，从第一个字符开始，查找以该字符为起点的回文，返回所有回文中最长的那个回文
代码：

class Solution {
public:
    string longestPalindrome(string s) {
        string result= "";
        string temp;

        for (int i = 0; i < s.length(); ++i)
        {
            temp = palindromeFromeI(s, i);

            if (temp.length() > result.length())
                result = temp;
        }

        return result;
    }

    string palindromeFromeI(const string& str, int position)
    {
        int maxPosition;
        int traceEnd;
        int traceFront;

        for (maxPosition = str.length() - 1; maxPosition >= position; --maxPosition)
        {
            traceEnd = maxPosition;
            traceFront = position;

            while (str[traceFront] == str[traceEnd])
            {
                ++traceFront;
                --traceEnd;

                if (traceEnd <= traceFront)
                return string(str, position, maxPosition - position + 1);
            }

        }

    }
};

复杂度分析：此方法复杂度和暴力法一样（把所有可能的起点和终点列出来，逐一判断是否是回文），复杂度为o（n^3）.计算过程：n*n/2 + (n-1)*(n-1)/2…… = （n^3 - 2n - 4n -…… + n） /2= o(n^3/4） = o(n^3).

改进：中间扩展思想，从回文 中间向两边扩展，直至找到最长的回文。改进后，复杂度为o（n^2）下图为参考答案中的代码：

public String longestPalindrome(String s) {
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
        int len1 = expandAroundCenter(s, i, i);
        int len2 = expandAroundCenter(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 expandAroundCenter(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;
}