Leetcode Longest Palindromic Substring解题报告

首先是我自己最先写的解法：就是将每一个字符作为中心字符，然后向两边一个一个的进行扩展，看是否相等，这样来判断回文子串，但是这样实现的时候，奇数偶数的情况要分开来算，总的不影响时间复杂度，都是o(n2)，代码还是很好看懂的我觉得。。。

class Solution {
public:
    string longestPalindrome(string s) {
        int maxlen = 1;
        int start = 0;
        int len = s.length();
        for(int i = 0;i<len;i++)
        {
            int j = i-1,k = i+1;
            while(j>=0&&k<len&&s[j]==s[k])
            {
                if(k-j+1>maxlen)
                {
                    maxlen = k-j+1;
                    start = j;
                }
                j--;
                k++;
            }
        }
        for(int i = 0;i<len;i++)
        {
            int j = i,k = i+1;
            while(j>=0&&k<len&&s[j]==s[k])
            {
                if(k-j+1>maxlen)
                {
                    maxlen = k-j+1;
                    start = j;
                }
                j--;
                k++;
            }
        }
        return s.substr(start,maxlen);
    }
};

但是还在discuss里面看到了一种解法，最好情况下时间复杂度为o(n),最坏情况下为O(N2)，但是discuss里为了看起来行数少，看起来真的。。。然后我根据我的理解加上了注释。。。

可以带入abba，abcba这两个例子，可以更好的理解。。。

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.empty())
            return "";
        if(s.size()==1)
            return s;
        int start = 0,maxlen = 1;//初始的最长的长度就是1
        int len = s.size();
        for(int i = 0;i<len;)
        {
            if(len-i<=maxlen/2)//当剩下的长度比最长情况下的一半还要小的话，就不用比较了，因为肯定不会更长的
                break;
            int j = i,k = i;
            while(k<s.size()-1&&s[k+1]==s[k])//这是找出所有相邻的情况
                ++k;
            i = k+1;
            while(k<s.size()-1&&j>0&&s[k+1]==s[j-1])//跨过所有相等的子串，看左右两边是否还要相等的
            {
                ++k;
                --j;
            }
            int newlen = k-j+1;
            if(newlen>maxlen)
            {
                start = j;
                maxlen = newlen;
            }
        }
        return s.substr(start,maxlen);
    }
};