HDU 4622 Reincarnation（后缀自动机）

HDU 4622 Reincarnation（后缀自动机）

题目链接：

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

题意：

​ 给定一个字符串S，长度为N（1<=N<=2000)，给定Q个询问，每次询问给定一个区间ql,qr，求出一个该区间对应的字符串中不同子串的个数

思路：

​ 首先先考虑求整个字符串的不同子串的个数，考虑用后缀自动机，对于每个节点我们知道它对应着一系列子串，这些子串在整个字符串中出现的次数都相同，位置（以最后一个字母标识）也相同，它们的长度是在min[q],到max[q]之间，所以对于这个节点来说他对应了max[q]-min[q]+1个不同的子串，并且我们可以知道后缀自动机中每个子串对应的节点都不同，所以子串的个数就是所有的节点对应的子串个数之和

​ 现在考虑不同询问怎么办，我们之前的算法是没有决定不同子串的右边界的位置，但是其实这是可以维护出来的，因为每个节点对应的子串的右边界都是相同的，所以我们是可以知道不同右边界的子串有多少个，那么我们现在考虑一个预处理的做法，把所有的答案个预处理出来，我们枚举每一个后缀，那么就可以知道左边界大于后缀起点，右边界在起点,…N的答案了，然后对于一个询问ql,qr来说它要求的就是右边界小于等于qr的答案了，所以再进行完后缀自动机之后，再对前缀球和就可以了

代码:

      #define debug printf
      #include<cstdio>
      #include<cstring>
      #include<algorithm>
      #include<iostream>
      #include<map>
      #include<string>
      using namespace std;
      const int CHAR=26;
      const int MAXN=2000+5;
      int idx[256];
      void init()
      {
          for(int i=0;i<26;i++){
              idx['a'+i]=i;
          }
      }
      struct SAM_Node{
        SAM_Node * fa,* next[CHAR];
        int len;
        int id,pos;
        SAM_Node(){}
        SAM_Node(int _len)
        {
            fa=0;
            len=_len;
            memset(next,0,sizeof(next));
        }
      };

      SAM_Node SAM_node[MAXN<<1],*SAM_root,*SAM_last;
      int SAM_size;
      SAM_Node * newSAM_Node(int len)
      {
        SAM_node[SAM_size]=SAM_Node(len);
        SAM_node[SAM_size].id=SAM_size;
        return &SAM_node[SAM_size++];
      }
      SAM_Node * newSAM_Node(SAM_Node * p)
      {
        SAM_node[SAM_size]=*p;
        SAM_node[SAM_size].id=SAM_size;
        return &SAM_node[SAM_size++];
      }

      void SAM_init()
      {
        SAM_size=0;
        SAM_root=SAM_last=newSAM_Node(0);
        SAM_node[0].pos=0;
      }

      void SAM_add(int x,int len)
      {
        SAM_Node * p=SAM_last,*np=newSAM_Node(p->len+1);
        np->pos=len;
        SAM_last=np;
        for(;p&&!p->next[x];p=p->fa){
            p->next[x]=np;
        }
        if(!p){
            np->fa=SAM_root;
            return;
        }
        SAM_Node * q=p->next[x];
        if(q->len==p->len+1){
            np->fa=q;
            return;
        }
        SAM_Node * nq=newSAM_Node(q);
        nq->len=p->len+1;
        q->fa=nq;
        np->fa=nq;
        for(;p&&p->next[x]==q;p=p->fa){
            p->next[x]=nq;
        }
      }

      void SAM_build(char * s)
      {
        SAM_init();
        int len=strlen(s);
        for(int i=0;i<len;i++){
            SAM_add(s[i]-'a',i+1);
        }
      }

      int T;
      char str[MAXN];
      int qry[MAXN][MAXN];
      int Q,ql,qr;
      void solve()
      {
        scanf("%s",str+1);
        int len=strlen(str+1);
        memset(qry,0,sizeof(qry));
        for(int i=1;i<=len;i++){
            SAM_init();
            for(int j=i;j<=len;j++){
                SAM_add(idx[str[j]],j);
            }
            for(int j=1;j<SAM_size;j++){
                qry[i][SAM_node[j].pos]+=SAM_node[j].len-SAM_node[j].fa->len;
            }
            for(int j=i+1;j<=len;j++){
                qry[i][j]+=qry[i][j-1];
            }
        }
        scanf("%d",&Q);
        for(int i=1;i<=Q;i++){
            scanf("%d %d",&ql,&qr);
            printf("%d\n",qry[ql][qr]);
        }
      }

      int main()
      {
          init();
        scanf("%d",&T);
        while(T--){
            solve();
        }

      }
      ```