leetcode-72-编辑距离

题目描述：

 

 方法：动态规划：

自底向上：

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        n = len(word1)
        m = len(word2)
        dp = [[0 for _ in range(n+1)]for _ in range(m+1)]
        for i in range(m+1):
            dp[i][0] = i
        for i in range(n+1):
            dp[0][i] = i
        for i in range(1,m+1):
            for j in range(1,n+1):
                if word1[j-1] == word2[i-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i-1][j],dp[i-1][j-1],dp[i][j-1]) + 1
        return dp[m][n]

java版：

class Solution {
    public int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        int [][] dp = new int [m+1][n+1];
        if (n*m == 0)
            return n+m;
        for(int i = 0; i < m + 1;i++){
            dp[i][0] = i;
        }
        for(int i = 0; i < n + 1;i++){
            dp[0][i] = i;
        }
        for(int i = 1; i < m + 1;i++){
            for(int j=1;j<n+1;j++){
                int left = dp[i-1][j] + 1;
                int down = dp[i][j -1] +1;
                int left_down = dp[i-1][j-1];
                if (word1.charAt(i-1)!=word2.charAt(j-1))
                    left_down += 1;
                dp[i][j] = Math.min(left,Math.min(down,left_down));
            }
        }
        return dp[m][n];
    }
}

 

自顶向下：

from functools import lru_cache
class Solution:
    @lru_cache(None)
    def minDistance(self, word1: str, word2: str) -> int:
        if not word1 or not word2:
            return len(word1) + len(word2)
        if word1[0] == word2[0]:
            return self.minDistance(word1[1:],word2[1:])
        else:
            insert = 1 + self.minDistance(word1,word2[1:])
            replace = 1 + self.minDistance(word1[1:],word2[1:])
            remove = 1 + self.minDistance(word1[1:],word2)
            return min(insert,replace,remove)