LeetCode OJ算法题（七十二）：Edit Distance

题目：

Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

a) Insert a character
b) Delete a character
c) Replace a character

解法：

一开始我是想先找到两个字符串之间最多的公用字符，然后将较长删除一些字符后，再把不同的字符用replace处理，就可以得到较小的字符串了，结果发现这个公共字符集相当难找，因为他们可以不连续，而且无顺序。比如abcd和ecbf，如果不考虑顺序，他们的编辑距离是2，但是实际上应该有顺序，他们实际的编辑距离应该是4（删除e，c换成a，f换成c，插入d）（也可以有其他的做法）。

参考网上大神们的思路，发现这题也可以用动态规划，关键是需要找到递推的关系。

设word1 = “a1，a2，a3，......ai”，word2 = “b1，b2，b3，......bj”。他们之间的编辑距离设为f（i，j），下面开始讨论：

1）如果ai == bj，那么很显然，有f（i，j）= f（i-1，j-1）；

2）如果ai != bj，对于元素ai，我们的操作可能使删除ai，或者是将ai替换成另外一个需要的值。如果是删除，那么f(i，j)=f(i-1，j)+1；如果是替换，那么f(i，j)=f(i-1，j-1)+1。

对于元素bi，一样我们可能的操作时删除还有替换，那么f(i，j)=f(i，j-1)+1或者f(i，j)=f(i-1，j-1)+1。

因此，递推关系很明显就是上述四个式子（其实是三个）最小的那一个，即f[i][j] = min(f[i-1][j]+1, f[i][j-1]+1, f[i-1][j-1]+1);

我们这里没有提到插入是因为对word1插入等效于对word2删除。

接下来的步骤就是考虑边界条件，即i=1，或者j=1时。我们以i=1为例：

word1 = a1，word2 = “b1，b2，b3，......bj”，假设bx=a1，那么f（1,1）到f（1，x-1）（通项即为f（1，n））都是删除第1~n-1个字符，然后把bn替换为a1，所以f（1，n）=n；从f（1，x）到f（1，j）都是只用把bx以外的元素删除即可，因此f（1，n）=n-1。

代码如下：

public class No72_EditDistance {
	public static void main(String[] args){
		System.out.println(minDistance("abcd", "ecbf"));
	}
	public static int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        int[][] result = new int[m][n];
        boolean hasSame = false;
        for(int i=0;i<m;i++){
        	result[i][0] = i+1;
        	if(word1.charAt(i) == word2.charAt(0))
        		hasSame = true;
        	if(hasSame) result[i][0]--;
        }
        hasSame = false;
        for(int j=0;j<n;j++){
        	result[0][j] = j+1;
        	if(word1.charAt(0) == word2.charAt(j))
        		hasSame = true;
        	if(hasSame) result[0][j]--;
        }
        for(int i=1;i<m;i++){
        	for(int j=1;j<n;j++){
        		if(word1.charAt(i) == word2.charAt(j))
        			result[i][j] = result[i-1][j-1];
        		else 
        			result[i][j] = min(result[i-1][j]+1, result[i][j-1]+1, result[i-1][j-1]+1);
        	}
        }
        return result[m-1][n-1];
    }
	public static int min(int a, int b, int c){
		return a<b?(a<c?a:c):(b<c?b:c);
	}
}