最长回文子串

来源：互联网发布：学口语交流软件编辑：程序博客网时间：2024/05/18 05:17

题：给出一个只由小写英文字符a,b,c...y,z组成的字符串S,求S中最长回文串的长度。回文就是正反读都是一样的字符串,如aba, abba等。

例如：aaaa与abab：最长的回文串长度分别为4、3。

解法一：（该解法有误，见勘误）

最先考虑到，这又是一个后缀数组的应用，一个字符串X如果含有回文子串，那么在其后面“连接”一个逆序X’，类似最长公共子串的解决方法，通过后缀数组寻找，这个最长回文子串必然会出现两次，类似的，我们将串X变为X#X’，其中X’是X的逆序序列。之后的实现跟最长公共子串就基本一样了，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/* 最长回文子串 LPS */
 
int maxlen;  // 记录最长回文子串的长度
 
/* 后缀数组 */
char * suff[100];
 
int pstrcmp(const void *p, const void *q)
{
    return strcmp(*(char**)p,*(char**)q);
}
 
int comlen_suff(char * p, char * q)
{
    int len = 0;
    while(*p && *q && *p++ == *q++)
    {
        ++len;
        if(*p == '#' || *q == '#')
        {
            break;
        }
    }
    int count = 0;
    while(*p)
    {
        if(*p++ == '#')
        {
            ++count;
            break;
        }
    }
    while(*q)
    {
        if(*q++ == '#')
        {
            ++count;
            break;
        }
    }
    if(count == 1)
        return len;
    return 0;
}
 
void LPS_suffix(char * X, int xlen)
{
    maxlen = 0;
 
    int len_suff = 2 * xlen + 1;
    char * arr = new char [len_suff + 1];  /* 将X和逆序X连接到一起 */
    strcpy(arr,X);
    arr[xlen] = '#';
 
    char *p = X, *q = arr + len_suff;  /* 逆序复制 */
    *q = '\0';
    while(*p && (*--q = *p++));
 
    for(int i = 0; i < len_suff; ++i)  /* 初始化后缀数组 */
    {
        suff[i] = & arr[i];
    }
 
    qsort(suff, len_suff, sizeof(char *), pstrcmp);
 
    for(int i = 0; i < len_suff-1; ++i)
    {
        int len = comlen_suff(suff[i],suff[i+1]);
        if(len > maxlen)
        {
            maxlen = len;
        }
    }
}

这种方法的复杂度还是比较高的，大于nlgn，甚至接近于n^2，我查了一下，网上存在着O(n)的解法，实现很巧妙，详见参考资料。

解法二：

这种解法很巧妙，我看了好久才明白，具体算法见参考资料，这二人的博客已经写的很详细了，图文并茂，这里就不重述了，直接上代码了，要注意的是：参考资料博文中的mx和id分别记录最大回文子串的长度和下标位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/* O(n)解法 */
#define MIN(a,b) ((a) < (b) ? (a) : (b))
 
int maxid;        // 最长回文子串下标
int LPS_rb[100];  // i为中心的回文子串右边界下标right border
char str[100];    // 原字符串处理后的副本
 
void LPS_linear(char * X, int xlen)
{
    maxlen = maxid = 0;
 
    str[0] = '$';  // 将原串处理成所需的形式
    char *p = str;
    *(++p)++ = '#';
    while((*p++ = *X++) != '\0')
    {
        *p++ = '#';
    }
 
    for(int i = 1; str[i]; ++i)  // 计算LPS_rb的值
    {
        if(maxlen > i)          // 初始化LPS[i]
        {
            LPS_rb[i] = MIN(LPS_rb[2*maxid-i],(maxlen-i));
        }else
        {
            LPS_rb[i] = 1;
        }
        while(str[i-LPS_rb[i]] == str[i+LPS_rb[i]]) // 扩展
        {
            ++LPS_rb[i];
        }
        if(LPS_rb[i]-1 > maxlen)
        {
            maxlen = LPS_rb[i]-1;
            maxid = i;
        }
    }
}

给出测试用例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void main()
{
    char X[30];  // 设串不超过30
    /* test case
     * aaaa
     * abab
     */
    while(cin.getline(X,30))
    {
        /* 后缀数组方法 */
        LPS_suffix(X,strlen(X));
        printf("%d\n", maxlen);
 
        /* O(n)方法 */
        LPS_linear(X,strlen(X));
        printf("%d\n", maxlen);
    }
}

勘误：感谢 @鼻子很帅的猪，的确如他所说，解法一是有问题的，这里给出O(n^2)的解法一，使用动态规划来做

思想：DP的考虑源于暴力方法，暴力方法是寻找一个字符串的所有子串，需要O(n^2)的开销，然后对于每一个子串需要O(n)的开销来判断是否是回文，故暴力方案为O(n^3)，但是这里有一个问题，就是在暴力的时候有重复判断；

例如，如果子串X为回文，那么sXs也是回文；如果X不是回文，那么sXs也不是回文；另外，ss也是回文。所以这里使用DP我们可以按照子串长度从小到大的顺序来构建DP状态数组，使用一个二维数组dp[i][j]记录子串[i-j]是否为回文子串，那么我们就有初始化和自底向上的方案了；

初始化：单字符串和相等的双字符串为回文

自底向上构造：X[i]==X[j] && dp[i+1][j-1]==1 则dp[i][j] = 1

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <iostream>
using namespace std;
 
/* 最长回文子串 LPS - DP */
 
int maxlen;  // LPS长度
 
/* DP解法 */
bool dp[31][31]; // dp[i][j]记录子串[i-j]是否构成回文
 
void LPS_dp(char * X, int xlen)   // 略去测试X合法性
{
    maxlen = 1;
 
    for(int i = 0; i < xlen; ++i) // 初始化
    {
        dp[i][i] = 1;       // 单字符为回文
        if(i && (X[i-1] == X[i]))
        {
            dp[i-1][i] = 1; // 双字符串为回文
        }
    }
 
    for(int len = 2; len < xlen; ++len)
    {
        for(int begin = 0; begin < xlen-len; ++begin)
        {
            int end = begin + len; // 从长度为3开始
 
            if((X[begin]==X[end]) && (dp[begin+1][end-1]==1))
            {
                dp[begin][end] = 1;
                if(end - begin + 1 > maxlen)
                {
                    maxlen = end - begin + 1;
                }
            }
        }
    }
}
 
void main()
{
    char X[30];  // 设串不超过30
    /* test case
     * abcfdcba / abba / abab / aaaa
     */
    while(cin.getline(X,30))
    {
        memset(dp,0,sizeof dp);
        /* DP方法 */
        LPS_dp(X,strlen(X));
        printf("%d\n", maxlen);
    }
}

再次感谢 @鼻子很帅的猪的提醒与建议。

本节相关代码可以到这里下载。

（全文完）

参考资料:

题目：http://acm.hdu.edu.cn/showproblem.php?pid=3068

O(n)解法：

http://www.felix021.com/blog/read.php?2040

http://blog.csdn.net/ggggiqnypgjg/article/details/6645824

0 0