文本相似度 -- 最小編輯距離算法

最小編輯距離算法是計算兩個字符串之間相互轉換最少要經過多少次操作(增加,移除,替換)的算法
算法原理
這個算法計算的是將s[1…i]轉換爲t[1…j]（例如將beauty轉換爲batyu）所需最少的操作數（也就是所謂的編輯距離），這個操作數被保存在d[i,j]中。

例如我們將beauty轉換爲空字符串，我們需要進行的操作數爲beauty的長度（所進行的操作爲將beauty所有的字符丟棄）。
我們對字符可能進行的操作有三種：
將s[1…n]轉換爲t[1…m]當然需要將所有的s轉換爲所有的t，所以，d[n,m]就是我們所需的結果。
如果我們可以使用k個操作數把s[1…i]轉換爲t[1…j-1]，我們只需要把t[j]加在最後面就能將s[1…i]轉換爲t[1…j]，操作數爲k+1
如果我們可以使用k個操作數把s[1…i-1]轉換爲t[1…j]，我們只需要把s[i]從最後刪除就可以完成轉換，操作數爲k+1
如果我們可以使用k個操作數把s[1…i-1]轉換爲t[1…j-1]，我們只需要在需要的情況下（s[i] != t[j]）把s[i]替換爲t[j]，所需的操作數爲k+cost（cost代表是否需要轉換，如果s[i]==t[j]，則cost爲0，否則爲1）。
這個證明過程只能證明我們可以得到結果，但並沒有證明結果是最小的（即我們得到的是最少的轉換步驟）。所以我們引進了另外一個算法，即d[i,j]保存的是上述三種操作中操作數最小的一種。這就保證了我們獲得的結果是最小的操作數

關於最小編輯距離算法 , 網上有很多資料 , 這裏講一下我遇到的論壇大神將最小編輯距離算法反用的計算文本相似度的算法

  /* 
     * 計算相似度 
     * */  
    public static double SimilarDegree(String strA, String strB){     
        String newStrA = removeSign(strA);      
        String newStrB = removeSign(strB);  
        //用較大的字符串長度作爲分母，相似子串作爲分子計算出字串相似度  
        int temp = Math.max(newStrA.length(), newStrB.length());      
        int temp2 = longestCommonSubstring(newStrA, newStrB).length();     
        return temp2 * 1.0 / temp;      
    }    


    /* 
     * 將字符串的所有數據依次寫成一行 
     * */  
    public static String removeSign(String str) {     
        StringBuffer sb = new StringBuffer();   
        //遍歷字符串str,如果是漢字數字或字母，則追加到ab上面  
        for (char item : str.toCharArray())     
            if (charReg(item)){      
                sb.append(item);    
            }    
        return sb.toString();    
    }    


    /* 
     * 判斷字符是否爲漢字，數字和字母， 
     * 因爲對符號進行相似度比較沒有實際意義，故符號不加入考慮範圍。 
     * */  
    public static boolean charReg(char charValue) {      
        return (charValue >= 0x4E00 && charValue <= 0X9FA5) || (charValue >= 'a' && charValue <= 'z')  
                || (charValue >= 'A' && charValue <= 'Z')  || (charValue >= '0' && charValue <= '9');      
    }      


 public static String longestCommonSubstring(String str1, String strB) {     
        char[] chars_strA = strA.toCharArray();  
        char[] chars_strB = strB.toCharArray();   
        int m = chars_strA.length;     
        int n = chars_strB.length;   

        /* 
         * 初始化矩陣數據,matrix[0][0]的值爲0， 
         * 如果字符數組chars_strA和chars_strB的對應位相同，則matrix[i][j]的值爲左上角的值加1， 
         * 否則，matrix[i][j]的值等於左上方最近兩個位置的較大值， 
         * 矩陣中其餘各點的值爲0. 
        */  
        int[][] matrix = new int[m + 1][n + 1];     
        for (int i = 1; i <= m; i++) {    
            for (int j = 1; j <= n; j++) {      
                if (chars_strA[i - 1] == chars_strB[j - 1])     
                    matrix[i][j] = matrix[i - 1][j - 1] + 1;      
                else     
                    matrix[i][j] = Math.max(matrix[i][j - 1], matrix[i - 1][j]);     
            }     
        }  
        /* 
         * 矩陣中，如果matrix[m][n]的值不等於matrix[m-1][n]的值也不等於matrix[m][n-1]的值， 
         * 則matrix[m][n]對應的字符爲相似字符元，並將其存入result數組中。 
         *  
         */  
        char[] result = new char[matrix[m][n]];      
        int currentIndex = result.length - 1;     
        while (matrix[m][n] != 0) {     
            if (matrix[n] == matrix[n - 1])    
                n--;     
            else if (matrix[m][n] == matrix[m - 1][n])      
                m--;     
            else {     
                result[currentIndex] = chars_strA[m - 1];     
                currentIndex--;    
                n--;     
                m--;    
            }    
        }      
       return new String(result);     
    } 
    /* 
     * 結果轉換成百分比形式  
     * */     
    public static String similarityResult(double resule){      
        return  NumberFormat.getPercentInstance(new Locale( "en ", "US ")).format(resule);     
    }