hdu 5343 MZL's Circle Zhou SAM

MZL's Circle Zhou

题意：给定两个长度不超过a,b（1 <= |a|,|b| <= 90000）,x为a的连续子串,b为y的连续子串（x和y均可以是空串）；问x+y形成的不同串的个数？

误区：开始一门心思想着求出总的可形成的字符串个数，再减去a,b中相同的子串重叠的部分；想通过连续插入a+b得到的SAM并不能获得信息；因为x，y是任意的子串，连续插入导致一定是a的后缀和b的前缀

正解：直接在计算有不同子串时，就不去计算重复的 <=>对于一个可能出现x后缀和y前缀相同而重复计算的情况，就全部加入x而y变为去掉前缀的部分；

即找到x最后一个字符ch，使得在x后能加的字符串不以ch开头，这样就避免了重复的情况；（思想很好啊！！！）

对SAM的理解：

SAM将字符串插入之后，step[np] - step[pre[np]]表示 状态np比父节点pre[np]多出的以相同的点为后缀的不同子串的个数；

对SAM进行拓扑之后:

<1>如果按照字符串先遍历有效节点，初始化每个状态出现的次数为1，就可从孩子节点得到父节点的出现的次数；再使用step得到不同子串的数目即可求解一类与出现次数有关的问题；如 hdu 4641 K-string

<2>如果初始化root为1，递推出每个节点出现的次数 cnt[ g[p][v] ] += cnt[p]将得到的是从初始状态到当前状态的所有子串（当然是不同的）数；

本题：需要对a字符串构成的SAM的每一个状态（节点）找出g[u][j] == 0（即上面讲的x不可能有j这条状态转移边），这时如果y以j开头的不同子串的数量已知，那就可以直接往结果中贡献出 cnt[u] * C[j]的值（cnt[u]表示a字符串以x状态为后缀不同子串的个数，C[j]表示y中以j开头子串的数目）

cnt集合根据上面的性质2可以直接递推得到，那C集合呢？

其实就是在找到一个cnt[u]之后，如果u有一条j的转移边j,那么C[j]的值就增加了cnt[u]?

还有一个问题：SAM只能求得以某个点为后缀的，怎么得到从每个点开始的呢？

那就将b逆序插入。。（好思想啊）这样后缀就变成了后缀里面的前缀

对于b的各种情况已经计算完了，但是由于可以有空子串，a的不同子串还需加上；

坑：这道题数据很大，怀疑是% unsigned long long判的结果，使用long long  直接WA了

注：如果C集合写在SAM里面，在调用SA时运算的SA的C集合。。不是SB的

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 typedef unsigned long long ll;

 const int maxn = ;
 const int SIGMA_SIZE = ;

 struct SAM{
     int sz, last, pos[maxn<<];
     int g[maxn<<][SIGMA_SIZE], pre[maxn<<], step[maxn<<];
     ll cnt[maxn<<];

     void init(){
         sz = ;last = ;
         newNode();
     }

     void newNode(int s){
         pre[++sz] = ;
         step[sz] = s;
         memset(g[sz],,sizeof(g[sz]));
     }

     int idx(char ch){ return ch - 'a'; }

     void Insert(char ch);
     void topoSort();
     void preSolve(ll* C);
     ll solve(ll* C);

 }SA, SB;

 void SAM::Insert(char ch){
     newNode(step[last] + );
     int v = idx(ch), np = sz, p = last;
     while(p && !g[p][v]){
         g[p][v] = np;
         p = pre[p];
     }

     if(p){
         int q = g[p][v];
         if(step[q] == step[p] + )
             pre[np] = q;
         else{
             newNode(step[p] + );
             int nq = sz;
             for(int i = ;i < SIGMA_SIZE;i++)
                 g[nq][i] = g[q][i];

             pre[nq] = pre[q];
             pre[q] = pre[np] = nq;

             while(p && g[p][v] == q)
                 g[p][v] = nq, p = pre[p];
         }
     }
     else pre[np] = ;
     last = np;
 }

 void SAM::topoSort(){
     for(int i = ; i <= sz; i++) cnt[i] = ;
     for(int i = ; i <= sz; i++) cnt[step[i]]++;
     for(int i = ; i <= sz; i++) cnt[i] += cnt[i-];
     for(int i = ; i <= sz; i++) pos[cnt[step[i]]--] = i;
 }

 void SAM::preSolve(ll* C){
     topoSort();
     for(int i = ;i <= sz; i++) cnt[i] = ;
     cnt[] = ;

     for(int i = ;i <= sz; i++){　　//从root递推到每个节点出现的次数
         int u = pos[i];
         for(int j = ; j < SIGMA_SIZE; j++){
             int v = g[u][j];
             if(v == ) continue;
             C[j] += cnt[u];
             cnt[v] += cnt[u];
         }
     }
 }

 ll SAM::solve(ll *C){
     topoSort();
     for(int i = ; i <= sz; i++) cnt[i] = ;
     cnt[] = ;

     ll ret = ;
     for(int i = ; i <= sz; i++){
         int u = pos[i];
         for(int j = ; j < SIGMA_SIZE; j++){
             int v = g[u][j];
             if(v == ) ret += cnt[u] * C[j];
             else cnt[v] += cnt[u];
          }
          ret += cnt[u];　　　　// x + ""
     }
     return ret;
 }

 char str[maxn];
 int main()
 {
     int T;
     scanf("%d",&T);
     while(T--){
         scanf("%s", str);
         int n = strlen(str);
         SA.init();
         for(int i = ;i < n; i++)
             SA.Insert(str[i]);

         scanf("%s", str);
         n = strlen(str);
         SB.init();
         for(int i = n - ; i >= ; i--)　　　　// **
             SB.Insert(str[i]);

         ll C[SIGMA_SIZE];
         memset(C,,sizeof(C));
         SB.preSolve(C);

         printf("%llu\n",SA.solve(C));
     }
 }