兩個字串的相似度定義為：將一個字串轉換成另外一個字串的代價（通過插入、刪除、替換三種方式轉換），轉換的代價越高則說明兩個字串的相似度越低。

如：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