最长回文字串

void LCS_dp(char * X, int xlen, char * Y, int ylen)
{    
    maxlen = maxindex = 0;    
    for(int i = 0; i < xlen; ++i)    
    {        
        for(int j = 0; j < ylen; ++j)        
        {            
            if(X[i] == Y[j])            
            {                
                if(i && j)                
                {                    
                    dp[i][j] = dp[i-1][j-1] + 1;                
                }                
                
                if(i == 0 || j == 0)                
                {                    
                    dp[i][j] = 1;                
                }                
                
                if(dp[i][j] > maxlen)                
                {                    
                    maxlen = dp[i][j];                    
                    maxindex = i + 1 - maxlen;                
                }            
            }        
        }    
    }    
    outputLCS(X);
}

#include <iostream>   
using namespace std;  
  
#define MAXCHAR 5000 //最长处理5000个字符   
  
char c[MAXCHAR], *a[MAXCHAR];  
  
int comlen( char *p, char *q )  
{  
    int i = 0;  
    while( *p && (*p++ == *q++) )  
        ++i;  
    return i;  
}  
  
int pstrcmp( const void *p1, const void *p2 )  
{  
    return strcmp( *(char* const *)p1, *(char* const*)p2 );  
}  
  
  
int main(void)  
{  
    char ch;  
    int  n=0;  
    int  i, temp;  
    int  maxlen=0, maxi=0;  
    printf("Please input your string:\n");  
  
    n = 0;  
    while( (ch=getchar())!=‘\n‘ )  
    {  
        a[n] = &c[n];  
        c[n++] = ch;  
    }  
    c[n]=‘\0‘;     // 将数组c中的最后一个元素设为空字符，以终止所有字符串   
  
    qsort( a, n, sizeof(char*), pstrcmp );  
    for(i = 0 ; i < n-1 ; ++i )  
    {  
        temp=comlen( a[i], a[i+1] );  
        if( temp>maxlen )  
        {  
            maxlen=temp;  
            maxi=i;  
        }  
    }  
    printf("%.*s\n",maxlen, a[maxi]);  
      
    return 0;  
}  

string longestPalindromeDP(string s) 
{  
    int n = s.length();  
    int longestBegin = 0;  
    int maxLen = 1;  
    bool table[1000][1000] = {false};  
    for (int i = 0; i < n; i++) 
    {    
        table[i][i] = true;   //前期的初始化  
    }  
    
    for (int i = 0; i < n-1; i++) 
    {    
        if (s[i] == s[i+1]) 
        {      
            table[i][i+1] = true; //前期的初始化,针对length为2的回文    
            longestBegin = i;      
            maxLen = 2;    
        }  
    }  
    
    for (int len = 3; len <= n; len++)         //针对length大于等于3的回文
    {    
        for (int i = 0; i < n-len+1; i++) 
        {      
            int j = i+len-1;   
            if (s[i] == s[j] && table[i+1][j-1]) 
            {        
                table[i][j] = true;        
                longestBegin = i;        
                maxLen = len;      
            }    
        }  
    }  
    return s.substr(longestBegin, maxLen);
}