2. 程式人生 > >多模式匹配演算法：AC自動機的C++實現

多模式匹配演算法：AC自動機的C++實現

阿新 • • 發佈：2019-02-09

AC自動機(Aho-Corasick automaton)是用來處理多模式匹配問題的。

基本可認為是TrieTree+KMP。其中KMP是一種單模式匹配演算法。

AC自動機的構造要點是失敗指標的設定，用於匹配失敗時跳轉到另一節點繼續匹配。同時在匹配的過程中也用來檢索其他“同尾”的模式。

失敗指標的設定：

用BFS。

對於每個節點，我們可以這樣處理：設這個節點上的字母為C，沿著他父親的失敗指標走，直到走到一個節點，他的兒子中也有字母為C的節點。然後把當前節點的失敗指標指向那個字目也為C的兒子。如果一直走到了root都沒找到，那就把失敗指標指向root。

最開始，我們把root加入佇列(root的失敗指標顯然指向自己)，這以後我們每處理一個點，就把它的所有兒子加入佇列，直到全部設定完畢。

要點1：root的孩子的那一層比較特殊，若按照上述演算法，它們的失敗指標會指向自己，這會在匹配的過程中導致死迴圈。顯然root的子節點的失敗指標應指向root，我們應對這一層單獨處理。

要點2：沿著父節點的失敗指標走到root之後並不是立即將子節點的失敗指標設定為root，而是在root的子節點中找尋字母為C的節點，將它設定為失敗指標。若沒有才設定為root。這樣不會丟失模式只有一個字母的情況。

匹配過程：

一開始，Trie中有一個指標t1指向root，待匹配串中有一個指標t2指向串頭。

接下來的操作和KMP很相似：

若：t2指向的字母，是Trie樹中，t1指向的節點的兒子，那麼

①t2+1,t1改為那個兒子的編號

②如果t1所在的點可以順著失敗指標走到一個綠色點（指TrieTree中單詞結尾字母對應的節點），那麼以那個綠點結尾的單詞就算出現過了。

否則：t1順這當前節點的失敗指標向上找，直到t2是t1的一個兒子，或者t1指向根。如果t1路過了一個綠色的點，那麼以這個點結尾的單詞就算出現過了。

c++實現：

//TrieTreeNode.h
#pragma once
#include<iostream>
using namespace std;

template<class T>
class TrieTreeNode
{
public:
	TrieTreeNode(int MaxBranch)//用於構造根節點
	{
		MaxBranchNum = MaxBranch;
		ChildNodes = new TrieTreeNode<T>*[MaxBranchNum];
		for (int i = 0; i < MaxBranchNum; i++)
			ChildNodes[i] = NULL;
		word = NULL;
		wordlen = 0;
		FailedPointer = NULL;
		Freq = 0;
		ID = -1;
	}
public:
	int MaxBranchNum;//最大分支數；
	char* word;//單詞字串的指標
	int wordlen;
	TrieTreeNode<T> **ChildNodes;
	int Freq;//詞頻統計
	int ID;//構建TrieTree樹時的插入順序，可用來記錄字串第一次出現的位置
	TrieTreeNode<T> *FailedPointer;
};
 


//TrieTree.h
#pragma once
#include<iostream>
#include"TrieTreeNode.h"
#include<queue>
using namespace std;

template<class T>
class TrieTree
{
	//Insert時為節點代表的單詞word分配記憶體，Delete時只修改Freq而不刪除word，Search時以Freq的數值作為判斷依據，而不是根據word是否為NULL
public:
	TrieTree(const int size);
	~TrieTree(){ Destroy(root); };
	void Insert(const T* str);//插入單詞str
	void Insert(const T* str, const int num);//插入單詞str，帶有編號資訊
	int Search(const T* str);//查詢單詞str，返回出現次數
	bool Delete(const T* str);//刪除單詞str
	void PrintALL();//列印trie樹中所有節點對應的單詞
	void PrintPre(const T* str);//列印以str為字首的單詞
	void SetFailedPointer();//設定匹配失效時的跳轉指標
	int MatchKMP(char* str);//返回str中出現在該TrieTree中的單詞個數
private:
	void Print(const TrieTreeNode<T>* p);
	void Destroy(TrieTreeNode<T>* p);//由解構函式呼叫，釋放以p為根節點的樹的空間
private:
	TrieTreeNode<T>* root;
	int MaxBranchNum;//最大分支數
};


template<class T>
void TrieTree<T>::Destroy(TrieTreeNode<T>* p)
{
	if (!p)
		return;
	for (int i = 0; i < MaxBranchNum; i++)
		Destroy(p->ChildNodes[i]);
	if (!p->word)
	{
		delete[] p->word;//只是釋放了char陣列word的空間，指標word本身的空間未釋放，由後續的delete p釋放
		p->word = NULL;
	}
	delete p;//釋放節點空間
	p = NULL;//節點指標置為空
	//以上的置NULL的兩句無太大意義，但是：程式設計習慣
}

template<class T>
bool TrieTree<T>::Delete(const T* str)
{
	TrieTreeNode<T>* p = root;
	if (!str)
		return false;
	for (int i = 0; str[i]; i++)
	{
		int index = str[i] - 'a';
		if (p->ChildNodes[index])
			p = p->ChildNodes[index];
		else return false;
	}
	p->Freq = 0;
	p->ID = -1;
	return true;
}

template<class T>
void TrieTree<T>::PrintPre(const T* str)
{
	TrieTreeNode<T>* p = root;
	if (!str)
		return;
	for (int i = 0; str[i]; i++)
	{
		int index = str[i] - 'a';
		if (p->ChildNodes[index])
			p = p->ChildNodes[index];
		else return;
	}
	cout << "以" << str << "為字首的單詞有:" << endl;
	Print(p);
}

template<class T>
int TrieTree<T>::Search(const T* str)
{
	TrieTreeNode<T>* p = root;
	if (!str)
		return -1;
	for (int i = 0; str[i]; i++)
	{
		int index = str[i] - 'a';
		if (p->ChildNodes[index])
			p = p->ChildNodes[index];
		else return 0;
	}
	return p->Freq;
}

template<class T>
TrieTree<T>::TrieTree(const int size)
{
	MaxBranchNum = size;
	root = new TrieTreeNode<T>(MaxBranchNum);//根節點不儲存字元
	root->FailedPointer = root;//設定失配指標
}

template<class T>
void TrieTree<T>::Insert(const T* str)
{
	TrieTreeNode<T>* p = root;
	int i;
	for (i = 0; str[i]; i++)
	{
		if (str[i]<'a' || str[i]>'z')
		{
			cout << "格式錯誤！" << endl;
			return;
		}
		int index = str[i] - 'a';//下溯的分支編號
		if (!p->ChildNodes[index])
			p->ChildNodes[index] = new TrieTreeNode<T>(MaxBranchNum);
		p = p->ChildNodes[index];
	}
	if (!p->word)//該詞以前沒有出現過
	{
		p->word = new char[strlen(str) + 1];
		strcpy_s(p->word, strlen(str) + 1, str);
		p->wordlen = i;//設定單詞長度
	}
	p->Freq++;
}

template<class T>
void TrieTree<T>::Insert(const T* str, const int num)
{
	TrieTreeNode<T>* p = root;
	int i;
	for (i = 0; str[i]; i++)
	{
		if (str[i]<'a' || str[i]>'z')
		{
			cout << "格式錯誤！" << endl;
			return;
		}
		int index = str[i] - 'a';//下溯的分支編號
		if (!p->ChildNodes[index])
			p->ChildNodes[index] = new TrieTreeNode<T>(MaxBranchNum);
		p = p->ChildNodes[index];
	}
	if (!p->word)//該詞以前沒有出現過
	{
		p->word = new char[strlen(str) + 1];
		strcpy_s(p->word, strlen(str) + 1, str);
		p->wordlen = i;
	}
	p->Freq++;
	if (num < p->ID || p->ID == -1)//取最小的num作為當前節點代表的單詞的ID
		p->ID = num;
}

template<class T>
void TrieTree<T>::PrintALL()
{
	Print(root);
}

template<class T>
void TrieTree<T>::Print(const TrieTreeNode<T>* p)
{
	if (p == NULL)
		return;
	if (p->Freq > 0)
	{
		cout << "單詞:" << p->word << "	頻數:" << p->Freq;
		if (p->ID >= 0)
			cout << "		ID:" << p->ID;
		cout << endl;
	}
	for (int i = 0; i < MaxBranchNum; i++)
	{
		if (p->ChildNodes[i])
		{
			Print(p->ChildNodes[i]);
		}
	}
}

template<class T>
int TrieTree<T>::MatchKMP(char* str)
{
	int count = 0;//str中出現的TrieTree中的單詞個數
	char* p = str;//str中指標
	TrieTreeNode<T>* node = root;//TrieTree的節點指標
	while (*p)
	{
		if (node->ChildNodes[*p - 'a'])//當前字元匹配成功
		{
			TrieTreeNode<T>* temp = node->ChildNodes[*p - 'a']->FailedPointer;
			while (temp != root)//在匹配的情況下，仍然沿FailedPointer搜尋，可檢索出所有模式。
			{
				if (temp->Freq > 0)
				{
					count++;
					//cout << "temp->wordlen:" << temp->wordlen << endl;
					cout << (int)(p - str) - temp->wordlen + 1 << "	" << temp->word << endl;//列印已匹配的模式的資訊
				}
				temp = temp->FailedPointer;
			}
			node = node->ChildNodes[*p - 'a'];
			p++;
			if (node->Freq > 0)
			{
				count++;
				//cout << "node->wordlen:" << node->wordlen << endl;
				cout << (int)(p - str) - node->wordlen << "	" << node->word << endl;//列印已匹配的模式的資訊
			}
		}
		else//失配，跳轉
		{
			if (node == root)
				p++;
			else
				node = node->FailedPointer;
		}
	}
	return count;
}

template<class T>
void TrieTree<T>::SetFailedPointer()
{
	queue<TrieTreeNode<T>*> q;
	q.push(root);
	while (!q.empty())
	{
		TrieTreeNode<T>* father = q.front();//父節點
		q.pop();
		for (int i = 0; i < MaxBranchNum; i++)//對每一個子節點設定FailedPointer
		{
			if (father->ChildNodes[i])
			{
				TrieTreeNode<T>* child = father->ChildNodes[i];
				q.push(child);
				TrieTreeNode<T>* candidate = father->FailedPointer;//從father->FailedPointer開始遊走的指標
				while (true)
				{
					if (father == root)
					{
						candidate = root;
						break;
					}
					if (candidate->ChildNodes[i])//有與child代表的字母相同的子節點
					{
						candidate = candidate->ChildNodes[i];
						break;
					}
					else
					{
						if (candidate == root)
							break;
						candidate = candidate->FailedPointer;//以上兩句順序不能交換，因為在root仍可以做一次匹配
					}
				}
				child->FailedPointer = candidate;
			}
		}
	}
}




//main.cpp
#pragma once
#include<iostream>
#include<fstream>
#include"TrieTree.h"
using namespace std;

void test(TrieTree<char>* t)
{
	char* charbuffer = new char[50];
	char* cb = charbuffer;

	fstream fin("d:\\words.txt");
	if (!fin){
		cout << "File open error!\n";
		return;
	}
	char c;
	int num = 0;
	while ((c = fin.get()) != EOF)
	{
		if (c >= '0'&&c <= '9')
			num = num * 10 + c - '0';
		if (c >= 'a'&&c <= 'z')
			*cb++ = c;
		if (c == '\n')
		{
			*cb = NULL;
			t->Insert(charbuffer, num);
			cb = charbuffer;
			num = 0;
		}
	}
	fin.close();
}


void main()
{
	TrieTree<char>* t = new TrieTree<char>(26);
	char* c1 = "she";
	char* c2 = "shee";
	char* c3 = "he";
	char* c4 = "e";

	char* s = "shee";//要匹配的串
	t->Insert(c1);
	t->Insert(c2);
	t->Insert(c3);
	t->Insert(c4);

	//test(t);
	t->SetFailedPointer();
	t->PrintALL();
	cout << endl << "匹配結果為:" << endl;
	int result = t->MatchKMP(s);
	cout << "共匹配" << result << "處模式串" << endl;
	system("pause");
}

執行結果：

對"shee"進行匹配

模式串為："shee" "she" "he" "e"


相關推薦

多模式匹配演算法：AC自動機的C++實現

AC自動機(Aho-Corasick automaton)是用來處理多模式匹配問題的。 基本可認為是TrieTree+KMP。其中KMP是一種單模式匹配演算法。 AC自動機的構造要點是失敗指標的設定，用於匹配失敗時跳轉到另一節點繼續匹配。同時在匹配的過程中也用來檢索其他“同

多模字串匹配演算法之AC自動機—原理與實現

簡介： 本文是博主自身對AC自動機的原理的一些理解和看法，主要以舉例的方式講解，同時又配以相應的圖片。程式碼實現部分也予以明確的註釋，希望給大家不一樣的感受。AC自動機主要用於多模式字串的匹配，本質上是KMP演算法的樹形擴充套件。這篇文章主要介紹AC自動機的工作原理，並在此

資料結構- 串的模式匹配演算法： KMP演算法

1、KMP演算法求解什麼型別問題？ 字串匹配。給你兩個字串，尋找其中一個字串是否包含另一個字串，如果包含，返回包含的起始位置。 2、完整的KMP演算法 #include <bits/stdc++

Aho-Corasick 多模式匹配算法、AC自動機詳解

實現 輸出 dfa 輸入 開始 img 添加 每一個 jpg Aho-Corasick算法是多模式匹配中的經典算法，目前在實際應用中較多。 Aho-Corasick算法對應的數據結構是Aho-Corasick自動機，簡稱AC自動機。 搞編程的一般都應該知道自動機FA吧，具體

18.10.29 多模式串字符串匹配模板題~AC自動機

輸入 queue prev pac 輸出 spl 串匹配 opened ++ 描述 給若幹個模式串，以及若幹個句子，判斷每個句子裏是否包含模式串。 句子和模式串都由小寫字母組成 輸入第一行是整數n，表示有n個模式串 ( n <= 1000)接下來n行每行一個模式串

演算法4-6：KMP字串模式匹配演算法實現 （c語言）

[提交] [統計] [提問] 題目描述 KMP演算法是字串模式匹配演算法中較為高效的演算法之一，其在某次子串匹配母串失敗時並未回溯母串的指標而是將子串的指標移動到相應的位置。嚴蔚敏老師的書中詳細描述了KMP演算法，同時前面的例子中也描述了子串移動位置的陣列實現的演算法。前面你已經實現

簡單講解KMP單模式匹配與AC演算法多模式匹配（KMP篇）

前言 本篇是對於KMP單模式匹配以及AC演算法多模式匹配的簡單講解，KMP演算法與AC演算法是關鍵字檢索中的常見演算法，能夠快速而高效地查找出目標字串中的多個關鍵字的匹配情況，而要檢索的關鍵字通常被稱為模式串，因此模式匹配四個字也就好理解了。網上的很多對於KMP的講解總是結

C/C++——樸素的模式匹配演算法和KMP模式匹配演算法

樸素的模式匹配演算法 其實就是一個一個往下匹配，沒有任何優化，在好的情況下時間複雜度為O(n+m)，在最求的情況下時間複雜度為O((n-m+1)*m)。 程式碼實現： //在主串s中找子串t，若找

C/C++/Java程式碼 樸素的(暴力法)模式匹配演算法 KMP演算法 資料結構

樸素的模式匹配(暴力法)演算法 演算法思想： 從目標串的的第一個字元起與模式串的第一個字元比較，若相等，則繼續對字元進行後續的比較，否則目標串從第二個字元起與模式串的第一個字元重新比較，直至模式串中的每個字元依次和目標串中的一個連續的字元序列相等為止，此時稱為匹配

演算法講解：ac自動機及簡單衍生

AC自動機簡介：  首先簡要介紹一下AC自動機：Aho-Corasick automation，該演算法在1975年產生於貝爾實驗室，是著名的多模匹配演算法之一。一個常見的例子就是給出n個單詞，再給出一段包含m個字元的文章，讓你找出有多少個單詞在文章裡出現過。嗯沒錯，比

KMP演算法與樸素模式匹配演算法（C語言）

在上一篇部落格中介紹了KMP演算法和樸素模式匹配演算法的區別，本文主要針對這兩種演算法的C語言實現進行講解。 #include<stdio.h> #define OK 0 #define ERROR -1 #define FAILED 1 in

BM模式匹配演算法I C++實現

// int BM(char *s,char *t,int *dist,const int lenS,const int lenT) { int i,j,k; i = lenT-1; while(i<lenS) { j = lenT-1; k = i; while(j>=0&&s[

串模式匹配算法KMP的C語言實現

退回 lib false else 不同 存在 == 根據 status #include "string.h"#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #

Brute-Force模式匹配演算法兩種實現方式

1. public static int indexOf(String mainStr,String subString,int start) { if((mainStr.length()<subString.length()) || mainStr==null || subStr

【python 走進NLP】兩種高效過濾敏感詞演算法--DFA演算法和AC自動機演算法

一道bat面試題：快速替換10億條標題中的5萬個敏感詞，有哪些解決思路？ 有十億個標題，存在一個檔案中，一行一個標題。有5萬個敏感詞，存在另一個檔案。寫一個程式過濾掉所有標題中的所有敏感詞，儲存到另一個檔案中。 1、DFA過濾敏感詞演算法 在實現文字過濾的演算法中，DFA是

學習筆記第二十七節：AC自動機

正題       聽說NOIP要考，所以臨時補了一下，多了一種思考方式。       AC自動機是基於KMP和字典樹的，要想透徹瞭解AC自動機，最好先學KMP和字典樹。       那麼，AC自

模式匹配演算法思想和實現KMP

首先模式匹配演算法解決的問題是在一個主串和一個模式匹配串中查詢相同的模式匹配串，如果相等，則返回當前模式匹配串的起始位置，否則返回-1 實現思路： /** 首先第一個大前提就是長度 第二個是判斷二者是否相等，然後同時後移 否則直接回退到i = i - j + 1

文章標題 改進的模式匹配演算法

一.演算法功能: 改進的模式演算法是由Knuth,Morris和Pratt等人共同提出的，所以稱為Knuth-Morris-Pratt演算法，簡稱KMP演算法。KMP演算法是字串模式匹配中的經典演算法，在起匹配過程中，主串指標不回溯，從而提高了演算法效能。 二.演算法思想

JAVA實現KMP模式匹配演算法

獲取next()陣列 /** * 獲取next陣列 * data 主字串 * */ public static int[] getNext(String data){ int[] next=new int[data.length()] ; next [0]=0;

資料結構- 串的模式匹配演算法 BF和 KMP演算法

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！