一坨字符串难题

CodeForces 204E Little Elephant and Strings

http://codeforces.com/contest/204/problem/E

输入n个字符串，由小写字母组成。

对于每一个字符串，求出这个字符串，有多少个区间[L,R]，使得子串L..R在至少K个字符串中出现，包括它本身。

SAM竟有如此美妙的构造方法。

首先用一个Trie来构造SAM。然后考虑par树，我们要求的是每个结点所代表的子串，包含了多少个字符串。

如果沿着Trie上的结点对应的SAM结点来访问SAM的话，可以发现对于每个结点它以及它沿着par树上的结点都在Trie上出现过一次，将这个结点的访问次数加一，那么对par树用一遍dfs使cnt[u]+=cnt[v]似乎就可以求出所有结点的访问次数了。但是这样会有一个重复计数，两个结点的公共祖先以上的结点重复计数过了，因此把它们的公共结点访问次数减一就对了。用Tarjan做一遍离线的LCA可以解决，记录Trie对应的每个串所包含的点的当前的公共祖先，如果有一个新的结点出现，就处理旧的公共祖先与当前点的公共祖先。

最后保留下所有出现次数>=k的结点。统计这个结点的len[u]-len[par[u]]即包含的子串数。我们通过Trie知道了某个结点是否是某个串的前缀，那么这个结点的后缀也应该在这个串上，统计par树上的父结点到当前结点的cnt，累加到该串的答案中。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>

using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef vector<int>::iterator Iter;
const int maxn=210000;
const int MAXS=26;
char buf[maxn];
LL ans[maxn];
int TtoM[maxn],MtoT[maxn];
int n,K;
int cnt[maxn];
namespace Trie{
    int trans[maxn][26];
    VI spb[maxn];
    int tot;
    int NewNode(){return tot++;}
    void Insert(char s[],int id){
        int u=0;
        for (int i=0;s[i];i++){
            int c=s[i]-'a';
            if (!trans[u][c]) trans[u][c]=NewNode();
            u=trans[u][c];
            spb[u].push_back(id);
        }
    }
    void Init(){
        tot=0;
        NewNode();
    }
}

namespace SAM{
    int trans[maxn][26],par[maxn],len[maxn],tot;
    VI adj[maxn];
    inline int NewNode(){
        memset(trans[tot],0,sizeof(trans[tot]));
        return tot++;
    }
    inline int NewNode(int u){
        memcpy(trans[tot],trans[u],sizeof(trans[u]));
        par[tot]=par[u];
        return tot++;
    }
    inline int h(int u){
        return len[u]-len[par[u]];
    }
    int Extend(int last,int w){
        int p=last,np=NewNode();
        len[np]=len[p]+1;
        while (p&&!trans[p][w]){
            trans[p][w]=np;
            p=par[p];
        }
        if (!p&&!trans[p][w]) {
            trans[p][w]=np;
            par[np]=0;
        }
        else{
            int q=trans[p][w];
            if (len[p]+1==len[q]) par[np]=q;
            else{
                int nq=NewNode(q);
                len[nq]=len[p]+1;
                par[q]=par[np]=nq;
                while (p&&trans[p][w]==q){
                    trans[p][w]=nq;
                    p=par[p];
                }
                if (!p&&trans[p][w]==q) trans[p][w]=nq;
            }
        }
        return np;
    }
    void Gao(){
        tot=0;
        queue<int>que;
        que.push(0);
        TtoM[0]=NewNode();
        while (que.size()){
            int u=que.front();
            que.pop();
            for (int w=0;w<26;w++){
                int v=Trie::trans[u][w];
                if (v){
                    TtoM[v]=Extend(TtoM[u],w);
                    MtoT[TtoM[v]]=v;
                    que.push(v);
                }
            }
        }
        for (int i=1;i<tot;i++) adj[par[i]].push_back(i);
    }
    void Check(){
        for (int u=1;u<tot;u++){
            cnt[u]=cnt[u]>=K?h(u):0;
        }
    }
}

namespace Tarjan{
    int pa[maxn],r[maxn],a[maxn],l[maxn];
    void Make(int x){
        r[x] = 0;
        pa[x] = x;
        a[x] = x;
    }
    int Find(int x){
        if (x!=pa[x]) pa[x]=Find(pa[x]);
        return pa[x];
    }
    void Union(int _x, int _y){
        int x=Find(_x);
        int y=Find(_y);
        if (r[x]<r[y]) pa[y]=x;
        else{
            pa[x]=y;
            a[y]=_x;
            if (r[x]==r[y]) r[x]++;
        }
    }
    void Tarjan(int u=0){
        Make(u);
        for (Iter it=SAM::adj[u].begin();it!=SAM::adj[u].end();it++){
            Tarjan(*it);
            Union(u,*it);
        }
        if (MtoT[u]){
            for (Iter it=Trie::spb[MtoT[u]].begin();it!=Trie::spb[MtoT[u]].end();it++){
                int v=*it;
                --cnt[a[Find(l[v])]];
                ++cnt[u];
                l[v]=u;

            }
        }
    }
    void dfs1(int u=0){
        int sz=SAM::adj[u].size();
        for (int i=0;i<sz;i++){
            int v=SAM::adj[u][i];
            dfs1(v);
            cnt[u]+=cnt[v];
        }
    }
    void dfs2(int u=0){
        int sz=SAM::adj[u].size();
        for (int i=0;i<sz;i++){
            int v=SAM::adj[u][i];
            cnt[v]+=cnt[u];
            dfs2(v);
        }
        sz=Trie::spb[MtoT[u]].size();
        for (int i=0;i<sz;i++){
            int v=Trie::spb[MtoT[u]][i];
            ans[v]+=cnt[u];
        }
    }
    void Init(){
        memset(l,0,sizeof(l));
    }
}
int main()
{
    scanf("%d%d",&n,&K);
    Trie::Init();
    for (int i=0;i<n;i++){
        scanf("%s",buf);
        Trie::Insert(buf,i);
    }
    SAM::Gao();
    Tarjan::Init();
    Tarjan::Tarjan();
    Tarjan::dfs1();
    SAM::Check();
    Tarjan::dfs2();
    for (int i=0;i<n;i++) printf("%I64d ",ans[i]);puts("");
    return 0;
}

CodeForces 452E Three strings 

http://codeforces.com/contest/452/problem/E

有三个字符串s1、s2、s3，对于每一个l(1<=l<=min(|s1|,|s2|,|s3|))，问存在多少对(i1,i2,i3)，使s_k[i_k... i_k + l - 1](k = 1, 2, 3)相等，结果对10⁹ + 7取模。

将三个串用特殊符号隔开拼接在一起，关键点在于求出结点在三个串上的right集合。

可以从根结点进行一个Dp来求出三个right集合。

而有了right集合后，对于一个结点u代表的子串来说，它对于len[u]存在right[0]*right[1]*right[2]个三元对，使子串相等。

注意如过一个状态表示的串出现了T次，那么该串的后缀也至少出现了T次，为了统计方便将num[len[par[u]]]减去num[len[u]]，最后将num[i+1]累加到num[i]上即可。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
const int MOD=1e9+7;
const int maxn=611111;
typedef long long LL;
LL num[maxn];
namespace SAM{
    int trans[maxn][30],par[maxn],len[maxn],tot,last;
    LL cnt[maxn][3];
    inline int NewNode(){
        memset(trans[tot],0,sizeof(trans[tot]));
        return tot++;
    }
    inline int NewNode(int u){
        memcpy(trans[tot],trans[u],sizeof(trans[u]));
        par[tot]=par[u];
        return tot++;
    }
    inline int h(int u){
        return len[u]-len[par[u]];
    }
    void Extend(int w){
        int p=last,np=NewNode();
        len[np]=len[p]+1;
        while (p&&!trans[p][w]){
            trans[p][w]=np;
            p=par[p];
        }
        if (!p&&!trans[p][w]) {
            trans[p][w]=np;
            par[np]=0;
        }
        else{
            int q=trans[p][w];
            if (len[p]+1==len[q]) par[np]=q;
            else{
                int nq=NewNode(q);
                len[nq]=len[p]+1;
                par[q]=par[np]=nq;
                while (p&&trans[p][w]==q){
                    trans[p][w]=nq;
                    p=par[p];
                }
                if (!p&&trans[p][w]==q) trans[p][w]=nq;
            }
        }
        last=np;
    }
    bool vis[maxn];
    void Dp(int u){
        if (vis[u]) return;
        vis[u]=true;
        for (int k=0;k<3;k++){
            if (trans[u][26+k]) cnt[u][k]=1;
        }
        for (int i=0;i<26;i++){
            int v=trans[u][i];
            if (v){
                Dp(v);
                for (int k=0;k<3;k++){
                    cnt[u][k]=(cnt[u][k]+cnt[v][k])%MOD;
                }
            }
        }
    }
    void Gao(){
        for (int i=1;i<tot;i++){
            LL tmp=((cnt[i][0]*cnt[i][1])%MOD*cnt[i][2])%MOD;
            num[len[i]]=(num[len[i]]+tmp)%MOD;
            num[len[par[i]]]=(num[len[par[i]]]-tmp+MOD)%MOD;
        }
        for (int i=tot-2;i>=1;i--){
            num[i]=(num[i]+num[i+1])%MOD;
        }
    }
    void Init(){
        memset(vis,0,sizeof(vis));
        memset(cnt,0,sizeof(cnt));
        tot=0;
        NewNode();
    }
    void Debug(int tp=0){
        if (tp==0)
        for (int i=0;i<tot;i++){
            printf("i=%d,par=%d,len=%d
",i,par[i],len[i]);
            for (int j=0;j<30;j++){
                if (trans[i][j]){
                    printf("to %d %c
",trans[i][j],(char)(j+'a'));
                }
            }
        }
        if (tp==1)
        for (int i=0;i<tot;i++){
            printf("i=%d %I64d %I64d %I64d
",i,cnt[i][0],cnt[i][1],cnt[i][2]);
        }
    }
}
const int INF=0x3f3f3f3f;
char s[maxn];
int main()
{
    SAM::Init();
    int n=INF;
    scanf("%s",s);
    n=min(n,(int)strlen(s));
    for (int i=0;s[i];i++) SAM::Extend(s[i]-'a');
    SAM::Extend(26);
    scanf("%s",s);
    n=min(n,(int)strlen(s));
    for (int i=0;s[i];i++) SAM::Extend(s[i]-'a');
    SAM::Extend(27);
    scanf("%s",s);
    n=min(n,(int)strlen(s));
    for (int i=0;s[i];i++) SAM::Extend(s[i]-'a');
    SAM::Extend(28);
    SAM::Dp(0);
    //SAM::Debug(0);
    //SAM::Debug(1);
    SAM::Gao();
    for (int i=1;i<=n;i++){
        if (i>1) printf(" ");
        printf("%I64d",num[i]);
    }
    puts("");
    return 0;
}

CodeForces 316G3 Good Substrings

http://codeforces.com/contest/316/problem/G3

统计一个字符串有多少个好的子串，好的子串是指，有n个规则(P,L,R)，其中P是一个字符串，L与R是一个整数，如果串T在串P中出现的次数在[L,R]区间就称T满足规则。而满足所有规则的子串称为好的子串。

HDU 4943 K-th good string

http://acm.hdu.edu.cn/showproblem.php?pid=4943

有一个字符串S，定义(x,p)为S[p-x+1,p-x+2,…,p]。

有三种类型的信息：

(x,p) 是好的，这里不包含(x,p)的子串。

(x,p) 是不好的。

(x,p)和整数k，回答第k个好串的长度。

ACdream 1117 Suffix Automation

http://acdream.info/problem?pid=1117

给你一个字符串集合（包含若干个字符串），最多10w次询问。

每次询问 i 串的a后缀跟 j 串的 b 后缀的最长的"特殊"公共前缀，这个公共前缀需要在字符串集合中出现。