最长回文子串

题：给出一个只由小写英文字符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.youkuaiyun.com/ggggiqnypgjg/article/details/6645824