AC自动机模板(hdu2222)

    拜读了大牛们的代码，对AC自动机的了解又加深了一步。

    不过刚才去一个QQ群推荐的题集里看了下，里面的题目还是不能顺利的解决，看来还需要更深入的去了解。

   

    下面是hdu2222的题解，感觉可以作为不错的AC自动机模板代码。

 

#include 
using  namespace std;
const  int kind =  26;
struct node{
    node *fail;        // 失败指针
    node *next[kind];  // Tire每个节点的26个子节点（最多26个字母）
     int count;         // 是否为该单词的最后一个节点
    node(){            // 构造函数初始化
       fail=NULL;
       count= 0;
       memset(next,NULL, sizeof(next));
   }
}*q[ 500001];           // 队列，方便用于bfs构造fail指针
char keyword[ 51];      // 输入的单词
char str[ 1000001];     // 模式串
int head,tail;         // 队列的头尾指针

void insert( char *str,node *root){      // 建字典树
    node *p=root;
     int i= 0,index;
     while(str[i]){
        index=str[i]- ' a ';
         if(p->next[index]==NULL) p->next[index]= new node();
        p=p->next[index];
        i++;
    }
    p->count++;             // 每个单词的末尾字母标记count为1，代表一个单词
}
/*
在字典树上构造fail指针。构造失败指针的过程概括起来就一句话：
设这个节点上的字母为C，沿着他父亲的失败指针走，直到走到一个节点，
他的儿子中也有字母为C的节点。然后把当前节点的失败指针指向那个字母也为C的儿子。
如果一直走到了根节点都没找到，那就把失败指针指向根节点。

所以构造fail指针 需要用到BFS。 保证是按层遍历字典树。
*/
void build_ac_automation(node *root){       // 构建fail指针
     int i;
    root->fail=NULL;        // 根节点fail指针指向空值
    q[head++]=root;         // 根节点入队
     while(head!=tail){
        node *temp=q[tail++];
        node *p=NULL;
         for(i= 0;i< 26;i++){
             if(temp->next[i]!=NULL){
                 if(temp==root) temp->next[i]->fail=root;
                 // 根节点每个儿子的fail指针为根节点
                 else{
                    p=temp->fail;
                     while(p!=NULL){     // P不为空，即未到达根节点
                         if(p->next[i]!=NULL){   // 找到了包含当前字母儿子的父节点
                            temp->next[i]->fail=p->next[i]; // 将子结点的fail指针指向此节点
                             break;
                        }
                        p=p->fail;      // 未找到，则到其fail指针节点处继续找
                    }
                     if(p==NULL) temp->next[i]->fail=root;
                }
                q[head++]=temp->next[i];    // 子节点入队
            }
        }
    }
}
/*
匹配过程分两种情况：
(1)当前字符匹配，表示从当前节点沿着树边有一条路径可以到达目标字符，
此时只需沿该路径走向下一个节点继续匹配即可，目标字符串指针移向下个字符继续匹配；
(2)当前字符不匹配，则去当前节点失败指针所指向的字符继续匹配，
匹配过程随着指针指向root结束。重复这2个过程中的任意一个，直到模式串走到结尾为止。
*/
int query(node *root){
     int i= 0,cnt= 0,index,len=strlen(str);
    node *p=root;
     while(str[i]){
        index=str[i]- ' a ';
         while(p->next[index]==NULL && p!=root) p=p->fail;  // 当在字典树上找不到c字符，那么就根据fail指针回退
        // 直到找到 或者到达根节点
        p=p->next[index];
        p=(p==NULL)?root:p;
        node *temp=p;
         while(temp!=root && temp->count!=- 1){   // 根据fail指针回退，直到根节点
            cnt+=temp->count;
            temp->count=- 1;         // 避免重复记录
            temp=temp->fail;
        }
        i++;
    }
     return cnt;
}
int main(){
     int n,t;
    scanf( " %d ",&t);
     while(t--){
        head=tail= 0;
        node *root= new node();
        scanf( " %d ",&n);
        getchar();
         while(n--){
            gets(keyword);
            insert(keyword,root);
        }
        build_ac_automation(root);
        scanf( " %s ",str);
        printf( " %d\n ",query(root));
    }
     return  0;
}

 

转载于:https://www.cnblogs.com/xiaolongchase/archive/2011/10/10/2206679.html