(java)字符串的相似度

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

如：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];
    }
}

参考：

http://blog.csdn.net/hehe9737/article/details/7007079
http://blog.sina.com.cn/s/blog_757dbe67010172k1.html