【leetcode】 Edit Distance

最新推荐文章于 2020-06-22 10:16:26 发布

原创最新推荐文章于 2020-06-22 10:16:26 发布 · 413 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

222 篇文章

订阅专栏

本文详细介绍了解决编辑距离问题的动态规划算法，通过实例演示如何计算两个字符串间的最小编辑距离，并提供C++及Java代码实现。

From：https://leetcode.com/problems/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

Hide Tags

Dynamic Programming String

Hide Similar Problems

(M) One Edit Distance

Solution ：

参考：http://www.cnblogs.com/lihaozy/archive/2012/12/31/2840152.html

定义从字符串a变到字符串b，所需要的最少的操作步骤（插入，删除，更改）为两个字符串之间的编辑距离。

例子，两个字符串eeba和abca相似度是多少呢，edit distance是一个很好的度量。

对于eeba, abca它们之间的编辑距离为3，可以按照上面的操作步骤（不是唯一的）将eeba变到abca，

1.将e变为a

2.删除e

3.添加c

典型的动态规划问题。

EDIT[i,j]表示对于字符串a从1到i的子串和字符串b从1到j的字串的编辑距离。（字符串下标从1开始)

1.EDIT[i - 1,j] + 1 ：表示对a 在i 位置删除delete操作

2.EDIT[i,j - 1] + 1 ：表示insert添加操作

3.EDIT[i-1, j - 1] + f(x[i],y[j]) ：这里如果x[i]==y[j] ,无操作,f(x[i],y[j])=0 ; 否则,f(x[i],y[j])=1, modify操作。

理解：1.中， i-1 与 j 对应到 i 与 j 对应，说明将a中的i直接删除了； 2.中，i 与 j-1对应到 i 与 j对应，说明b中j在a的i处没有对应，所以是a插入了一个与b的j位置对应。

递归的base line如下图：

如果需要记录编辑过程如第一幅图所示，需要用二维数组记录下动态规划过程的路径信息，即记录下前一步骤的位置索引信息。

如下图

过程：

代码：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.size(), len2 = word2.size();
        vector<vector<int>> table(len1+1, vector<int>(len2+1));
        for(int i=0; i<=len1; i++) {
            table[i][0] = i;
        }
        for(int j=0; j<=len2; j++) {
            table[0][j] = j;
        }
        
        for(int i=1; i<=len1; i++) {
            for(int j=1; j<=len2; j++) {
                table[i][j] = min(table[i-1][j-1]+(word1[i-1]!=word2[j-1]), min(table[i-1][j]+1, table[i][j-1]+1));
            }
            
        }
        
        return table[len1][len2];
    }
};

public class Solution {
    public int minDistance(String s1, String s2) {
        if(s1 == null && s2 == null) {
            return 0;
        } else if(s1 == null) {
            return s2.length();
        } else if(s2 == null) {
            return s1.length();
        }
        
        int n1 = s1.length(), n2 = s2.length();
        int[][] dist = new int[n1+1][n2+1];
        for(int i=0; i<=n1; ++i) {
            dist[i][0] = i;
        }
        for(int i=1; i<=n2; ++i) {
            dist[0][i] = i;
        }
        
        for(int i=1; i<=n1; ++i) {
            for(int j=1; j<=n2; ++j) {
                int t = s1.charAt(i-1)==s2.charAt(j-1)?0:1;
                dist[i][j] = min(dist[i][j-1]+1, dist[i-1][j]+1, dist[i-1][j-1]+t);
            }
        }
        
        return dist[n1][n2];
    }
    
    private int min(int a, int b, int c) {
        if(a < b) {
            if(a < c) {
                return a;
            }
        } else {
            if(b < c) {
                return b;
            }
        }
        return c;
    }
}