*LeetCode：Longest Palindromic Substring

问题描述：给定一个字符串，寻找最长回文子串。

猜想：当拿到这个问题，最初的想法打算用分治法来解，也许是受到近期在看算法导论的影响，其实它跟算法导论里"最大子数组"问题类似。但是，唯一的不足：没有被accepted，但是在vs2010里我解决了这个问题。针对这个问题，我花费2天的时间去完善，但是仍然存在瑕疵，故想记录下来当时的想法，也希望得到你们的帮助。

1、算法描述：

step1: 先考虑特殊情况，或者说是最小子问题。

若字符串只有一个字符即len=1；

若字符串len=2,则只需考虑两者是否相等；

若字符串len=3进行处理；

（任何的问题的解，都可以分解成以上子问题解的组合）

step2: 将问题划分成3种情况考虑，即左：left_result、右：right_result、跨界:cross_result。然后依次递归调用函数Search_Palindrome寻找回文子串。最后比较left_result、right_result、cross_result三者的回文子串长度，选择最长的结果返回。

2、具体实现参考以下代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct result_palindrome
{

char *_low;
char *_high;
int _sum;

}Result;

char *s_buf;

//declaration
Result *Cross_search_palindrome(char *s_start, char *s_mid, char *s_end, int len);
bool Compare_literal(char *s_start, char *s_end, char *str, int len);

Result *Search_Palindrome(char *s_start, char *s_end, int len);
char* longestPalindrome(char* s);

bool Compare_literal(char *s_start, char *s_end, char *str, int len)
{

int i,j;
for (i=1,j=len; i<=j; i++,j--)
{
if (*s_start!=*str || *s_end!=*str)
{
return false;
}
s_start++;
s_end--;
}
return true;
}

Result *Cross_search_palindrome(char *s_start, char *s_mid, char *s_end, int len)
{
Result *result=NULL;
int length=0;
bool Com_result;
char *max_left;
char *max_right;

char *_left, *_right;
_left=s_mid-1;
_right=s_mid+1;

result=(Result*)malloc(sizeof(Result)*1);
if (result==NULL)
{
printf("error in memory in function Cross_search_palindrome\n");
}

for (; _left!=s_start && _right!=s_end; _left--,_right++)
{
if (*_left!=*_right)
{
/*length=_right-_left+1-2;*/
result->_sum=2*length+1;//come error
result->_low=_left+1;
result->_high=_right-1;

return result;
}
length++;
}

if (_left!=s_start /*&& _right==s_end*/)
{

if (*_left!=*_right)
{
length=length;
result->_sum=2*length+1;//come error
result->_low=_left+1;
result->_high=_right-1;

return result;//forget return
}
length++;
_left--;

Com_result=Compare_literal(_left+1,_right,_left,2*length+1);
if (Com_result==false)
{
result->_sum=2*length+1;//come error
result->_low=_left+1;
result->_high=_right;

return result;
}

//all element is the same
/*length=length+1;*/
result->_sum=2*length+2;//come error
result->_low=_left;
result->_high=_right;

return result;

}
else
{

if (*_left!=*_right)
{
result->_sum=2*length+1;
result->_low=_left+1;
result->_high=_right-1;

return result;
}
length++;
result->_sum=2*length+1;
result->_low=_left;
result->_high=_right;

return result;
}

}

Result *Search_Palindrome(char *s_start, char *s_end, int len)
{
if (len==2)
{
Result *result2=(Result*)malloc(sizeof(Result)*1);
if (*s_start==*s_end)
{

result2->_low=s_start;
result2->_high=s_end;
result2->_sum=2;

return result2;
}
else
{
result2->_low=NULL;
result2->_high=NULL;
result2->_sum=0;

return result2;
}
}

if (len==3)
{
Result *result3=(Result*)malloc(sizeof(Result)*1);
if (*s_start==*s_end)
{
result3->_sum=3;
result3->_low=s_start;
result3->_high=s_end;

return result3;
}
else if (*s_start==*(s_start+1))
{
result3->_sum=2;
result3->_low=s_start;
result3->_high=(s_start+1);

return result3;
}
else if (*(s_start+1)==*s_end)
{
result3->_sum=2;
result3->_low=(s_start+1);
result3->_high=s_end;

return result3;
}

}

if (s_start==s_end)
{
Result *result4=(Result*)malloc(sizeof(Result)*1);
result4->_low=s_start;
result4->_high=s_end;
result4->_sum=1;

return result4;
}
else
{

Result *left_result=(Result*)malloc(sizeof(Result)*1);
Result *right_result=(Result*)malloc(sizeof(Result)*1);
Result *cross_result=(Result*)malloc(sizeof(Result)*1);

left_result=Search_Palindrome(s_start,s_start+len/2,len/2+1);
right_result=Search_Palindrome(s_start+len/2+1,s_end,len/2-1);

cross_result=Cross_search_palindrome(s_start,s_start+len/2,s_end,len);
if (left_result->_sum>=right_result->_sum && left_result->_sum>=cross_result->_sum)
{
return left_result;
}
else if (right_result->_sum>=left_result->_sum && right_result->_sum>=cross_result->_sum)
{
return right_result;
}
else if (cross_result->_sum>=left_result->_sum && cross_result->_sum>=right_result->_sum)
{
return cross_result;
}
}
}

char* longestPalindrome(char* s) {
//count the length of s
int length=0;
int Palindrome_length=0;
char *low, *high;
char *c_s=s;
char *result_palindrome=NULL;
char *buf;

while(*c_s!='\0')
{

length++;
c_s++;
}
printf("string length is %d\n",length);

low=s;
high=s+length-1;
Result *back_value=Search_Palindrome(low,high,length);
if (back_value==NULL)
{
printf("something wrong in function Search_Palindrome\n");
exit(-1);
}
Palindrome_length=back_value->_sum;
printf("Palindrome string length is %d\n",Palindrome_length);

//open a new memory
result_palindrome=(char*)malloc(sizeof(char)*length);
if (result_palindrome==NULL)
{
printf("error in open memory\n");
exit(-1);
}
buf=result_palindrome;

low=back_value->_low;
high=back_value->_high;

while(low!=high)
{

*result_palindrome=*low;
low++;
result_palindrome++;
}
*result_palindrome=*low;
*(result_palindrome+1)='\0';
result_palindrome=buf;

return result_palindrome;

}

主函数：

void main()
{

char str[]="cfcaeff";//"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc";//"zeusnilemacaronimaisanitratetartinasiaminoracamelinsuez"
char *back_str=longestPalindrome(str);

if (back_str==NULL)
{
printf("something wrong in function longestPalindrome\n");
exit(-1);
}

printf("longestPalindrome is %s\n",back_str);
/*	free(back_str);*/
return;
}

3、结果

当给定字符串"cfcaeff"，最长回文子串为"cfc"，实验结果如下。



最后给出unaccepted的原因：






但是，当给定长度为1000的字符串"cccc....cccc"时,vs2010结果是正确的，如下所示。






对于其他可以自行验证。针对未接受的原因或者程序中的缺点，希望大家给出宝贵的意见，谢谢！