hdu4641 K-string，后缀自动机，并查集

做完这题还是有点小高兴的。。
网上题解都是O(n^2)水的。
简单介绍一下我想滴比标程还短还快的O(n+T(并查集))的做法。

如果你已经很了解后缀自动机，请跳过这段：
//--------------------------------------------------
首先，我们要知道后缀自动机能够建立一个父指针树。(以fa指针为边的树)
然后呢，这个神奇的树有这样的性质：
1.对于每个节点，父节点的接受串是该节点的接受串的后缀，而且是最长的那个。
所以呢，用该节点的len减去父节点的fa.len，就是该节点表示的串中父节点不能表示的串个数。
当某节点的计数到达k次时，就说明有len-fa.len个不同子串计数到达k次了。
（同理，当插入这个节点，出现的新不同子串个数就是len-fa.len。这也是很有用的性质。）

2.每个节点表示串出现的次数，是这个节点子树上有效节点的总数。
（有效节点指插入该字符产生的那个节点，也就是代码中extend中的np节点）。
这样我们初始化有效节点为1，然后拓扑排序dp，就可以O(n)得到每个节点出现次数。
//-------------------------------------------------

然后进入正题。题意是，给一个原始串，一个尾端插入一个字符的操作，和一个询问，问当前串多少不同子串。

先想想朴素的搞法是怎样。
尾端插入，这个是后缀自动机的特色操作。没啥好说的。
询问不同子串。每当插入一个字符，需要将父指针树上所有的节点出现次数+1。这样最差复杂度将是树的高度。
不过这个题数据太水，很多人都这样搞过了。。。
但只要搞一个全是a的串和200000次插入a的操作的样例，很容易让那些程序挂掉。


怎么办呢。这里发现一个单调性，当一个串出现的次数大于k次时，那么他的父节点出现次数必然大于等于k。
我们每次都只需要找到父链中那个出现次数等于k的节点。

不过这样不好操作。反过来想，我们先把所有串都插进去，然后一个个字符删除，找链上那个次数大于等于k的节点。
因为小于k的节点已经没用，用一个并查集进行路径压缩。这样，删除字符的平摊复杂度就是O(n+T(并查集))。
每次一个节点出现次数变为小于k，就要减去len-fa.len个不同的串。
离线搞一下就好了。

似乎算法复杂度压制了，暂时排名rank1哟。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define Maxn 250009

int root,last;
int tots;
int l;

int sv[Maxn*2];
struct query{int a;long long ans;}qu[Maxn];

struct sam_node{
    int fa,son[26];
    int len;
    void init(int _len){len=_len;fa=-1;memset(son,-1,sizeof(son));}
}t[Maxn*2];

void sam_init(){
    tots=0;
    root=last=0;
    t[tots].init(0);
}

void extend(int w){
    int p=last;
    int np=++tots;t[tots].init(t[p].len+1);
    sv[l]=np;
    int q,nq;
    while(p!=-1&&t[p].son[w]==-1){t[p].son[w]=np;p=t[p].fa;}
    if (p==-1) t[np].fa=root;
    else{
        q=t[p].son[w];
        if (t[p].len+1==t[q].len){t[np].fa=q;}
        else{
            nq=++tots;t[nq].init(0);
            t[nq]=t[q];
            t[nq].len=t[p].len+1;
            t[q].fa=nq;t[np].fa=nq;
            while(p!=-1&&t[p].son[w]==q){t[p].son[w]=nq;p=t[p].fa;}
        }
    }
    last=np;
}

int w[Maxn],r[Maxn*2];

void topsort(){
    int i;
    for(i=0;i<=l;++i)   w[i]=0;
    for(i=1;i<=tots;++i)w[t[i].len]++;
    for(i=1;i<=l;++i)   w[i]+=w[i-1];
    for(i=tots;i>=1;--i)r[w[t[i].len]--]=i;
    r[0]=0;
}

int dp[Maxn*2];
int sub[Maxn*2];
char s[Maxn];
int set[Maxn*2];
int findset(int x){
    int y;
    while(x!=set[x]){
        y=set[x];
        set[x]=set[y];
        x=y;
    }
    return x;
}

int main(){
    int n,m,k,f,y,p,i,a;
    long long ans;
    while(scanf("%d%d%d",&n,&m,&k)!=EOF){
        scanf("%s",s);
        int tl=strlen(s);
        l=0;
        sam_init();
        for(i=0;i<tl;++i){
            ++l;
            extend(s[i]-'a');
        }
       
        char ts[20];

        for(i=1;i<=m;++i){
            scanf("%d",&a);
            if (a==1){
                scanf("%s",ts);
                s[l++]=ts[0];
                qu[i].a=a;
                extend(ts[0]-'a');
            }
            else if (a==2) qu[i].a=a;
        }
        for(i=0;i<=tots;++i){dp[i]=0;}
        topsort();
        p=root;
        for(i=0;i<l;++i){
            p=t[p].son[s[i]-'a'];
            dp[p]++;
        }
        for(i=tots;i>=1;--i){
            p=r[i];
            if (t[p].fa!=-1) dp[t[p].fa]+=dp[p];
        }
        ans=0;
        for(i=1;i<=tots;++i)
            if (dp[i]>=k) ans+=t[i].len-t[t[i].fa].len;

        for(i=0;i<=tots;++i){set[i]=i;sub[i]=0;}

        for(i=m;i>=1;--i){
            if (qu[i].a==2) qu[i].ans=ans;
            else{
                p=sv[l];
                l--;
                y=findset(p);
                while(y!=0&&dp[y]<k){            //find first>=k
                    f=t[y].fa;
                    set[y]=f=findset(f);
                    y=f;
                }
                y=findset(p);
                if (y==root) {continue;}
                sub[y]++;
                while(y!=0&&(dp[y]-sub[y]<k)){   //after -1,find first >=k
                    ans=ans-t[y].len+t[t[y].fa].len;
                    f=t[y].fa;
                    f=findset(f);
                    sub[f]+=sub[y];
                    set[y]=f;
                    y=f;
                }
            }
        }
        for(i=1;i<=m;++i)if (qu[i].a==2){
            printf("%I64d\n",qu[i].ans);
        }
    }
    return 0;
}