bzoj 2434 ac自动机

ac自动机中，如果以trie中的节点为节点，(fail[i],i)为边，可以建立一颗树，该树有如下特点：“节点u是节点v的祖先 当且仅当 u代表的字符串是v代表的字符串的一个后缀”。（u代表的字符串是由根节点到u路径上所有的边代表的字符顺次组合成的，我们记作str(u)）。

本题中的每一个P都对应trie中的一个节点，所以本题就是求str(b)中有多少个str(a)子串：

如果len(str(b))<len(str(a))，则为0

如果len(str(b))==len(str(a))，则判断a和b是否是同一个字符串。

如果len(str(b))<len(str(a))，则str(a)一定是str(b)一个前缀的后缀，str(b)的前缀就是根到b路径上所有点代表的字符串，而如果str(a)是str(b)的一个后缀，则在fail树中，b一定在a的子树中。

 /**************************************************************
     Problem: 2434
     User: idy002
     Language: C++
     Result: Accepted
     Time:580 ms
     Memory:18912 kb
 ****************************************************************/

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #define maxn 100010
 #define fprintf(...)
 using namespace std;

 struct Query {
     int a, id;
     Query( int a, int id ):a(a),id(id){}
 };

 int n, m, ans[maxn];
 char str[maxn];
 int son[maxn][], pre[maxn], fail[maxn], ppos[maxn], ntot;
 int ww[maxn], dl[maxn], dr[maxn], dfs_clock;
 vector<int> g[maxn];
 vector<Query> qry[maxn];

 void modify( int pos, int delta ) {
     for( int i=pos; i<=n; i+=i&-i )
         ww[i] += delta;
 }
 int query( int pos ) {
     int rt=;
     for( int i=pos; i; i-=i&-i )
         rt += ww[i];
     return rt;
 }
 void build_trie( int n, const char *P ) {
     int u = ;
     int pid_clock=;
     for( int i=; i<n; i++ ) {
         if( P[i]=='P' ) {
             pid_clock++;
             ppos[pid_clock] = u;
             fprintf( stderr, "the No.%d P is at node %d\n", pid_clock, u );
         } else if( P[i]=='B' ) {
             u = pre[u];
             fprintf( stderr, "up to %d\n", u );
         } else {
             int c=P[i]-'a';
             if( !son[u][c] ) {
                 ntot++;
                 son[u][c] = ntot;
                 pre[ntot] = u;
             }
             fprintf( stderr, "%d->%d with %c\n", u, son[u][c], c+'a' );
             u = son[u][c];
         }
     }
 }
 void build_fail() {
     queue<int> qu;
     for( int c=; c<; c++ ) {
         int v=son[][c];
         if( !v ) continue;
         fail[v] = ;
         fprintf( stderr, "fail[%d] = %d\n", v, fail[v] );
         g[].push_back(v);
         qu.push( v );
     }
     while( !qu.empty() ) {
         int u=qu.front();
         qu.pop();
         for( int c=; c<; c++ ) {
             int v=son[u][c];
             int w=fail[u];
             if( !v ) continue;
             while( w && !son[w][c] ) w=fail[w];
             fail[v] = son[w][c];
             fprintf( stderr, "fail[%d] = %d\n", v, fail[v] );
             g[son[w][c]].push_back( v );
             qu.push( v );
         }
     }
 }
 void dfs( int u ) {
     dl[u] = ++dfs_clock;
     fprintf( stderr, "(%d ", u );
     for( int t=; t<g[u].size(); t++ )
         dfs( g[u][t] );
     dr[u] = dfs_clock;
     fprintf( stderr, ")" );
 }
 void solve( int n, const char *P ) {
     int u=;
     for( int i=; i<n; i++ ) {
         if( P[i]=='P' ) {
             for( int t=; t<qry[u].size(); t++ ) {
                 Query &q = qry[u][t];
                 if( q.a==u ) ans[q.id]=;
                 else ans[q.id] = query(dr[q.a])-query(dl[q.a]-);
             }
         } else if( P[i]=='B' ) {
             if( u== ) continue;
             modify( dl[u], - );
             u = pre[u];
         } else {
             int c=P[i]-'a';
             u = son[u][c];
             modify( dl[u], + );
         }
     }
 }
 int main() {
     scanf( "%s", str );
     n = strlen(str);
     build_trie(n,str);
     build_fail();
     dfs();
     fprintf( stderr, "\n" );
     scanf( "%d", &m );
     for( int i=,a,b; i<=m; i++ ) {
         scanf( "%d%d", &a, &b );
         a = ppos[a];
         b = ppos[b];
         qry[b].push_back( Query(a,i) );
     }
     solve(n,str);
     for( int i=; i<=m; i++ )
         printf( "%d\n", ans[i] );
 }
     

收获：

1、“a是b的子串 当且仅当 a是b的后缀的前缀或前缀的后缀“ 所以统计时就可以根据这个分类判断。

2、 fail指针对应的树的含义：同一条链上，深度小的字符串是深度大的字符串的后缀。