最长回文子串

简单来说，就是顺着和逆着读相同的子串；例如erabcba的最长回文串是abcba

方法一：
动态转移方程：P[i][j]记录i—j是否为回文串（true false），P[i][j]=P[i-1][j-1]（if a[i]==a[j]）；
枚举子串的长度l，通过对每个字符开始l长的子串判断是否为回文串；
同时注意单个字符的回文串是；且若相邻两个字符相同，则这两个字符的回文串是2；以上两种情况要单独在初始化的时候考虑。
输出回文串，要用max去记住当前最长的回文串长度，start记住最长回文串的起始位置；

int huiwen1(string a)
//动态规划算法，枚举的是长度从小到大；动态转移方程：（P[i][j]=0如果ij不是回文串）P[i+1][j-1]=1且a[i]=a[j]则P[i][j]=P[i+1][j-1]
//时间复杂度O(N^2),空间复杂度O(N^2)
{
    int len = a.length();
    int start = 0;//记最长子串的起始坐标为start
    int P[10][10] = { false }; //P记录以i开始j结尾的子串是不是回文串
    int max = 0;//记录最长的回文串长度
    //要考虑一个字母是自己的回文，两个字符相等的话回文长度为2；故长度=1、2的子串要单独讨论
    for (int i = 0; i < len; i++)
    {
        P[i][i] = true;
        max = 1;
    }
    for (int i = 1; i < len; i++)
    {
        if (a[i] == a[i - 1])
        {
            P[i - 1][i] = true;
            max = 2;
            start = i - 1;
        }
    }
    //从长度为3的子串开始遍历
    for (int l = 3; l <= len; l++)//考虑长度为l的子串
    {
        for (int i = 0; i <= len - l; i++)
        //为了保证ij<len，则要保证i<=(len-1)
        {
            int j = i + l - 1;//开始坐标为i，结束坐标为j的子串
            if ((a[i] == a[j]) && (P[i+1][j-1] == true))
            {
                P[i][j] = true;
//此时子串的长度就是l，所以P不用计入长度，简单的可以用true和false表示
                if (max == l)
                    start = i;
            }
        }
    }
    for (int t = start; t < start + max; t++)
        cout << a[t] << " ";
    cout << endl;
    cout << "最长子串长度：" << max << endl;
    return max;
}

方法二：中心扩展——枚举的是字符串的中心，不断的往两边扩展比较，只需要用max来记住当前最长的回文串长度。

int huiwen2(string a)//中心扩展法，枚举的是每一个坐标，算以这个坐标为中心能向两边扩展的最大长度
//时间复杂度O(N^2) 空间复杂度O(1)
{
    //要考虑奇偶的情况，如aba与abba
    int start = 0;
    int max = 1;
    for (int i = 0; i < a.length(); i++)
    {
        //奇数情况
        int l = i - 1; int r = i + 1;
        while ((l >= 0) && (r < a.length()) && (a[l] == a[r]))//如果以i为中心前后相等构成回文串
        {
            max = ((r - l + 1)>max ? (r - l + 1) : max);
            if (max == (r - l + 1))
                start = l;
            l--; r++;
        }
        //偶数情况
        l = i; r = i + 1;//考虑连续两个相同字符的情况
        while ((l >= 0) && (r < a.length()) && (a[l] == a[r]))
        {
            max = ((r - l + 1)>max ? (r - l + 1) : max);
            if (max == (r - l + 1))
                start = l;
            l--; r++;
        }
    }
    for (int t = start; t < start + max; t++)
        cout << a[t] << " ";
    cout << endl;
    cout << "最长回文子串长度：" << max << endl;
    return max;
}

方法三：Manchester
参考：http://blog.csdn.net/yzl_rex/article/details/7908259