HDU 4622 Reincarnation 后缀数组 或 后缀自动机

题目大意：

就是现在给定字符串S (长度不超过2000), 接下来是Q次询问(Q <= 10000), 每次询问给出 l, r, 输出S[l, r]这一段S的子串中不同字串的个数

大致思路：

首先如果用后缀数组的话不难想到求出S的后缀数组之后, 对于每一次询问 l, r, 遍历height数组找到 l <= sa[i] <= r的那些, 然后用lcp记录之前已经有计算过的长度, 向后遍历的同时更新lcp, 如果某个sa[i]在[l, r]中, 其对答案的贡献是 r - sa[i] + 1 - lcp (如果> 0)

这样复杂度是O(Q|S|)

如果用后缀自动机来做的话我刚开始想的是对于S建立后缀自动机之后, 对于每次询问, 将子串[l, r]在S的后缀自动机上遍历一遍, 统计出现的子串数量, 复杂度最坏情况下O(Q|S|)

后来发现可以对于S的每个后缀建立一次后缀自动机, 预处理出所有 [l, r]之间的子串数量然后O(1)查询, 复杂度O(|S|*|S| + Q)

3种做法的代码如下：

后缀数组做法：

Result  :  Accepted     Memory  :  1696 KB     Time  :  1107 ms

/*
* Author: Gatevin
* Created Time: 2015/4/16 16:01:32
* File Name: Rin_Tohsaka.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++e)
#define SHOW_MEMORY(x) cout<<sizeof(x)/(1024*1024.)<<"MB"<<endl

#define maxn 2333
#define rank Rank
int wa[maxn], wb[maxn], wv[maxn], Ws[maxn];

int cmp(int *r, int a, int b, int l)
{
return r[a] == r[b] && r[a + l] == r[b + l];
}

void da(int *r, int *sa, int n, int m)
{
int *x = wa, *y = wb, *t, i, j, p;
for(i = 0; i < m; i++) Ws[i] = 0;
for(i = 0; i < n; i++) Ws[x[i] = r[i]]++;
for(i = 1; i < m; i++) Ws[i] += Ws[i - 1];
for(i = n - 1; i >= 0; i--) sa[--Ws[x[i]]] = i;
for(j = 1, p = 1; p < n; j <<= 1, m = p)
{
for(p = 0, i = n - j; i < n; i++) y[p++] = i;
for(i = 0; i < n; i++) if(sa[i] >= j) y[p++] = sa[i] - j;
for(i = 0; i < n; i++) wv[i] = x[y[i]];
for(i = 0; i < m; i++) Ws[i] = 0;
for(i = 0; i < n; i++) Ws[wv[i]]++;
for(i = 1; i < m; i++) Ws[i] += Ws[i - 1];
for(i = n - 1; i >= 0; i--) sa[--Ws[wv[i]]] = y[i];
for(t = x, x = y, y = t, p = 1, x[sa[0]] = 0, i = 1; i < n; i++)
x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
return;
}

int rank[maxn], height[maxn];
void calheight(int *r, int *sa, int n)
{
int i, j, k = 0;
for(i = 1; i <= n; i++) rank[sa[i]] = i;
for(i = 0; i < n; height[rank[i++]] = k)
for(k ? k-- : 0, j = sa[rank[i] - 1]; r[i + k] == r[j + k]; k++);
return;
}

char in[maxn];
int s[maxn], sa[maxn];

int solve(int l, int r, int N)
{
lint ans = 0;
int lcp = 0;
for(int i = 1; i <= N; i++)
{
lcp = min(lcp, height[i]);
if(sa[i] >= l && sa[i] <= r)
{
if(r - sa[i] + 1 > lcp)
{
ans += (r - sa[i] + 1 - lcp);
lcp = r - sa[i] + 1;
}
}
}
return ans;
}

int main()
{
int T;
scanf("%d", &T);
while(T--)
{
scanf("%s", in);
int len = strlen(in);
for(int i = 0; i < len; i++)
s[i] = in[i] - 'a' + 1;
s[len] = 0;
da(s, sa, len + 1, 30);
calheight(s, sa, len);
int Q;
scanf("%d", &Q);
while(Q--)
{
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", solve(l - 1, r - 1, len));
}
}
return 0;
}

后缀自动机的做法：

方式1 O(|S|Q)：

Result  :  Accepted     Memory  :  2108 KB     Time  :  2730 ms

/*
* Author: Gatevin
* Created Time: 2015/4/16 16:42:32
* File Name: Rin_Tohsaka.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++e)
#define SHOW_MEMORY(x) cout<<sizeof(x)/(1024*1024.)<<"MB"<<endl

#define maxm 2333
#define maxn 4444
char s[maxm];

struct Suffix_Automation
{
struct State
{
State *par;
State *go[26];
int val, maxcnt;
void init(int _val = 0)
{
par = 0, val = _val;
maxcnt = 0;
memset(go, 0, sizeof(go));
}
};
State *root, *last, *cur;
State nodePool[maxn];
State* newState(int val = 0)
{
cur->init(val);
return cur++;
}
void initSAM()
{
cur = nodePool;
root = newState();
last = root;
}
void extend(int w)
{
State *p = last;
State *np = newState(p->val + 1);
while(p && p->go[w] == 0)
{
p->go[w] = np;
p = p->par;
}
if(p == 0)
np->par = root;
else
{
State *q = p->go[w];
if(p->val + 1 == q->val)
np->par = q;
else
{
State *nq = newState(p->val + 1);
memcpy(nq->go, q->go, sizeof(q->go));
nq->par = q->par;
q->par = nq;
np->par = nq;
while(p && p->go[w] == q)
{
p->go[w] = nq;
p = p->par;
}
}
}
last = np;
}
int d[maxm];
State *b[maxn];
void topo()
{
int maxVal = 0;
int cnt = cur - nodePool;
memset(d, 0, sizeof(d));
for(int i = 1; i < cnt; i++)
maxVal = max(maxVal, nodePool[i].val), d[nodePool[i].val]++;
for(int i = 1; i <= maxVal; i++) d[i] += d[i - 1];
for(int i = 1; i < cnt; i++) b[d[nodePool[i].val]--] = &nodePool[i];
b[0] = root;
}
void solve(int L, int R)
{
for(int i = 0; i < cur - nodePool; i++) b[i]->maxcnt = 0;
State *now = root;
int cnt = 0;
for(int i = L; i <= R; i++)
{
int w = s[i] - 'a';
if(now->go[w])
{
now = now->go[w];
cnt++;
now->maxcnt = max(now->maxcnt, cnt);
}
else
{
while(now && now->go[w] == 0)
{
now = now->par;
if(now)
{
cnt = now->val;
now->maxcnt = cnt;
}
}
if(now == 0)
now = root, cnt = 0;
else
{
now = now->go[w];
cnt++;
now->maxcnt = max(now->maxcnt, cnt);
}
}
}
int ans = 0;
cnt = cur - nodePool;
for(int i = cnt - 1; i > 0; i--)
{
if(b[i]->maxcnt)
{
b[i]->par->maxcnt = b[i]->par->val;
ans += b[i]->maxcnt - b[i]->par->val;
}
}
printf("%d\n", ans);
}
};

Suffix_Automation sam;

int main()
{
int T;
scanf("%d", &T);
while(T--)
{
sam.initSAM();
scanf("%s", s);
int len = strlen(s);
for(int i = 0; i < len; i++)
sam.extend(s[i] - 'a');
sam.topo();
int Q;
scanf("%d", &Q);
while(Q--)
{
int l, r;
scanf("%d %d", &l, &r);
sam.solve(l - 1, r - 1);
}
}
return 0;
}

后缀自动机做法2 O(|S|*|S| + Q)：
Result  :  Accepted     Memory  :  15936 KB     Time  :  1357 ms

/*
* Author: Gatevin
* Created Time: 2015/4/16 18:46:12
* File Name: Rin_Tohsaka.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++e)
#define SHOW_MEMORY(x) cout<<sizeof(x)/(1024*1024.)<<"MB"<<endl

#define maxn 4444
#define maxm 2333
char s[maxm];

struct Suffix_Automation
{
struct State
{
State *par;
State *go[26];
int right, val, mi;
void init(int _val = 0)
{
par = 0, val = _val, right = mi = 0;
memset(go, 0, sizeof(go));
}
int calc()
{
if(par == 0) return 0;
else return val - par->val;
}
};
State *root, *cur, *last;
State nodePool[maxn];
int tot;
State* newState(int val = 0)
{
cur->init(val);
return cur++;
}
void initSAM()
{
cur = nodePool;
root = newState();
last = root;
tot = 0;
}
void extend(int w)
{
State *p = last;
State *np = newState(p->val + 1);
np->right = 1;
while(p && p->go[w] == 0)
{
p->go[w] = np;
p = p->par;
}
if(p == 0)
{
np->par = root;
tot += np->calc();
}
else
{
State *q = p->go[w];
if(q->val == p->val + 1)
{
np->par = q;
tot += np->calc();
}
else
{
State *nq = newState(p->val + 1);
memcpy(nq->go, q->go, sizeof(q->go));
tot -= q->calc();
nq->par = q->par;
q->par = nq;
np->par = nq;
tot += q->calc() + nq->calc() + np->calc();
while(p && p->go[w] == q)
{
p->go[w] = nq;
p = p->par;
}
}
}
last = np;
}
int d[maxm];
State *b[maxn];
void topo()
{
int maxVal = 0;
memset(d, 0, sizeof(d));
int cnt = cur - nodePool;
for(int i = 1; i < cnt; i++)
maxVal = max(maxVal, nodePool[i].val), d[nodePool[i].val]++;
for(int i = 1; i <= maxVal; i++) d[i] += d[i - 1];
for(int i = 1; i < cnt; i++) b[d[nodePool[i].val]--] = &nodePool[i];
b[0] = root;
}
void SAMInfo()
{
int cnt = cur - nodePool;
State *p;
for(int i = cnt - 1; i > 0; i--)
{
p->par->right += p->right;
p->mi = p->par->val + 1;
}
}
int ans[2010][2010];
void solve(char *s, int len)
{
for(int i = 0; i < len; i++)
{
initSAM();
for(int j = i; j < len; j++)
{
extend(s[j] - 'a');
ans[i][j] = tot;
}
}
int Q;
scanf("%d", &Q);
while(Q--)
{
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", ans[l - 1][r - 1]);
}
}
};

Suffix_Automation sam;

int main()
{
int T;
scanf("%d", &T);
while(T--)
{
scanf("%s", s);
int len = strlen(s);
sam.solve(s, len);
}
return 0;
}