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

简述：

设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 ]

代码：

package dynamic_programming;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class StringToString {
	public static void main(String[] args) {
		System.out.print("please input src String: ");
        InputStream inputStream = System.in;
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);   
        BufferedReader bufferReader = new BufferedReader(inputStreamReader);
        
        //Get source string
        String srcStr = null;  
        try{  
            srcStr = bufferReader.readLine();
        }catch(IOException e){  
            e.printStackTrace();  
        }
        //Get destination string
        String dstStr = null;
        System.out.print("please input dst String: ");
        try{  
            dstStr = bufferReader.readLine();
        }catch(IOException e){  
            e.printStackTrace();  
        }
        
        //Display the result
        System.out.println("Edit Distance is: " 
        		+ getEditDistance(srcStr, dstStr));
        
        try{  
            bufferReader.close();  
            inputStreamReader.close();  
            inputStream.close();  
        }catch(IOException e){  
            e.printStackTrace();  
        }  
	}
	
	public static int getEditDistance(String srcStr, String dstStr){
		int m = srcStr.length();
		int n = dstStr.length();
		//use one dimension array to represent two dimension
		//Initializing...
		int d[] = new int[(m + 1) * (n + 1)];
		for(int i = 0;i <= m;i++)
			d[i * (n + 1)] = i;
		for(int i = 0;i <= n;i++)
			d[i] = i;
		
		//Dynamic Programming...
		for(int i = 1; i <= m;i++){
			for(int j = 1; j <= n;j++){
				int modifyDis = d[(i - 1) * (n + 1) + (j - 1)]
				          + (srcStr.charAt(i - 1) == dstStr.charAt(j - 1) ? 0 : 1);
				int addDis = d[(i - 1) * (n + 1) + j] + 1;
				int deleteDis = d[i * (n + 1) + (j - 1)] + 1;
				d[i * (n + 1) + j] = Min(modifyDis, addDis, deleteDis);
			}
		}
		
		//Display Result
		System.out.println("Result Array: ");
		for(int i = 0; i <= m;i++){
			for(int j = 0; j <= n;j++){
				System.out.print("\t" + d[i * (n + 1) + j]);
			}
			System.out.println();
		}
		
		return d[m * (n + 1) + n];
	}
	
	public static int Min(int a, int b, int c){
		int result = a > b ? b : a;
		return result > c ? c : result;
	}
}

输出测试：