回文串问题

有关回文串的问题，可能涉及到判断一个字符串是否是回文串、求最大回文子串长度或者求至少添加多少个字符使得输入字符串称为回文串。这些问题我都已经解决，为了使用方便，我把这些实现代码都粘出来了。

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

/**
  * @brief 检测字符串是否为回文字符串,如果是，返回1；否则，返回0       
  */
int isPalindrome(char s[], int len){
    int i, mid = len / 2;

    if (len == 1) return 1;

    for (i = 0; i < mid; i++){
        if (s[i] != s[len - i - 1])
            return 0;
    }
    return 1;
}

//穷举策略：O(n^3)
int getMaxPalindrome1(char s[], int len, int *start)
{
    printf("O(N^3) method.
");
    //offset是子串起始相对于输入字符串起始的偏移量，j是子串长度
    int offset = 0, j = len;
    int maxLen = 0;//存储回文子串的最大长度

    if (len <= 1) return -1;//出错

    while (offset < len){//子串起始逐个后移
        j = len - offset;//j初始化为可获得的最大子串长度
        while (j > 1){
            if (isPalindrome(s+offset, j)){
                if (maxLen < j){
                    maxLen = j;
                    *start = offset;//记录最大子串的偏移
                }
            }
            j--;//缩短子串    
        }
        offset++;//偏移量后移
    }

    return maxLen;    
}

//此算法仍然可以继续优化,在知道maxLen值的情况下，我们可以直接
//寻找以offset为中心比maxLen大一个的长度来初始化left和right
//的初始值,算法更加高效.
int getMaxPalindrome2(char s[], int len, int *start)
{
    printf("O(N^2) method.
");

    //奇数长度子串和偶数长度子串的最大回文长度
    int offset = 0, maxLen = 0, oddLen, evenLen;
    int left, right;//分别指向子串的左右边界

    if (len <= 1) return -1;

    while (offset < len){
        //奇数长度子串的情况
        left  = offset - 1;
        right = offset + 1;
        oddLen = 1;//初始化最大奇数回文长度为1
        //while (left >= 0 && right < len && isPalindrome(s+left, right-left+1)){
        while (left >= 0 && right < len && s[left] == s[right]){
            left--;
            right++;
            oddLen += 2;    
        }
        if (oddLen > maxLen){
            maxLen = oddLen;
            *start = ++left;
        }    

        //偶数长度子串的情况
        left  = offset;
        right = offset + 1;
        evenLen = 0;//初始化最大偶数回文长度为0
        //while (left >= 0 && right < len && isPalindrome(s+left, right-left+1)){
        while (left >= 0 && right < len && s[left] == s[right]){
            left--;
            right++;
            evenLen += 2;    
        }
        if (evenLen > maxLen){
            maxLen = evenLen;
            *start = ++left;
        }

        //偏移量自加
        offset++;
    }

    return maxLen;
}

// Manacher算法实现
// 对原字符串进行预处理
// srcstr[] 原字符数组 head:新串起始标志 separator:字符之间的分隔符
char* prepare(char srcstr[], int len, char head, char separator)
{
    int i, length = len;
    char *newstr = (char*)malloc(2*length + 3);
    newstr[0] = head;
    for (i = 0; i < length; i++){
        newstr[2*i+1] = separator;
        newstr[2*i+2] = srcstr[i];
    }
    newstr[2*length+1] = separator;
    newstr[2*length+2] = '';//添加结尾标志

    return newstr;//返回字符串起始地址
}

int getMaxPalindrome(char s[], int len, int *start)
{
    char* newstr = prepare(s, len, '$', '#');//预处理
    int   maxLen = 0, length = strlen(newstr);  //新串长度
    int   i, mx = 0, pi = 1;//最长回文右边界mx和对称中心索引pi
    int*  p = (int*)malloc(length * sizeof(int));//辅助数组

    printf("O(N) method.
");

    p[0] = 0;//头标志$不统计回文串长度
    for (i = 1; i < length; i++){
        if (mx > i){//如果p[i]在最长回文串的范围内
            p[i] = ((mx - i) < p[2*pi - i]) ? (mx - i) : p[2*pi - i];
        }else{
            p[i] = 1;
        }

        while (newstr[i - p[i]] == newstr[i + p[i]] && i - p[i] > 0 && i + p[i] < length){
            p[i]++;
        }

        if (i + p[i] > mx){//如果新的最长回文串超出mx边界
            mx = i + p[i];
            pi = i;
        }
    }
    //寻找最大回文长度
    for (i = 1; i < length; i++)
    {
        if (p[i] > maxLen){
            maxLen = p[i];
            *start = (i-p[i])/2;//计算原串中最长回文子串起始索引
        }
    }

    free(newstr);
    free(p);

    return maxLen - 1;
}

//返回输入字符串应该添加至少多少个字符方可构成回文串
int toPalindrome(char s[], int len)
{
    char* re = (char*)malloc(len);//对s置逆
    int   cnt, i, j, temp, maxComm = 0;//两字符串的公共子串最大值
    
    for (i = 0; i < len; i++){
        re[len-1-i] = s[i];
    }
    //计算最长公共子串
    for (cnt = 0; cnt < len; cnt++){
        i = cnt; j = 0;
        temp = 0;
        while(i < len){
            if (s[i] == re[j]){
                temp++;
                i++; j++;
            }else{
                if (temp > maxComm) 
                    maxComm = temp;
                temp = 0;
                j++;
            }

            if (j >= len){//如果其中一个字符串已经遍历一遍
                if (temp > maxComm) 
                    maxComm = temp;
                temp = 0;
                j = 0;
                i++;
            }
        }
    }

    return len - maxComm;
}

// for Test
int main(void)
{
    char  str[100];
    char* newstr = NULL;
    int  i, len, start = 0;

    fgets(str, sizeof(str), stdin);
    len = (int)strlen(str);
    if (str[len-1] == '
'){
        str[len-1] = '';
        --len;
    }
    printf("Get: %s of size %d
Answer: ", str, len);

#if 0
    newstr = prepare(str, len, '$', '#');
    printf("new string: %s
", newstr);
    printf("new length: %d
", strlen(newstr));
    free(newstr); newstr = NULL;
#endif

#if 1
    printf(" Add %d
", toPalindrome(str, len));
#endif

#if 0
    if (isPalindrome(str, len)){
        printf("YES
");
    }else{
        printf("No
");
    }
    //最大回文子串
    len = getMaxPalindrome(str, len, &start);
    if (len > 1){
        printf("Max Palindrome String Length: %d
", len);
        for (i = 0; i < len; i++)
            printf("%c", str[start+i]);
        printf("
");    
    }
#endif

    return 0;
}