leetCode & hihocoder:最长回文子字符串时间复杂度为O(N)解法

来源:互联网 发布:新世纪期货软件 编辑:程序博客网 时间:2024/05/16 12:27

转载之http://blog.csdn.net/ggggiqnypgjg/article/details/6645824地址


之前自己做过这道题目,不过算法复杂度是O(n^2)的时间复杂度和空间复杂度的

后来http://hihocoder.com/contest/hiho1/rank 这个有比赛,写了个O(n^2)的

一致TLE,看到discuss才发现有O(N)算法,真的是膜拜 

代码来源   http://acm.hust.edu.cn:8080/judge/problem/viewSource.action?id=140283

[cpp] view plaincopy
  1. /***************************************** 
  2. * 
  3. * 2011,UESTC_ACM 
  4. * 回文串 
  5. * By a180285 
  6. * O(n) 算法  
  7. *****************************************/  
  8.   
  9. # include <math.h>  
  10. # include <stdio.h>  
  11. # include <string.h>  
  12. # include <stdlib.h>  
  13. # include <algorithm>  
  14. # include <iostream>  
  15. # include <string>  
  16. # include <queue>  
  17. # include <stack>  
  18. # include <map>  
  19. # include <set>  
  20. # include <vector>  
  21. # include <cstring>  
  22. # include <list>  
  23. # include <ctime>  
  24. # include <sstream>  
  25.   
  26. # define For(i,a)   for((i)=0;i<(a);(i)++)  
  27. # define MAX(x,y)   ((x)>(y)? (x):(y))  
  28. # define MIN(x,y)   ((x)<(y)? (x):(y))  
  29. # define sz(a)      (sizeof(a))  
  30. # define MEM(a)     (memset((a),0,sizeof(a)))  
  31. # define MEME(a)    (memset((a),-1,sizeof(a)))  
  32. # define MEMX(a)    (memset((a),0x7f,sizeof(a)))  
  33. # define pb(a)      push_back(a)  
  34.   
  35. using namespace std;  
  36.   
  37. typedef long long           ll      ;  
  38. typedef unsigned long long  ull     ;  
  39. typedef unsigned int        uint    ;  
  40. typedef unsigned char       uchar   ;  
  41.   
  42.   
  43. template<class T> inline void checkmin(T &a,T b){if(a>b) a=b;}  
  44. template<class T> inline void checkmax(T &a,T b){if(a<b) a=b;}  
  45.   
  46. const int oo=1<<30          ;  
  47. const double eps=1e-7       ;  
  48. const int N=1               ;  
  49. const int M=1100110*2               ;  
  50. const ll P=10000000097ll    ;  
  51.   
  52. char str[M];//start from index 1  
  53. int p[M];  
  54. char s[M];  
  55. int n;  
  56.   
  57. void kp()  
  58. {  
  59.     int i;  
  60.     int mx = 0;  
  61.     int id;  
  62.     for(i=1; i<n; i++)  
  63.     {  
  64.         if( mx > i )  
  65.             p[i] = MIN( p[2*id-i], p[id]+id-i );  
  66.         else  
  67.             p[i] = 1;  
  68.         for(; str[i+p[i]] == str[i-p[i]]; p[i]++)  
  69.             ;  
  70.         if( p[i] + i > mx )  
  71.         {  
  72.             mx = p[i] + i;  
  73.             id = i;  
  74.         }  
  75.     }  
  76. }  
  77.   
  78. void pre()  
  79. {  
  80.     int i,j,k;  
  81.     n = strlen(s);  
  82.     str[0] = '$';  
  83.     str[1] = '#';  
  84.     For(i, n)  
  85.     {  
  86.         str[i*2 + 2] = s[i];  
  87.         str[i*2 + 3] = '#';  
  88.     }  
  89.     n = n*2 + 2;  
  90.     str[n] = 0;  
  91. }  
  92.   
  93. void pt()  
  94. {  
  95.     int i;  
  96.     int ans = 0;  
  97. //    For(i, n)  
  98. //        printf("%c", str[i]);  
  99. //    puts("");  
  100. //    For(i, n)  
  101. //        printf("%d", p[i]);  
  102. //    puts("");  
  103.   
  104.     For(i, n)  
  105.         checkmax(ans, p[i]);  
  106.     printf("%d\n", ans-1);  
  107. }  
  108.   
  109. int main()  
  110. {  
  111.     int n = 0;  
  112.     cin>> n;  
  113.     while( n--){  
  114.         cin>>s;  
  115.         pre();  
  116.         kp();  
  117.         pt();  
  118.     }  
  119.     return 0;  
  120. }  

具体做法可以参考链接;

对于一个字符串数组,我们将其插入一些字符,例如“#”

例如字符     a b c d d f g g

插入后      #a#b#c#d#d#f#g#g#

p[id]       12121212

定义数组 p[],对于插入后的字符串数组我们为chs[]吧

p[id] 表示位置id上为中心的最长回文串向右边可以扩展p[id]个位置,显然,可知

p[id] - 1 就是以id为中心的最长回文串的长度了

定义一个id,当前所知道能最右边扩展的位置的中心点;mx,该id

可以向右扩展mx位

那么只要求出p[] 这个数组,就可以知道最长回文串的长度了

 

上面的式子是根据回文串的对称性做的,理解上不难

因为是从低坐标向高坐标遍历的,id总是小于等于i

对于 p[i], 如果当前mx的值是大于i,所以i是位于以id为中心的回文串中的

也就是说以id为中心,可以找到i的对称,称其为j,(j 总是小于i)

因为p[j]是已知的,只需求出j 的值即可 j = 2 * id - i,这是第一种情况

第二种情况是在当mx - i 也就说 i在以id为中心的回文串中的长度,小于p[j]的长度,看上图,第二行的

右边的长方体的长度是大于mx的,(左右两边是对称的),由于mx之外值我们还没有比较,所以

当前只能取两者中较小的。


算法的构思十分巧妙,再次膜拜


0 0