bzoj 3473 后缀自动机多字符串的子串处理方法

 

后缀自动机处理多字符串字串相关问题。

首先，和后缀数组一样，用分割符连接各字符串，然后建一个后缀自动机。

我们定义一个节点代表的字符串为它原本代表的所有串去除包含分割符后的串。每个节点代表的字符串的数量可以用DP来计算（不能用right集合来算了）。

对于原来n个串中的一个串，其所有前缀可以通过将该串放到自动机上跑来获得，对于某个前缀，其所有后缀包括在该前缀本身的节点以及parent树的祖先节点中。这样我们就获得访问某个串所有子串的技能了。

 

对于这道题，我们可以先建出后缀自动机，然后对于n个串中的每个串，找到包含其子串的所有节点（可以保证所有子串一定且唯一出现在某个节点中）。然后将它们的计数器+1。弄完后，对于每个节点，我们就可以知道其代表的串是n个串中多少个串的子串。

最后再对于每个串，找出所有字串（不同位置要区分），统计答案。

 

如果不同位置不区分，那么我们得到的节点不能重复。如果要区分，对于每个前缀，其parent树上的节点都要计算，即使以前被计算过（因为他们的结束位置不同，所以肯定要计算）。

/**************************************************************
    Problem: 3473
    User: idy002
    Language: C++
    Result: Accepted
    Time:728 ms
    Memory:120928 kb
****************************************************************/
 
#include <cstdio>
#include <cstring>
#include <cassert>
#include <algorithm>
#define N 200010
#define S 500010
#define P 18
using namespace std;
 
typedef long long dnt;
 
int n, k;
char buf[N], *shead[N];
int son[S][27], pnt[S], val[S], ntot, last;
int head[S], dest[S], next[S], etot;
int dfn[S], dep[S], anc[S][P+1], idgr[S], stk[S], qu[S], top, bg, ed, idc;
dnt dp[S], eff[S];
int log[S];
 
void init() {
    ntot = last = 0;
    pnt[0] = -1;
}
void append( int c ) {
    int p = last;
    int np = ++ntot;
    val[np] = val[p]+1;
    while( p!=-1 && !son[p][c] ) 
        son[p][c]=np, p=pnt[p];
    if( p==-1 ) {
        pnt[np] = 0;
    } else {
        int q=son[p][c];
        if( val[q]==val[p]+1 ) {
            pnt[np] = q;
        } else {
            int nq = ++ntot;
            memcpy( son[nq], son[q], sizeof(son[nq]) );
            val[nq] = val[p]+1;
            pnt[nq] = pnt[q];
            pnt[q] = pnt[np] = nq;
            while( p!=-1 && son[p][c]==q ) 
                son[p][c]=nq, p=pnt[p];
        }
    }
    last = np;
}
void make_topo() {
    for( int u=0; u<=ntot; u++ ) {
        for( int c=0; c<=26; c++ ) {
            int v=son[u][c];
            if( !v ) continue;
            idgr[v]++;
        }
    }
    qu[bg=ed=1] = 0;
    while( bg<=ed ) {
        int u=qu[bg++];
        for( int c=0; c<=26; c++ ) {
            int v=son[u][c];
            if( !v ) continue;
            idgr[v]--;
            if( idgr[v]==0 ) 
                qu[++ed] = v;
        }
    }
}
void dodp() {
    make_topo();
    dp[0] = 1;
    for( int i=1; i<=ed; i++ ) {
        int u=qu[i];
        for( int c=1; c<=26; c++ ) {
            int v=son[u][c];
            if( !v ) continue;
            dp[v] += dp[u];
        }
    }
}
void adde( int u, int v ) {
    etot++;
    dest[etot] = v;
    next[etot] = head[u];
    head[u] = etot;
}
void build() {
    for( int u=1; u<=ntot; u++ ) 
        adde( pnt[u], u );
}
void dfs( int u ) {
    dfn[u] = ++idc;
    for( int p=1; p<=P && anc[u][p-1]; p++ )
        anc[u][p] = anc[anc[u][p-1]][p-1];
    for( int t=head[u]; t; t=next[t] ) {
        int v=dest[t];
        dep[v] = dep[u]+1;
        anc[v][0] = u;
        dfs(v);
    }
}
int lca( int u, int v ) {
    if( dep[u]<dep[v] ) swap(u,v);
    int t=dep[u]-dep[v];
    for( int p=0; t; p++,t>>=1 )
        if( t&1 ) u=anc[u][p];
    if( u==v ) return u;
    for( int p=log[dep[u]]; anc[u][0]!=anc[v][0]; p-- )
        if( anc[u][p]!=anc[v][p] ) u=anc[u][p],v=anc[v][p];
    return anc[u][0];
}
void fetch( char *s ) {
    top = 0;
    int u = 0;
    for( int i=0; s[i]; i++ ) {
        int c=s[i]-'a'+1;
        u = son[u][c];
        assert(u!=0);
        stk[++top] = u;
    }
}
bool cmp( int u, int v ) {
    return dfn[u]<dfn[v];
}
void effort( char *s ) {
    fetch(s);
    sort( stk+1, stk+1+top, cmp );
    eff[stk[1]] += 1;
    for( int i=2; i<=top; i++ ) {
        int u=stk[i];
        int ca=lca(u,stk[i-1]);
        eff[u] += 1;
        eff[ca] -= 1;
    }
}
void bfs() {
    qu[bg=ed=1] = 0;
    while( bg<=ed ) {
        int u=qu[bg++];
        for( int t=head[u]; t; t=next[t] ) {
            int v=dest[t];
            qu[++ed] = v;
        }
    }
    for( int i=ed; i>=1; i-- ) {
        int u=qu[i];
        for( int t=head[u]; t; t=next[t] ) {
            int v=dest[t];
            eff[u] += eff[v];
        }
    }
    dp[0] = 0;
    for( int i=2; i<=ed; i++ ) {
        int u=qu[i];
        if( eff[u]>=k ) {
            dp[u] = dp[pnt[u]]+dp[u];
        } else {
            dp[u] = dp[pnt[u]];
        }
    }
}
void query( char *s ) {
    fetch(s);
    sort( stk+1, stk+1+top, cmp );
    dnt rt = 0;
    for( int i=1; i<=top; i++ ) {
        int u=stk[i];
        rt += dp[u];
    }
    printf( "%lld ", rt );
}
int main() {
    //  input and build sam
    scanf( "%d%d", &n, &k );
    init();
    char *buf_cur = buf;
    for( int i=1; i<=n; i++ ) {
        shead[i] = buf_cur;
        scanf( "%s", shead[i] );
        for( int j=0; shead[i][j]; j++ )
            append( shead[i][j]-'a'+1 );
        append( 0 );
        buf_cur += strlen(shead[i]) + 1;
    }
    log[0] = -1;
    for( int i=1; i<=ntot; i++ ) log[i] = log[i>>1]+1;
    //  dodp to calc the number of real substring
    dodp();
    //  build parent tree and its dfs order
    build();
    dfs(0);
    //  calc echo string's effort
    for( int i=1; i<=n; i++ )
        effort( shead[i] );
    //  bfs to calc the sum of subans
    bfs();
    //  query the answer of eacho string
    for( int i=1; i<=n; i++ )
        query( shead[i] );
    printf( "\n" );
}