PKU 3261 Milk Pattern - 后缀数组+LCP

题目大意：

给出长度为n的数字序列（n<20,000），求重复出次数不小于k的最长子序列（连续）的长度。例如序列 1 2 3 2 3 2 3，k=2，那么序列2 3 2 3重复出现了两次，长度为4。

分析：

此题可以用后缀数组的最长公共前缀LCP来解决。只是需要将字符数组换做数字数组来处理而已。

下面的讨论是基于已求出后缀数组并且做好LCP的预处理的前提下进行的。如何求后缀数组以及最长公共前缀请参考2004年许智磊的IOI国家队论文《后缀数组》。

论文中一个重要结论：LCP(i,j)=min{LCP(k-1,k)|i+1≤k≤j}。即，询问后缀数组中第i个后缀和第j个后缀的最长公共前缀，等同于询问i到j之间所有排名的相邻两个后缀的最长公共前缀。再换句话说，如果LCP(i,j)=lcp的话，说明i到j之间所有的串都和i,j有长度不小于lcp的公共前缀。

应用到此题上来，用两个间隔为k（至少重复的次数）的游标p,q，枚举所有长度为k的区间，询问LCP(p,q)=lcp，在这些lcp中找最大值即为所求。

复杂度后缀数组O(nlogn) + LCP预处理O(nlogn) + 枚举区间求LCP O(nlogn)。所以复杂度为O(nlogn)。

 

1. /*
2. PKU3261 Milk Patterns
3. */
5. #include <stdio.h>
6. #include <memory.h>
7. #include <stdlib.h>
9. #define MAX(a,b) ((a)>(b)?(a):(b))
10. #define MIN(a,b) ((a)>(b)?(b):(a))
12. #define N 20005
13. #define K 35
15. int nday;
17. /***************************************/
19. int power;
20. int lstrank[N];
21. int cmpstr[N];
23. int cmpChar(const void *a,const void *b){
24.     return cmpstr[*(int*)a] - cmpstr[*(int*)b];
25. }
27. int cmpLst(const void *A,const void *B){
28.     int a = *(int*)A;
29.     int b = *(int*)B;
30.     if(lstrank[a]==lstrank[b]) 
31.         return lstrank[a+power]-lstrank[b+power];
32.     return lstrank[a]-lstrank[b];
33. }
35. /*后缀数组
36. 参数：
37.     输入字符串str[];
38.     返回后缀数组sa[];返回名次数组rank[]
39. 说明：
40.     复杂度O(nlogn)
41.     需要stdlib.h辅助全局变量power, lstrank[],cmpstr[]
42. */
43. void suffixArray(int str[],int sa[],int rank[]){
44.     int i,j,n=nday;
46.     for(i=0;i<n;i++) sa[i]=i;
47.     memcpy(cmpstr,str,sizeof(cmpstr));
48.     qsort(sa,n,sizeof(int),cmpChar);
49.     for(i=j=0;i<n;i++){
50.         if(i>0&& str[sa[i]]!=str[sa[i-1]]) j++;
51.         rank[sa[i]]=j;
52.     }
54.     for(power=1;rank[sa[n-1]]<n-1; power*=2)
55.     {
56.         memcpy(lstrank,rank, sizeof(int)*n);
57.         qsort(sa,n,sizeof(int), cmpLst);
58.         for(i=j=0;i<n;i++){
59.             if(i>0&&cmpLst(&sa[i-1], &sa[i])) j++;
60.             rank[sa[i]]=j;
61.         }
62.     }
63. }
65. /*区间最大值询问
66.     preRMQ()用O(nlogn)时间预处理
67.     RMQ()用O(1)的时间询问i~j之间的最大值 
68. */
69. int dr[N][K]={0};
71. void preRMQ(int a[],int n){
72.     int i,j,k,f,s;
73.     for(i=0;i<n;i++) dr[i][0]=a[i];
74.     for(s=f=1;s<n;f++){
75.         for(i=0;;i++){
76.             if(i+s>=n) break;
77.             dr[i][f]= MIN(dr[i][f-1],dr[i+s][f-1]);
78.         }
79.         s=1<<f;
80.     }
81. }
83. int RMQ(int p,int q){
84.     int d,f;
85.     d=q-p+1;
86.     for(f=0;(1<<f)<=d;f++); f--;
87.     return MIN(dr[p][f],dr[q-(1<<f)+1][f]);
88. }
90. /*预处理LCP求h[],height[] 
91. 参数：
92.     输入原字符串str[] 
93.     输入后缀数组sa[]
94.     输入名次数组rank[]
95.     返回height[]
96. 说明：
97.     复杂度O(n)
98.     需要事先用suffixArray计算sa[]和rank[] 
99.     height[i]=LCP(i-1,i)
100.     h[i]=height[rank[i]]
101.     height[i]=h[sa[i]]
102. */
103. void preLCP(int str[],int sa[],int rank[],int height[]){
104.     int i,j,k,s,n=nday;
105.     int h[N];
106.     
107.     for(i=0;i<n;i++){
108.         if(rank[i]==0){
109.             h[i]=0; continue;
110.         }
111.         j=rank[i]-1;
112.         k=rank[i];
113.         if(i==0||h[i-1]<=1) s=0;
114.         else s=h[i-1]-1;
115.         for(;sa[k]+s<n && sa[j]+s<n;s++)
116.             if(str[sa[k]+s]!= str[sa[j]+s]) break;
117.         h[i]=s;
118.     }
119.     for(i=0;i<n;i++) height[rank[i]]= h[i];
120.     preRMQ(height,n);
121. }
123. /*
124. LCP询问后缀数组sa[]中x和y的最长公共前缀，复杂度O(logn) 
125. */
126. int LCP(int x,int y){
127.     if(x<y) return RMQ(x+1,y);
128.     else return RMQ(y+1,x);
129. }
131. /**************************************/
133. int n,m;
134. int str[N];
135. int sa[N];
136. int rank[N];
137. int height[N];
139. void printa(int a[]){
140.     int i;
141.     for(i=0;a[i];i++) printf("%d",a[i]-1);
142.     puts("");
143. }
145. int main()
146. {
147.     int i,j,k;
148.     int ans;
149.     
150.     while(scanf("%d%d",&n,&m)!=EOF){
152.         nday=n+1;
153.         for(i=0;i<n;i++){
154.             scanf("%d",&str[i]); str[i]++;
155.         }
156.         str[n]=0;
158.         suffixArray(str,sa,rank);
159.         preLCP(str,sa,rank,height);
160.         /*
161.         for(i=0;i<n;i++){
162.             printf("%d - %d: ",i,sa[i]);
163.             printa(str+sa[i]);
164.         }*/
166.         ans=0;
167.         for(i=0,j=m-1;j<=n;i++,j++){
168.             k=LCP(i,j);
169.             ans=MAX(ans,k);
170.         }
172.         printf("%d/n",ans);
173.     }
175.     return 0;
176. }