求算两个字符串之间的编辑距离

简述：

设A和B是两个字符串，要用最少的字符操作将字符串A转换为字符串B

字符串操作包括，

1）删除一个字符

2）插入一个字符

3）将一个字符改为另一个字符

算法：

模拟构造一个（m + 1)行，（n+1）列的表格

每一次都是在前一次的计算结果下，得到当前的值

首先是三个特殊情况 用srcStr表示源字符串，dstStr 表示目标字符串

1)    两个空字符串的编辑距离D(srcStr, dstStr) = 0

2)   如果srcStr为空，dstStr不为空，则D(srcStr, dstStr) = dstStr.length(), 即在原空字符串上添加字符，形成dstStr

3)   如果dstStr为空，srcStr不为空，则D(srcStr, dstStr) = srcStr.length(), 及在源字符串上删除其所有字符，直至为空

例子：

下面实际解决一下从srcStr = "bd"  到 dstStr = "abcd"的过程，

上面这三种情况分别是初始化的时候要做的

首先用一维数组表示两位数组

纵向 i = 0 -> m+1 ， d[i * (n + 1)] = i 

横向 i = 0 -> n+1, d[i] = i

即：如下图是初始化之后的表格信息，纵向是b,d   横向是a,b,c,d

步骤：

for(i = 1 -> 2)     //  2为“bd"的长度

      for( j = 1 -> 4 )   // 4 为”abcd"的长度

为了确定d[ i ][ j ]的大小， 需要比较

a)  从d[ i - 1 ][j - 1] 修改字符srcStr[i - 1], 使之变为dstStr[j - 1], 如果srcStr[i - 1] == dstStr[j - 1] 则这一步可以免去

b)  从d[ i - 1 ][ j ]  在srcStr的[ i - 1]处添加一个字符，使字符srcStr[ i - 1 ]变为dstStr[ j - 1 ]

c)  从d[ i ][ j - 1 ] 在dstStr的[ j - 1 ]处删除一个字符， 使字符dstStr[ j - 1 ]变为srcStr[ i - 1]

三者之间的最小值赋给d[ i ][ j ]

代码：

[java] view plain

1. package dynamic_programming;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStream;  
6. import java.io.InputStreamReader;  
7.   
8. public class StringToString {  
9.     public static void main(String[] args) {  
10.         System.out.print("please input src String: ");  
11.         InputStream inputStream = System.in;  
12.         InputStreamReader inputStreamReader = new InputStreamReader(inputStream);     
13.         BufferedReader bufferReader = new BufferedReader(inputStreamReader);  
14.           
15.         //Get source string  
16.         String srcStr = null;    
17.         try{    
18.             srcStr = bufferReader.readLine();  
19.         }catch(IOException e){    
20.             e.printStackTrace();    
21.         }  
22.         //Get destination string  
23.         String dstStr = null;  
24.         System.out.print("please input dst String: ");  
25.         try{    
26.             dstStr = bufferReader.readLine();  
27.         }catch(IOException e){    
28.             e.printStackTrace();    
29.         }  
30.           
31.         //Display the result  
32.         System.out.println("Edit Distance is: "   
33.                 + getEditDistance(srcStr, dstStr));  
34.           
35.         try{    
36.             bufferReader.close();    
37.             inputStreamReader.close();    
38.             inputStream.close();    
39.         }catch(IOException e){    
40.             e.printStackTrace();    
41.         }    
42.     }  
43.       
44.     public static int getEditDistance(String srcStr, String dstStr){  
45.         int m = srcStr.length();  
46.         int n = dstStr.length();  
47.         //use one dimension array to represent two dimension  
48.         //Initializing...  
49.         int d[] = new int[(m + 1) * (n + 1)];  
50.         for(int i = 0;i <= m;i++)  
51.             d[i * (n + 1)] = i;  
52.         for(int i = 0;i <= n;i++)  
53.             d[i] = i;  
54.           
55.         //Dynamic Programming...  
56.         for(int i = 1; i <= m;i++){  
57.             for(int j = 1; j <= n;j++){  
58.                 int modifyDis = d[(i - 1) * (n + 1) + (j - 1)]  
59.                           + (srcStr.charAt(i - 1) == dstStr.charAt(j - 1) ? 0 : 1);  
60.                 int addDis = d[(i - 1) * (n + 1) + j] + 1;  
61.                 int deleteDis = d[i * (n + 1) + (j - 1)] + 1;  
62.                 d[i * (n + 1) + j] = Min(modifyDis, addDis, deleteDis);  
63.             }  
64.         }  
65.           
66.         //Display Result  
67.         System.out.println("Result Array: ");  
68.         for(int i = 0; i <= m;i++){  
69.             for(int j = 0; j <= n;j++){  
70.                 System.out.print("\t" + d[i * (n + 1) + j]);  
71.             }  
72.             System.out.println();  
73.         }  
74.           
75.         return d[m * (n + 1) + n];  
76.     }  
77.       
78.     public static int Min(int a, int b, int c){  
79.         int result = a > b ? b : a;  
80.         return result > c ? c : result;  
81.     }  
82. }  

输出测试：