几种句子相似度实现算法（简单了解一下）

最近在做一个虚拟客服的项目，简单的了解了一下中文语境的集中句子相似度的算法

看了大佬的项目和博客，不明觉厉，链接送上：https://github.com/wenyangchou/SimilarCharactor

SimilarCharactor

基于音形码，EditDistance的字符串纠正相似度算法

音形码格式：【韵母，声母，结构，四角编码，笔画数】 共8位

音形码相似度算法 参考博客https://blog.csdn.net/chndata/article/details/41114771
TODO 字符串错误匹配算法 参考

结构、四角编码 抓取http://zidian.miaochaxun.com 数据
韵母、声母 使用pinyin包
笔画数抓取https://bihua.51240.com 数据

入口函数在string_similarity.py

繁简切换 Done ongoing 相似度分值映射调整(sigmod函数映射) TODO 字符串包含关系 ongoing 相似度算法添加与调整(bm25)
TODO 字符串错位

除了大佬介绍的几种解决方案，大概介绍一下常用和我能直接理解的三种简单算法：

BF算法

暴力检索，这种方法最容易想到，也是最容易实现的，从首字母开始挨个的将关键字和做比对

package other.string.textmatch;

/**
 * 暴力检索
 */
public class BFMatch {

    /**
     * 暴力检索，输出匹配到的关键字的起始索引（包括起始索引在内，因为有的是不包括结尾下标在内，所以这里说明一下）
     *
     * @param originText 原始文字
     * @param keyword    要匹配的关键字
     */
    public static void BFMatch(String originText, String keyword) {
        char originChar;
        for (int i = 0; i < originText.length(); i++) {
            for (int j = 0; j < keyword.length(); j++) {
                if (i + j >= originText.length()) break;
                originChar = originText.charAt(i + j);

                if (originChar != keyword.charAt(j)) {
                    break;
                }

                if (j == keyword.length() - 1) {
                    System.out.println("找到匹配字符串，起始：" + i +
                            " 终止：" + (i + keyword.length() - 1));
                }
            }
        }
    }

    public static void main(String... args) {
        BFMatch("asdfj9iwhefpnehbnfhodhsvb", "j9");
    }
}

RK算法

RK 算法是对 BF 算法的一个改进，RK 对于 BF 的改进就在于尝试进行一次比较来判断两者是否相等。RK 算法首先计算子串的哈希值，然后在原字符串中取出同样长度的字符串计算哈希值，如果二者的哈希值不等那么他们一定不同。如果哈希值相同，由于哈希冲突的存在，也需要再次比对一下是否相同。一般情况肯定高于BF的

package other.string.textmatch;

public class RKMatch {

    /**
     * 暴力检索的改进，输出匹配到的关键字的起始索引（包括起始索引在内，因为有的是不包括结尾下标在内，所以这里说明一下）
     *
     * @param originText 原始文字
     * @param keyword    要匹配的关键字
     */
    public static void RKMatch(String originText, String keyword) {
        int keyHash = keyword.hashCode();
        int keyLength = keyword.length();

        String subString;
        for (int i = 0; i < originText.length(); i++) {
            if (keyLength + i >= originText.length()) break;

            subString = originText.substring(i, i + keyLength);
            if (subString.hashCode() == keyHash) {
                for (int j = 0; j < keyLength; j++) {
                    if (subString.charAt(j) != keyword.charAt(j)) break;

                    if (j == keyLength - 1) {
                        System.out.println("找到匹配字符串，起始：" + i +
                                " 终止：" + (i + keyword.length() - 1));
                    }
                }
            }
        }
    }

    public static void main(String... args) {
        RKMatch("asdfj9iwhefpnehbnfhodhsvb", "j9");
    }
}

KMP

“部分匹配值”是指字符串前缀和后缀所共有元素的长度。前缀是指除最后一个字符外，一个字符串全部头部组合；后缀是指除第一个字符外，一个字符串全部尾部组合。以”ABCDABD”为例：
“AB”的前缀为[A]，后缀为[B]，共有元素的长度为0；
“ABC”的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；
“ABCD”的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；
“ABCDA”的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为”A”，长度为1；
“ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为”AB”，长度为2；
“ABCDABD”的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。
 

    /**
     * 计算部分匹配值
     */
    public static int[] calcPartMatch(String keyword) {
        int[] partMatchVal = new int[keyword.length()];

        for (int i = 0; i < keyword.length(); i++) {
            if (i == 0) {
                partMatchVal[0] = 0;
                continue;
            }
            String subKey = keyword.substring(0, i + 1);
            // 求前缀
            list1.clear();
            for (int j = 1; j < subKey.length(); j++) {
                list1.add(subKey.substring(0, j));
            }

            // 求后缀
            list2.clear();
            for (int j = 1; j < subKey.length(); j++) {
                list2.add(subKey.substring(j, subKey.length()));
            }

            System.out.println("\ni = " + i);

            for (String s : list1) {
                System.out.println("前缀：" + s);
            }

            for (String s : list2) {
                System.out.println("后缀：" + s);
            }

            // 求交集
            list1.retainAll(list2);
            if (list1.size() == 0) partMatchVal[i] = 0;
            else {
                partMatchVal[i] = list1.get(0).length();
            }

            System.out.println("\n长度为：" + partMatchVal[i]);
        }

        return partMatchVal;
    }

输入 ada ，输出：

i = 1
前缀：a
后缀：d

长度为：0

i = 2
前缀：a
前缀：ad
后缀：da
后缀：a

长度为：1

计算得出的部分匹配值就是0、0、1

KMP算法实现：

    /**
     * 流程比较复杂，注释里比较难写清，具体可见
     * http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html
     * <p>
     * 具体的操作流程就是：
     * 1.计算 keyword 的部分匹配值
     * 2.进行匹配操作，碰到部分匹配成功，下一次 起始点索引 = 原位置 + 已匹配的字符数 - 对应的部分匹配值
     */
    public static void kmpMatch(String originText, String keyword) {
        // 部分匹配值
        int[] partMatch = calcPartMatch(keyword);

        for (int i = 0; i < originText.length(); ) {
            char c;
            // 匹配字符数
            int count = 0;
            for (int j = 0; j < keyword.length(); j++) {
                if (i + j >= originText.length()) break;
                c = originText.charAt(i + j);
                if (c != keyword.charAt(j)) {
                    break;
                }
                count++;
                if (j == keyword.length() - 1) {
                    System.out.println("找到匹配字符串，起始：" + i +
                            " 终止：" + (i + keyword.length() - 1));
                }
            }
            if (count == 0) {
                i++;
            } else {
                i += count - partMatch[count - 1];
            }
            if (i > originText.length()) break;
        }
    }

输入：kmpMatch(“asdfasdfasdfasdfadae4rqerfasdfv”, “ada”);
输出：找到匹配字符串，起始：16 终止：18