UVA - 11107 Life Forms (广义后缀自动机+后缀树/后缀数组+尺取)

题意：给你n个字符串，求出在超过一半的字符串中出现的所有子串中最长的子串，按字典序输出。

这道题算是我的一个黑历史了吧，以前我的做法是对这n个字符串建广义后缀自动机，然后在自动机上dfs，交上去AC了，然而事后发现算法假了，出了个数据把自己给hack了...

之前写的太烂了，决定重写一遍。

正确的操作是对n个串倒序建广义后缀自动机，建好以后把每个串放到自动机上跑一遍，把所有覆盖到的状态结点打上标记（每个串只标记一次，用vis判重），记录每个状态在多少个串中出现过，然后在后缀树（fail树）上按字典序dfs一遍就好了。

注意每添加一个字符串，需要把last指向根节点，而且在每次往后添加结点的时候判断当前结点是否存在过，如果存在则需要特殊处理（源自洛谷zcysky大神的思路）

复杂度$O(n\sqrt n)$，但上界很松，跑起来速度还是很快滴~

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int N=2e5+,M=;
 int n,ka;
 char s[][];
 struct SAM {
     int fa[N],go[N][M],mxl[N],last,tot,ch[N][M],pos[N],cc[N],nc,vis[N],cnt[N],mx;
     int newnode(int l,int p) {
         int u=++tot;
         mxl[u]=l,pos[u]=p,cnt[u]=;
         memset(go[u],,sizeof go[u]);
         memset(ch[u],,sizeof ch[u]);
         return u;
     }
     void init() {tot=nc=,last=newnode(,-);}
     void add(int ch) {
         cc[++nc]=ch;
         int p=last;
         if(go[p][ch]) {
             int q=go[p][ch];
             if(mxl[q]==mxl[p]+)last=q;
             else {
                 int nq=newnode(mxl[p]+,pos[q]);
                 memcpy(go[nq],go[q],sizeof go[q]);
                 fa[nq]=fa[q],fa[q]=nq;
                 for(; p&&go[p][ch]==q; p=fa[p])go[p][ch]=nq;
                 last=nq;
             }
         } else {
             int np=last=newnode(mxl[p]+,nc);
             for(; p&&!go[p][ch]; p=fa[p])go[p][ch]=np;
             if(!p)fa[np]=;
             else {
                 int q=go[p][ch];
                 if(mxl[q]==mxl[p]+)fa[np]=q;
                 else {
                     int nq=newnode(mxl[p]+,pos[q]);
                     memcpy(go[nq],go[q],sizeof go[q]);
                     fa[nq]=fa[q],fa[q]=fa[np]=nq;
                     for(; p&&go[p][ch]==q; p=fa[p])go[p][ch]=nq;
                 }
             }
         }
     }
     void dfs(int u) {
         if(mxl[u]==mx&&cnt[u]>n/) {
             for(int i=pos[u]; i>pos[u]-mxl[u]; --i)printf("%c",cc[i]+'a');
             puts("");
         }
         for(int i=; i<M; ++i)if(ch[u][i])dfs(ch[u][i]);
     }
     void run() {
         for(int i=; i<n; ++i) {
             last=;
             int l=strlen(s[i]);
             reverse(s[i],s[i]+l);
             for(int j=; j<l; ++j)add(s[i][j]-'a');
         }
         memset(vis,-,sizeof vis);
         for(int i=; i<n; ++i)
             for(int j=,u=; s[i][j]; u=go[u][s[i][j]-'a'],++j)
                 for(int v=go[u][s[i][j]-'a']; v!=&&vis[v]!=i; v=fa[v])vis[v]=i,++cnt[v];
         mx=-;
         for(int i=; i<=tot; ++i)if(cnt[i]>n/)mx=max(mx,mxl[i]);
         for(int i=; i<=tot; ++i)ch[fa[i]][cc[pos[i]-mxl[fa[i]]]]=i;
         if(!~mx)puts("?");
         else {
             memset(vis,,sizeof vis);
             dfs();
         }
     }
 } sam;
 int main() {
     while(scanf("%d",&n),n) {
         ka?puts(""):++ka;
         sam.init();
         for(int i=; i<n; ++i)scanf("%s",s[i]);
         sam.run();
     }
     return ;
 }

还有一种做法是利用后缀数组。

把这n个串用不同的字符连接在一起求后缀数组，并给每个后缀i赋一个值a[i]表示它是哪个字符串里的。然后对排好序的后缀进行尺取并维护区间不同值的个数，一旦区间不同值的个数>n/2，就输出长度为左右端点lcp的字符串。（需要尺取两次，第一次求出最大长度，第二次输出）

但是这样做可能会有重复的串被输出，怎么去重呢？用哈希固然可以，可有没有优雅一点的做法呢？当然。只要每次输出的时候记录一下当前子串的左端点la，下次准备输出的时候和la求一次lcp，如果lcp=最大长度的话，就跳过。

复杂度$O(nlogn+n)$

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int N=1e5+,mod=;
 char buf[N];
 int s[N],sa[N],buf1[N],buf2[N],c[N],n,m,k,rnk[N],ht[N],ST[N][],Log[N],a[N],cnt,ka;
 void Sort(int* x,int* y,int m) {
     for(int i=; i<m; ++i)c[i]=;
     for(int i=; i<n; ++i)++c[x[i]];
     for(int i=; i<m; ++i)c[i]+=c[i-];
     for(int i=n-; i>=; --i)sa[--c[x[y[i]]]]=y[i];
 }
 void da(int* s,int n,int m=) {
     int *x=buf1,*y=buf2;
     x[n]=y[n]=-;
     for(int i=; i<n; ++i)x[i]=s[i],y[i]=i;
     Sort(x,y,m);
     for(int k=; k<n; k<<=) {
         int p=;
         for(int i=n-k; i<n; ++i)y[p++]=i;
         for(int i=; i<n; ++i)if(sa[i]>=k)y[p++]=sa[i]-k;
         Sort(x,y,m),p=,y[sa[]]=;
         for(int i=; i<n; ++i)y[sa[i]]=x[sa[i-]]==x[sa[i]]&&x[sa[i-]+k]==x[sa[i]+k]?p-:p++;
         if(p==n)break;
         swap(x,y),m=p;
     }
 }
 void getht() {
     for(int i=; i<n; ++i)rnk[sa[i]]=i;
     ht[]=;
     for(int i=,k=; i<n; ++i) {
         if(k)--k;
         if(!rnk[i])continue;
         for(; s[i+k]==s[sa[rnk[i]-]+k]; ++k);
         ht[rnk[i]]=k;
     }
 }
 void initST() {
     for(int i=; i<n; ++i)ST[i][]=ht[i];
     for(int j=; (<<j)<=n; ++j)
         for(int i=; i+(<<j)-<n; ++i)
             ST[i][j]=min(ST[i][j-],ST[i+(<<(j-))][j-]);
 }
 int lcp(int l,int r) {
     if(l==r)return n-sa[l];
     if(l>r)swap(l,r);
     l++;
     int k=Log[r-l+];
     return min(ST[l][k],ST[r-(<<k)+][k]);
 }
 void add(int x,int f) {
     if(!x)return;
     if(!c[x])++cnt;
     if(!(c[x]-=f))--cnt;
 }
 int main() {
     Log[]=-;
     for(int i=; i<N; ++i)Log[i]=Log[i>>]+;
     while(scanf("%d",&m),m) {
         if(ka++)puts("");
         memset(a,,sizeof a);
         n=;
         for(int i=; i<m; ++i) {
             if(i)s[n++]='z'+i;
             scanf("%s",buf),k=strlen(buf);
             for(int j=; j<k; ++j)a[n]=i+,s[n++]=buf[j];
         }
         s[n]=;
         da(s,n),getht(),initST();
         memset(c,,sizeof c);
         cnt=;
         int mx=;
         for(int i=,j=; i<n; ++i) {
             if(!a[sa[i]])break;
             for(; j<n&&cnt<=m/; ++j)add(a[sa[j]],);
             add(a[sa[i]],-);
             mx=max(mx,lcp(i,j-));
         }
         if(!mx)puts("?");
         else {
             for(int i=,j=,k,la=-; i<n; ++i) {
                 if(!a[sa[i]])break;
                 for(; j<n&&cnt<=m/; ++j)add(a[sa[j]],);
                 if(lcp(i,j-)==mx) {
                     if(!~la||lcp(la,j-)!=mx) {
                         for(k=; k<lcp(i,j-); ++k)printf("%c",s[sa[i]+k]);
                         puts("");
                     }
                     la=i;
                 }
                 add(a[sa[i]],-);
             }
         }
     }
     return ;
 }