(java)字符串的相似度_java 词林相似度-CSDN博客

两个字符串的相似度定义为：将一个字符串转换成另外一个字符串的代价（通过插入、删除、替换三种方式转换），转换的代价越高则说明两个字符串的相似度越低。

如：snowy与sunny，转换方式有

变换1：
S - N O W Y
S U N N - Y
Cost = 3 （插入U、替换O、删除W）
变换2：
- S N O W - Y
S U N - - N Y
Cost = 5 （插入S、替换S、删除O、删除W、插入N）

对于多阶段决策类型的问题，应该优先考虑动态规划法（Dynamic Programming, DP）。
假设source字符串有n个字符，target字符串有m个字符，如果将问题定义为求解将source的1－n个字符转换为target的1－m个字符所需要的最少编辑次数（最小编辑距离），则其子问题就可以定义为将source的1－i个字符转换为target的1－j个字符所需要的最少编辑次数，这就是本问题的最优子结构。我们用d[i, j]表示source[1…i]到target[1…j]之间的最小编辑距离，则计算d[i, j]的递推关系可以这样计算出来：
如果source[i] 等于target[j]，则：
d[i, j] = d[i-1, j-1] + 0 （1）

如果source[i] 不等于target[j]，则根据插入、删除和替换三个策略，分别计算出使用三种策略得到的编辑距离，然后取最小的一个：
d[i, j] = min(d[i, j - 1] + 1，d[i - 1, j] + 1，d[i - 1, j - 1] + 1 ) （2）

d[i, j - 1] + 1 表示对source[i]执行插入操作后计算最小编辑距离
d[i - 1, j] + 1 表示对source[i]执行删除操作后计算最小编辑距离
d[i - 1, j - 1] + 1表示对source[i]替换成target[i]操作后计算最小编辑距离

d[i, j]的边界值就是当target为空字符串（m = 0）或source为空字符串（n = 0）时所计算出的编辑距离：
m = 0，对于所有 i：d[i, 0] = i
n = 0，对于所有 j：d[0, j] = j

代码如下：

import java.util.Scanner;

public class Qiyone {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
String source = in.next();
String target = in.next();
int i;
i = EditDistance(source, target);
System.out.println(i);
}
}

/**
 * 采用动态规划的方法解决
 *
 * @param source
 * @param target
 * @return
 */
private static int EditDistance(String source, String target) {
    char[] sources = source.toCharArray();
    char[] targets = target.toCharArray();
    int sourceLen = sources.length;
    int targetLen = targets.length;
    int[][] d = new int[sourceLen + 1][targetLen + 1];
    for (int i = 0; i <= sourceLen; i++) {
        d[i][0] = i;
    }
    for (int i = 0; i <= targetLen; i++) {
        d[0][i] = i;
    }

    for (int i = 1; i <= sourceLen; i++) {
        for (int j = 1; j <= targetLen; j++) {
            if (sources[i - 1] == targets[j - 1]) {
                d[i][j] = d[i - 1][j - 1];
            } else {
                //插入
                int insert = d[i][j - 1] + 1;
                //删除
                int delete = d[i - 1][j] + 1;
                //替换
                int replace = d[i - 1][j - 1] + 1;
                d[i][j] = Math.min(insert, delete) > Math.min(delete, replace) ? Math.min(delete, replace) :
                        Math.min(insert, delete);
            }
        }
    }
    return d[sourceLen][targetLen];
}

}

作者：超级侠哥
来源：CSDN
原文：https://blog.csdn.net/znb769525443/article/details/52582888
版权声明：本文为博主原创文章，转载请附上博文链接！