poj1509 后缀自动机模板题

1. 
   
   
   
   ①给定字符串P，问P是否为T的子串。
   
   
   我们对于T建立后缀自动机。
   我们顺着后缀自动机找即可。
   
   
   
   
   
   
   ②给定一个字符串S，问他有多少个不同的子串。
   因为后缀自动机是一个有向无环图。
   我们用dp。
   dp[v]=1+dp[w];
   我们输出dp[0]-1。
   
   
   
   
   
   
   ③不同子串的总长度：
   ans[v]=d[w]+ans[w]
   
   
   
   
   
   
   
   
   ④给定字符串S，找到和它循环同构的字典序最小字符串
   将S+S构建后缀自动机，该自动机包含了和s同构短的所有字符串。
   我们找字典树最小的，长度为length（s）的路径。
   
   
   
   
   ⑤首次出现位置查询
   为了解决这一问题，我们需要预处理firstpos，找到自动机中所有状态的出现位置，即，对每个状态v我们希望找到一个位置firstpos[v]，代表
   其第一次出现的位置。换句话说，我们希望预先找出每个endpos(v)中的最小元素（我们无法明确记录整个endpos集合）。
     维护这些firstpos的最简单方法是在构建自动机时一并计算，当我们创建新的状态cur时，一旦进入函数sa_extend()，就确定该值：
    firstpos(cur)=len(cur)-1（如果我们的下标从0开始）。
   当拷贝节点q时，令：
    firstpos(clone)=firstpos(q)，（因为只有一个别的可能值——firstpos(cur)，显然更大）。
    这样就得到了查询的答案——firstpos(t)-length(P)+1，其中t是模式串P对应的状态。
   
   
   
   
   
   
   ⑥所有出现位置查询
   
2. 
   
3. 
   
4. 
   
5. 
   
6. 
   
7. 
   
8. 
   
9. 
   
10. #include<iostream>  
11. #include<cstdio>  
12. #include<string>  
13. #include<cstring>  
14. #include<vector>  
15. #include<cmath>  
16. #include<queue>  
17. #include<stack>  
18. #include<map>  
19. #include<set>  
20. #include<algorithm>  
21. using namespace std;  
22. const int maxn=10010;  
23. const int SIGMA_SIZE=26;  
24. struct SAM_Node  
25. {  
26.     SAM_Node *par,*next[SIGMA_SIZE];  
27.     int len;//从开始到当前位置的长度  
28.     int id;//状态节点编号  
29.     int pos;  
30.     SAM_Node(){}  
31.     SAM_Node(int ilen)  
32.     {  
33.         par=0;  
34.         len=ilen;  
35.         memset(next,0,sizeof(next));  
36.     }  
37. };  
38. SAM_Node node[maxn<<2],*root,*last;  
39. int SAM_size;  
40. SAM_Node *newSAM_Node(int len)  
41. {  
42.     node[SAM_size]=SAM_Node(len);  
43.     node[SAM_size].id=SAM_size;  
44.     return &node[SAM_size++];  
45. }  
46. SAM_Node *newSAM_Node(SAM_Node *p)  
47. {  
48.     node[SAM_size]=*p;  
49.     node[SAM_size].id=SAM_size;  
50.     return &node[SAM_size++];  
51. }  
52. void SAM_init()  
53. {  
54.     SAM_size=0;  
55.     root=last=newSAM_Node(0);  
56.     node[0].pos=0;  
57. }  
58. void SAM_add(int x,int len)  
59. {  
60.     SAM_Node *p=last,*np=newSAM_Node(p->len+1);  
61.     np->pos=len;  
62.     last=np;  
63.     while(p&&!p->next[x])  
64.     {  
65.         p->next[x]=np;  
66.         p=p->par;  
67.     }  
68.     if(!p)  
69.     {  
70.         np->par=root;  
71.         return;  
72.     }  
73.     SAM_Node *q=p->next[x];  
74.     if(q->len==p->len+1)  
75.     {  
76.         np->par=q;  
77.         return ;  
78.     }  
79.     SAM_Node *nq=newSAM_Node(q);  
80.     nq->len=p->len+1;  
81.     q->par=nq;  
82.     np->par=nq;  
83.     while(p&&p->next[x]==q)  
84.     {  
85.         p->next[x]=nq;  
86.         p=p->par;  
87.     }  
88. }  
89. void SAM_build(char *s)  
90. {  
91.     SAM_init();  
92.     int len=strlen(s);  
93.     for(int i=0;i<len;i++)  
94.         SAM_add(s[i]-'a',i+1);  
95. }  
96. int N;  
97. char s[maxn*2];  
98. int main()  
99. {  
100.     scanf("%d",&N);  
101.     while(N--)  
102.     {  
103.         scanf("%s",s);  
104.         int len=strlen(s);  
105.         for(int i=0;i<len;i++)  
106.             s[len+i]=s[i];  
107.         s[2*len]='\0';  
108.         SAM_build(s);  
109.         SAM_Node *p=root;  
110.         for(int i=0;i<len;i++)  
111.         {  
112.             for(int j=0;j<SIGMA_SIZE;j++)  
113.                 if(p->next[j])  
114.                 {  
115.                     p=p->next[j];  
116.                     break;  
117.                 }  
118.         }  
119.         printf("%d\n",p->len-len+1);  
120.     }  
121.     return 0;  
122. }