目的
在自然语言处理领域，如果我们要在文本中检测特定的词，这就是模式匹配的问题。如果检测多个词，则是多模式匹配。最简单的方法是依次在给定的文本中检测所有感兴趣模式（兴趣词），这样做在兴趣词很多的时候，或者文本很大的时候，其计算复杂度很高，所以就有了AC算法，其计算复杂度相比上述方法降低不少。另外还有对AC算法的改进算法，如ACBM等，本文重点讲解AC。
网上对AC算法的博文也不少，但是大部分是C++程序，而且只能建模26个小写英文字母，本文的kotlin程序则可以建模任何的unicode字符。
要点
如果不了解AC算法，推荐看博文 彻底理解AC多模式匹配算法，然后再继续。
AC算法的要点有两个，即构建兴趣模式的trie树，和构建自动机失败跳转机制。
构建trie树比较好理解，即将模式分为一个个字符，根据字符先后顺序依次在树种生成子节点，直到一个模式完成。失败跳转则表示如果文本当前的符号在trie树种没有子节点，则为其选择另一个能继续下去的节点，最差的情况是回到根节点。
构建失败跳转机制的时候，根节点跟别的节点不太一样。如果在根节点匹配到子节点，则跳转到子节点，否则跳转到根节点。如果在非根节点匹配到子节点，则跳转到子节点，否则跳转到失败跳转机制指定的节点。
Kotlin程序
package com.davezhao.utils
data class Node(
var finish: Boolean = false,
var state: Int = 0,
var pattern: String = ""
) {
val transTable: MutableMap<Char, Node> = mutableMapOf()
fun containsEdge(edge: Char): Boolean {
return if (state == 0) true else transTable.contains(edge)
}
fun goto(edge: Char): Node {
return if (state != 0) transTable[edge]!!
else if (transTable.contains(edge)) transTable[edge]!! else this
}
fun addEdge(edge: Char, node: Node): Node {
transTable.put(edge, node)
return this
}
}
class AcPatternMathing {
val startNode: Node = Node()
var stateCount = 0
val correspondingNode: MutableList<Node> = mutableListOf(this.startNode)
lateinit var fail: MutableMap<Int, Node>
fun loadPatterns(patterns: List<String>) {
var latestState = 1
patterns.forEach { pattern ->
var p = this.startNode
pattern.forEach { symbol ->
val isExists = p.transTable.contains(symbol)
p = if (!isExists) {
val nextNode = Node(state = latestState++)
p.addEdge(symbol, nextNode)
this.correspondingNode.add(nextNode)
nextNode
} else {
p.goto(symbol)
}
}
p.finish = true
p.pattern = pattern
}
this.stateCount = latestState
}
fun dispose() {
val q = mutableListOf<Node>()
this.fail = mutableMapOf()
startNode.transTable.forEach {
fail[it.value.state] = startNode
q.add(it.value)
}
while (!q.isEmpty()) {
val known = q.removeAt(0)
known.transTable.forEach { symbol, nxtNode ->
var p = fail[known.state]
while (!p!!.containsEdge(symbol)) {
println(p.state)
p = fail[p.state]
}
fail[nxtNode.state] = p.goto(symbol)
q.add(nxtNode)
}
}
}
fun match(str: String, S: MutableList<String>) {
var p = startNode
var i = 0
while (i < str.length) {
val symbol = str[i]
p = if (p.containsEdge(symbol)) {
p.goto(symbol)
} else {
i--
fail[p.state]!!
}
if (p.finish) {
S.add(p.pattern)
}
i++
}
}
}
fun main(args: Array<String>) {
val ac = AcPatternMathing()
val patterns = listOf("his", "hers", "she", "he", "中国")
val matched = mutableListOf<String>()
ac.loadPatterns(patterns = patterns)
ac.dispose()
val str = "hishers中国人民中国中国"
ac.match(str, matched)
matched.forEach {
println(it)
}
}
输出为：
his
she
he
hers
中国
中国
中国
