hihocoder #1032 : 最长回文子串（动态规划+manacher算法）

题目链接：http://hihocoder.com/problemset/problem/1032

这道题应该是要求用manacher算法解决的，用动态规划复杂度太高，显示超时，但站在解决问题的角度，还是把两种方法都贴出来。

1.动态规划

首先是动态规划，动态规划要找状态转移方程，具体如下。

不熟悉动态规划思想的可以参考下这篇博文，写的很好http://blog.csdn.net/shineboyxxb/article/details/52079360 我的代码与这篇文章提供的有些许不同，但都是动态规划思想。

代码如下：

#include<iostream>
#include<stdio.h>
using namespace std;
int FindLongStr(string str)
{
    int i,j,result;
    int **p;
    result=0;
    p=new int *[str.length()];
    for(i=0;i<str.length();i++)
    {
        p[i]=new int [str.length()];
    }
    for(i=0;i<str.length();i++)
    {
        p[i][i]=1;
        if(str[i]==str[i+1])
        {
            p[i][i+1]=1;
            result=2;
        }
    }
    for(i=str.length()-2;i>=0;i--)
    {
        for(j=i+2;j<str.length();j++)
        {
            if(str[i]==str[j]&&p[i+1][j-1]==1)
            {
                p[i][j]=1;
                if(result<(j-i+1))
                    result=j-i+1;
            }
        }
    }

    for(i=0;i<str.length();i++)
    {
        delete [] p[i];
    }
    delete [] p;
    return result;
}
int main()
{
    int num;
    string str;
    freopen("input.txt","r",stdin);
    cin>>num;
    while(num--)
    {
        cin>>str;
        cout<<FindLongStr(str)<<endl;

    }
}

提交后的结果显示超时，本题的字符串长队太大，估计动态规划的思想无法实现。

2.manacher算法

这个算法的思想是真的厉害，get到精髓了很容易能看懂，可惜我看了一下午才明白。不说别的了，还是摆大神的博客：https://www.61mon.com/index.php/archives/181/讲的非常通俗易懂，建议在看的时候拿一个长的字符串自己找一找，感受一下，完了再看图文分析，很容易就能看懂。这里贴几张大神的图片

重点在于已知id以及id对应的最长回文子串（黑色线段长度），在求以位置i为中心的最长回文子串时，找到i以id为中心的对称位置j，根据j的最长回文子串长度来减少计算量。

这个方法的时间复杂度是O(n),提交之后AC了。具体的代码如下：

#include <iostream>
#include <cstring>
#include <stdio.h>
using namespace std;
int Manacher(string str)
{
    int id,i,j;
    int max_len=-1;  // 最长回文长度
    int mx=0;
    int len=str.length();
    char *str_new=new char[len*2+3]; //增加了两个边界符
    int *p=new int[len*2+3];
    str_new[0] = '$'; //前边界判断
    str_new[1] = '#';
    for (i=0,j=2; i < len; i++)
    {
        str_new[j++] = str[i];
        str_new[j++] = '#';
    }
    len=j;
    str_new[j] = '\0'; //后边界判断
    for (i=1;i<len;i++)
    {
        if (i<mx)
            p[i]=p[2*id-i]<mx-i?p[2*id-i]:mx-i;
        else
            p[i]=1;
        while (str_new[i-p[i]]==str_new[i+p[i]])  // 不需边界判断，因为左有'$',右有'\0'
            p[i]++;
        if (mx<i+ p[i])
        {
            id=i;
            mx=i+p[i];
        }
        max_len=max_len>p[i]-1?max_len:p[i]-1;
    }
    delete []str_new;
    delete []p;
    return max_len;
}

int main()
{
    int num;
    string str;
    freopen("input.txt","r",stdin);
    cin>>num;
    while (num--)
    {
        cin>>str;
        cout<<Manacher(str)<<endl;
    }
    return 0;
}

这个方法还是略屌的，不过不知道这个方法还有没有其他的应用该领域。动态规划虽然时间复杂度有O（n2），但是使用的范围广，建议还是以掌握动态规划为主。