算法模板——AC自动机

AC自动机

一种能让你AC的算法？
一种字符串匹配算法！
用来解决多字符串匹配问题的算法啦。
首先想一想KMP算法……（不知道KMP是什么？到时候我会写一篇专门的博客，敬请期待）
例如字符串aabaaaba与aba的匹配：

在第二个位置失配，这个时候模式串可以向下跳一位：

全部匹配成功，这个时候可以向下跳两位：

那么像这样的过程可以看作是只有一个模式串的多串匹配。
这样可以对模式串aba建立一个图：

其中点中的数字代表已经匹配到了哪一位，而边代表如果主串的下一个字符是黑色边上的字符那么就走黑色边，同时主串的当前字符变成当前字符的下一个字符，否则走红色回溯边。到达3号点的次数就是模式串aba在主串中出现的次数。
如：aabaaaba这个主串的匹配顺序是：第一个位置，匹配到了a，走黑色边；第二个位置，由于下一个应该出现的字符是b而主串出现的是a，那么走一次红色回溯边，然后走从0到1的黑色边；第三个位置，走1-2的黑色边；第四个位置，走2-3的黑色边，已经到达了3，答案+1；第五个位置应当走两边红色回溯边（因为走一遍过后应当出现的字符是b，而实际是a）……这可以被认为是一次KMP匹配过程，而建立红色边的过程就是KMP中建立next数组的过程。
可以看出，上面的过程中建立了一条链和一些红色边（回溯边），当模式串更多，这个时候就显然不能建立多个链，而是建立一棵树了（trie树）。例如，{he,she,her,shr}这4个单词（虽然最后面那个可能不是）建立的trie树就是：

其中打上绿色标记的是一个单词的终止节点。
那么红色边的定义就变成了：
fail指针：一个点x的fail指针指向的是离trie的根最远的点y，使得trie[root,y]=trie[z,x]，其中z是x的祖先。
例如这个图的红色边就有：

（由于某些技术上的原因导致这张图没有前面的几个图好看了，请原谅）
那么就可以照搬上面的方法来解决这个问题了：走的通就走黑色边，否则走红色边，到达绿色节点这个点的匹配数量加1。这样就非常完美的解决了多字符串匹配问题~~~
fail指针的添加等具体细节请见代码。

代码（非指针版）

实际上代码还是非常短的，只是我写的很长而已（作为一名扩行者的提醒）……

struct ac_automaton
{
  int cnt,son[maxm+10][26],fail[maxm+10],ans;
  int num[maxm+10],q[maxm+10],head,tail,tot,b[maxn+10],w[maxm+10];
  //cnt数组记录节点的种类
  //son记录这个点的所有儿子
  //fail就是正文中的意思
  //ans记录的是有多少个串被匹配成功了
  //num记录的是一个点有多少个串
  //q是队列
  //tot记录trie中有多少个字串
  //b记录的是一个点是否被搜索到
  //w记录的是一个模式串的末尾位置

  int init()//初始化应该没有任何问题吧
  {
    cnt=0;
    ans=0;
    tot=0;
    memset(son,0,sizeof son);
    memset(fail,0,sizeof fail);
    memset(num,0,sizeof num);
    memset(b,0,sizeof b);
    return 0;
  }


  int insert(char* s)//在自动机中插入一个串s（其实就是trie树的插入方法）
  {
    int len=strlen(s),now=0;//now记录已经插入到了哪一位
    for(register int i=0; i<len; ++i)
      {
        if(!son[now][s[i]-'a'])//如果没有这个节点，就新建一个
          {
            cnt++;
            son[now][s[i]-'a']=cnt;
          }
        now=son[now][s[i]-'a'];
      }
    tot++;//将这个串的信息记录一下
    num[now]++;
    w[tot]=now;
    return 0;
  }

  int build()//这个是建立fail指针
  {
    head=0;
    tail=0;
    for(register int i=0; i<26; ++i)//这个是队列的初始化
      {
        if(son[0][i])
          {
            tail++;
            q[tail]=son[0][i];
            fail[son[0][i]]=0;
          }
      }
    while(head!=tail)//用队列来优化fail指针的计算
      {
        head++;
        int now=q[head];
        for(register int i=0; i<26; ++i)
          {
            if(son[now][i])//这个自己想一想就好了
              {
                int r=fail[now];
                while((!son[r][i])&&(r))
                  {
                    r=fail[r];
                  }
                fail[son[now][i]]=son[r][i];
                tail++;
                q[tail]=son[now][i];
              }
            else
              {
                son[now][i]=son[fail[now]][i];
              }
          }
      }
    return 0;
  }

  int find(char* s)//让这些模式串匹配主串s，就是正文中的方法
  {
    int len=strlen(s),now=0;
    for(register int i=0; i<len; ++i)
      {
        while((now)&&(!son[now][s[i]-'a']))
          {
            now=fail[now];
          }
        if(son[now][s[i]-'a'])
          {
            now=son[now][s[i]-'a'];
            int r=now;
            while(r&&(!b[r]))
              {
                b[r]=1;
                r=fail[r];
              }
          }
      }
    return 0;
  }

  int work(char* s)//统计答案
  {
    build();
    find(s);
    for(int i=1; i<=tot; ++i)
      {
        ans+=b[w[i]];
      }
    printf("%d\n",ans);
    return 0;
  }
};

代码（指针版）

struct node
{
  node *ch[26],*fail;
  int vis;
};

namespace acam
{
  node bin[maxk+10],*root,*end[maxn+10];
  int cnt;
  std::queue<node*> q;

  int build()
  {
    cnt=0;
    root=&bin[++cnt];
    return 0;
  }

  int addstr(char *s,int len,int id)
  {
    node *now=root;
    for(int i=0; i<len; ++i)
      {
        if(now->ch[s[i]-'a']==NULL)
          {
            now->ch[s[i]-'a']=&bin[++cnt];
          }
        now=now->ch[s[i]-'a'];
      }
    end[id]=now;
    return 0;
  }

  int getfail()
  {
    root->fail=root;
    for(int i=0; i<26; ++i)
      {
        if(root->ch[i]!=NULL)
          {
            root->ch[i]->fail=root;
            q.push(root->ch[i]);
          }
      }
    while(!q.empty())
      {
        node *u=q.front();
        q.pop();
        for(int i=0; i<26; ++i)
          {
            if(u->ch[i]!=NULL)
              {
                node *now=u->fail;
                while((now!=root)&&(now->ch[i]==NULL))
                  {
                    now=now->fail;
                  }
                if(now->ch[i]!=NULL)
                  {
                    u->ch[i]->fail=now->ch[i];
                  }
                else
                  {
                    u->ch[i]->fail=root;
                  }
                q.push(u->ch[i]);
              }
          }
      }
    return 0;
  }

  int getans(char *s,int len)
  {
    node *now=root;
    for(int i=0; i<len; ++i)
      {
        while((now!=root)&&(now->ch[s[i]-'a']==NULL))
          {
            now=now->fail;
          }
        if(now->ch[s[i]-'a']!=NULL)
          {
            now=now->ch[s[i]-'a'];
          }
        node *u=now;
        while(!u->vis)
          {
            u->vis=1;
            u=u->fail;
          }
      }
    return 0;
  }
}
//对于i串，如果end[i]->vis==1那么就有匹配，否则没有