POJ 2758 后缀数组

 思路：

1.如果没有操作I，也就是insert操作，则很容易想到用后缀数组处理，直接计算lcp(i,j)即可，要注意的是用rmq计算lcp[i][j]的时候，如果i==j，要做特殊处理！

2.题目有个很容易误解的地方，就是Q操作的时候是对原始下标，而I操作的p是插入后的下标

3.计算Q(i,j)的时候，首先计算lcp(i,j)，

    1)如果lcp(i,j)大于离i,j最近的插入字符到i,j的距len, 则定位到i+len, j+len, 比较i+len,j+len处的插入字符，从而问题转换为lcp(i',j')，重复即可。

    2)如果lcp(i,j)小于等于len，则答案即为lcp(i,j);

 

 

 

 

2. #include <iostream>
3. #include <string>
4. #include <algorithm>
5. using namespace std;
7. #define Min(a,b) (a)<(b)?(a):(b)
8. const int N = 51000;
9. const int M = 260;
10. int n, m;
11. char s[N];
12. struct
13. {
14.     char c;
15.     int p;
16. }si[M];
17. int cnt[N], mem[4][N], *rank, *nrank, *sa, *nsa, lcp[17][N];
18. // lcp[i][j]: longest commen prefix ( suffix(sa[k+1]), suffix(sa[k]) ) j <= k < j+2^i
20. void radix_sort()
21. {
22.     int i, j, k;
23.     rank = mem[0];
24.     nrank = mem[1];
25.     sa = mem[2];
26.     nsa = mem[3];
28.     for(i = 0; i < n; i++) cnt[s[i]]++;
29.     for(i = 1; i < M; i++) cnt[i] += cnt[i-1];
30.     for(i = n-1; i >= 0; i--) sa[--cnt[s[i]]] = i;
31.     for(rank[0]=0, i=1; i < n; i++)
32.     {
33.         rank[sa[i]] = rank[sa[i-1]];
34.         if(s[sa[i]]!=s[sa[i-1]]) rank[sa[i]]++;
35.     }
37.     for(k = 1; k<n && rank[sa[n-1]] < n-1; k*=2)
38.     {
39.         for(i = 0; i < n; i++) cnt[rank[sa[i]]] = i+1;
40.         for(i = n-1; i >= 0; i--) if(sa[i]-k>=0)
41.             nsa[--cnt[rank[sa[i]-k]]] = sa[i]-k;
43.         // max(sa[i]-k)=n-k-1 , therefore i = n-k;
44.         for(i = n-k; i < n; i++)
45.             nsa[--cnt[rank[i]]] = i;
47.         for(nrank[nsa[0]], i=1; i < n; i++)
48.         {
49.             nrank[nsa[i]] = nrank[nsa[i-1]];
50.             if(rank[nsa[i]] != rank[nsa[i-1]]
51.                 || rank[nsa[i]+k] != rank[nsa[i-1]+k])
52.             nrank[nsa[i]]++;
53.         }
54.         swap(rank, nrank);
55.         swap(sa, nsa);
56.     }
57. }
59. void print()
60. {
61.     for(int i=0;i<n;i++) printf("%d %s/n", sa[i], s + sa[i]);puts("");
62.     puts(s);for(int i=0;i<n;i++) printf("%d ", rank[i]);puts("");
63. }
65. void get_lcp_rmq()
66. {
67.     int i, j, k;
68.     for(i=0,k=0; i<n; i++)
69.     {
70.         if(rank[i]==n-1) lcp[0][rank[i]]=k=0;
71.         else
72.         {
73.             if(k>0)k--;
74.             j = sa[rank[i]+1];
75.             for(;s[i+k]==s[j+k];k++) ;
76.             lcp[0][rank[i]]=k;
77.         }
78.     }
80.     for(i=0,k=1; k<n; k*=2, i++)
81.     {
82.         for(j = 0; j+k < n; j++)
83.             lcp[i+1][j] = Min(lcp[i][j], lcp[i][j+k]);
84.     }
85. }
87. int rmq(int a, int b)
88. {
89.     int i, j, k;
90.     a = rank[a];
91.     b = rank[b];
92.     if(a>b) swap(a,b);
94.     int t=b-a;
95.     for(i=0,k=1; 2*k<t; i++,k*=2) ;
96.     return Min(lcp[i][a], lcp[i][b-k]); // not  b-k+1
97.     // lcp[0][i]: LCP(i,i+1)
98. }
99. /*
100. aaaaaaaa
101. I a 2
102. I b 3
103. Q 1 3
104. */
106. int query(int a, int b)
107. {
108.     int i,j,k;
109.     int mi, ret=0;
110.     int x, y, t;
111.     char c1, c2;
113.     for(x = 0; si[x].p <= a; x++);
114.     for(y = 0; si[y].p <= b; y++);
115.     if(a==b) return n-a+m-x-2;
116.     while(1)
117.     {
118.         k = rmq(a, b);
119.         i = si[x].p-a;
120.         j = si[y].p-b;
121.         t = Min(k, Min(i,j));
122.         ret+=t; a+=t; b+=t;
123.         if(t==i || t==j)
124.         {
125.             while(si[x].p==a&&si[y].p==b)
126.             {
127.                 if(si[x].c==si[y].c) x++,y++,ret++;
128.                 else return ret;
129.             }
130.             while(si[x].p==a)
131.             {
132.                 if(si[x].c==s[b]) x++,b++,ret++;
133.                 else return ret;
134.             }
135.             while(si[y].p==b)
136.             {
137.                 if(si[y].c==s[a]) y++,a++,ret++;
138.                 else return ret;
139.             }
140.         }
141.         else return ret;
142.     }
144.     return ret;
145. }
148. void insert(char ch, int pos)
149. {
150.     int i;
151.     for(i = 0; i < m; i++)
152.     {
153.         if(si[i].p>=pos)break;
154.         else pos--;
155.     }
157.     if(pos >= n) pos = n-1;
158.     int j=i;
159.     for(i = m++; i > j; i--) si[i] = si[i-1];
160.     si[j].c = ch;
161.     si[j].p = pos;
162. }
164. int main()
165. {
166.     int i, j, k;
167.     char cmd[10];
169.     scanf("%s", s);
170.     n = strlen(s);
171.     s[n++]=0;
173.     radix_sort();
174.     get_lcp_rmq();
178.     si[0].c = 0;
179.     si[0].p = N;
180.     m = 1;
182.     scanf("%d", &k);
183.     while(k--)
184.     {
185.         scanf("%s", cmd);
186.         if(cmd[0]=='Q')
187.         {
188.             scanf("%d%d", &i, &j);
189.             printf("%d/n", query(i-1,j-1));
190.         }
191.         else
192.         {
193.             scanf("%s%d", cmd, &i);
194.             insert(cmd[0], i-1);
195.         }
196.     }
198.     return 0;
199. }