多模式匹配AC算法Java（kotlin）实现，可建模中文

目的

在自然语言处理领域，如果我们要在文本中检测特定的词，这就是模式匹配的问题。如果检测多个词，则是多模式匹配。最简单的方法是依次在给定的文本中检测所有感兴趣模式（兴趣词），这样做在兴趣词很多的时候，或者文本很大的时候，其计算复杂度很高，所以就有了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
中国
中国
中国

参考资料

彻底理解AC多模式匹配算法