KMP算法 AC自动机

先介绍一个数据结构Trie，也叫前缀树，用来保存字符串集合。

int ch[maxnode][sigma_size];
int val[maxnode];
int sz; //结点总数
 
void init(){
	sz = 1;  //初始化时只有一个结点
	memset(ch[0],0,sizeof(ch[0]));
}
//插入字符串s，附加信息为v。注意v必须是非0，因为0代表本结点不是单词结点
void insert(char* s, int v){
	int u = 0, n = strlen(s);
	for(int i = 0; i < n; i++){
		int c = s[i]-'a';
		if(!ch[u][c]){								//结点不存在
			memset(ch[sz],0,sizeof(ch[sz]));
			val[sz] = 0;                //中间结点的附加信息为零
			ch[u][c] = sz++;        
		}
		u = ch[u][c];                //往下走
	}
	val[u] = v;                    //字符串的最后一个字符的附加信息为v

Trie例题：

给出一个由S个不同单词组成的字典和一个长字符串。把这个字符串分解成若干个单词的连接（单词可以重复使用），有多少种方法？比如，有4个单词a，b，cd，ab，则abcd又两种分解方法：a+b+cd和ab+cd

分析：不难想到用动态规划。令d[i]表示从字符串i开始的字符串（即后缀S[i....L]）的分解方法数，则d[i]=sum{d[i+len(x)]}，其中单词x是S[i...L]的前缀。如果枚举x，在判断它是否是为S[i...L]，时间无法承受。可以换个思路，先把所有的单词组成一个Trie，然后试着在Trie中查找S[i...L]的前缀。查找过程中没经过一个单词节点，就找到一个上述状态转移方程中的x，最多需要比较100次就能找到所有x。

KMP算法：

KMP算法解决的是字符串匹配的问题。假定匹配过程中正在比较文本串*位置的字符和模板串abbaaba的最后一个字符，发现二者不同。KMP算法认为，我们已经知道文本串*前六个字符就是abbaab。因此应该根据模板串本身的特性来判断出右移一位一定不匹配。因此我们用一个f[i]来表示当模板串的第i个字符失配的时候，我们应该调到第几个字符重新匹配。

int find (char* t, char* p, int* f) //T为文本，p为模板串，f为失配函数
{
	int n = strlen(t), m = strlen(p);
	getFail(p,f);        //构建失配函数
	int j = 0;
	for(int i = 0; i < n; i++){
		while(j && p[j]!=t[i]) j = f[j];
		if(p[j]==t[i]) j++;
		if(j==m) printf("%d\n", i-m+1);
	}
}

void getFail(char* p int* f){
	int  m = strlen(p);
	f[0] = 0,f[1] = 0;
	for(int i = 1; i < m; i++){
		int j = f[i];
		while(j && p[j]!=p[i]) j = f[j];
		f[i+1] = (p[j]==p[i] ? j+1 : 0);
	}
}

AC自动机：在模式匹配问题中，如果模板有很多个，KMP算法就不太合适了。因为每次查找一个模板，都要遍历整个文本串。可不可以只遍历一次文本串呢？可以，方法就是把所有的模板建成一个大的状态转移图，而不是每个模板各建一个状态转移图。注意到KMP的状态转移图是线性的字符串加上失配边组成的，不难想到AC自动机是Trie加上失配边组成的。

int find (char* t){
	int n = strlen(t);
	int j = 0;
	for(int i = 0; i < n; i++){
		int c = t[i]-'a';
		while(j && !ch[j][c]) j = f[j];
		j = ch[j][c];
		if(val[j]){
			print(j);			//发现了一个单词匹配，并沿着后缀链接找更多匹配的单词
		} else if(last[j]) print(last[j]);
	}
}

void print (int j){
	if(j){
		printf("%d\n", val[j]);
		print(last[j]);
	}
}

代码中出现的一个陌生的数组last，下面解释一下。和Trie一样，我们认为所有val[j]>0的结点j都是单词结点，反之亦然。但是和Trie不同的是，同一个结点可能对应多个字符串的结尾。如，当找到she的时候，也以为着我们找到了he。当然，失配指针不一定指向单词结点，为了提高效率，这里增设了一个指针last[j]，表示结点j沿着失配指针往回走时，遇到的下一个单词结点。

计算失配函数的方式和KMP很接近，知识把线性递推改成了按照BFS顺序递推。代码如下：

int getFail(){
	queue<int> q;
	f[0] = 0;
	for(int i = 0; i < sigma_size; i++){
		int u = ch[0][i];
		if(u){
			f[u] = 0;
			last[u] = 0;
			q.push(u);
		}
	}
	while(!q.empty()){
		int u = q.front(), q.pop();
		for(int i = 0; i < sigma_size; i++){
			int r = ch[u][i];
			if(r){
				q.push(r);
				int p = f[u];
				while(p && !ch[p][i]) p = f[p];
				f[r] = ch[p][i];
				last[cr] = (val[f[r]] ? f[r] : last[f[r]]);
			}
		}
	}
}

HDOJ2222 基本的AC自动机

#include <iostream>
#include <string.h>
#include <queue>
using namespace std;
#define MAXN 500005
int n,sz,result;
int ch[MAXN][26],last[MAXN],f[MAXN],val[MAXN];
char t[1100000], c[50];  //题目中说t的长度不会超过1000000，所以一开始给t开了1000000大小，一直WA,纠结了一上午，最后我看别人的程序，试探性的改了下t的大小，竟然AC了。。。杭电的数据有的时候真是让人无语。。。。

void insert(char c[]){
    int m = strlen(c);
    int j = 0;
    for(int i = 0; i < m; i++){
        int index = c[i]-'a';
        if (!ch[j][index]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            val[sz] = 0;
            ch[j][index] = sz++;
        }
        j = ch[j][index];
    }
    val[j] += 1;
}
void GetFail(){
    queue<int> q;
    for(int i = 0; i < 26; i++){
        if (ch[0][i]) {
            int u = ch[0][i];
            f[u] = 0;
            last[u] = 0;
            q.push(u);
        }
    }
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for(int i = 0; i < 26; i++){
            if (ch[u][i]) {
                int k = ch[u][i];
                int j = f[u];
                while (j && !ch[j][i]) j = f[j];
                f[k] = ch[j][i];
                last[k] = (val[f[k]] ? f[k] : last[f[k]]);
                q.push(k);
            }
        }
    }
    
}
void init(){
    memset(ch[0], 0, sizeof(ch[0]));
    memset(val, 0, sizeof(val));
    sz = 1;
    result = 0;
    memset(f, 0, sizeof(f));
    memset(last, 0, sizeof(last));
    scanf("%d", &n);
    for(int i = 0; i < n; i++){
        scanf("%s",c);
        insert(c);
    }
    GetFail();
    scanf("%s", t);
}
void count(int j){
    if(!j) return;
    if (val[j]) {
        result += val[j];
        val[j] = 0;
    }
    count(last[j]);
}
void solve(){
    int j = 0;
    int m = strlen(t);
    for(int i = 0; i < m; i++){
        int index = t[i]-'a';
        while (j && !ch[j][index]) j = f[j];
        j = ch[j][index];
        if(val[j]) count(j);
        else if(last[j]) count(last[j]);
    }
}

int main(int argc, const char * argv[])
{
    int t;
    while (scanf("%d", &t)!=EOF) {
        while (t > 0) {
            t--;
            init();
            solve();
            printf("%d\n", result);
        }
    }
}

HDOJ 2896 病毒入侵 我的AC代码

#include <iostream>
#include <string.h>
#include <vector>
#include <queue>
#include <stdlib.h>
using namespace std;
#define MAXN 110000
#define sigma 133
int m,n,sz;
vector<int> result;
int ch[MAXN][sigma],f[MAXN],last[MAXN],v[MAXN],vis[MAXN];
char t[11000],c[210];
void insert(int num){
    int j = 0;
    int k = strlen(c);
    for(int i = 0; i < k; i++){
        int index = (int)c[i];
        if (!ch[j][index]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            v[sz] = 0;
            ch[j][index] = sz++;
        }
        j = ch[j][index];
    }
    v[j] = num;
}
void MakeFail(){
    queue<int> q;
    for(int i = 0; i < sigma; i++){
        if (ch[0][i]) {
            int u = ch[0][i];
            f[u] = 0;
            last[u] = 0;
            q.push(u);
        }
    }
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for(int i = 0; i < sigma; i++){
            if(ch[u][i]){
                int j = ch[u][i];
                int k = f[u];
                while (k && !ch[k][i]) k = f[k];
                f[j] = ch[k][i];
                last[j] = (v[f[j]] ? f[j] : last[f[j]]);
            }
        }
    }
}
void init(){
    memset(ch[0], 0, sizeof(ch[0]));
    memset(f, 0, sizeof(f));
    memset(last, 0, sizeof(f));
    memset(v, 0, sizeof(v));
    memset(vis, 0, sizeof(vis));
    result.clear();
    sz = 1;
    for(int i = 0; i < n; i++){
        scanf("%s",c);
        insert(i+1);
    }
}
void count (int num){
    int j = num;
    while (j) {
        if (v[j] > 0) {
            if(vis[j]==0) result.push_back(v[j]);
            vis[j] = 1;
            j = last[j];
        }
    }
}
void find (){
    int j = 0;
    int l = strlen(t);
    for(int i = 0; i < l; i++){
        int index = (int)t[i];
        while(j && !ch[j][index]) j = f[j];
        j = ch[j][index];
        if (v[j] > 0) {
            count(j);
        }else if(last[j]) {
            count(last[j]);
        }
        if (result.size()==3) {
            break;
        }
    }
}

int main(int argc, const char * argv[])
{
    while (scanf("%d",&n)!=EOF) {
        int total = 0;
        init();
        MakeFail();
        scanf("%d", &m);
        for(int i = 0; i < m; i++){
            result.clear();
            memset(vis, 0, sizeof(vis));
            scanf("%s", t);
            find();
            sort(result.begin(),result.end(), less<int>());
            if (result.size() > 0) {
                printf("web %d:",i+1);
                for(int j = 0; j < result.size(); j++){
                    printf(" %d", result[j]);
                }
                printf("\n");
                total++;
            }
        }
        printf("total: %d\n",total);
    }
}