[LintCode] 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:

• Insert a character
• Delete a character
• Replace a character

Example

Given word1 = "mart" and word2 = "karma", return 3.

 

Solution 1. Recursion 

i is the last character's index in word1, j is the last character's index in word2.

Recursive functions:

f(i, j) = Math.min(1 + Math.min(f (i - 1, j), f(i, j - 1) ),   f(i - 1, j - 1)),  if word1.charAt(i) == word2.charAt(j);

f(i, j) = Math.min(1 + Math.min(f (i - 1, j), f(i, j - 1) ),   1 + f(i - 1, j - 1)), if word1.charAt(i) != word2.charAt(j);

 

Base case:

i < 0 && j < 0: both words are empty, no operations is needed;

i < 0 && j >= 0: word1 empty but word2 not empty, j + 1 deletions is needed;

i >= 0 && j < 0: word1 not empty word2 empty, i + 1 deletions is needed;

 

public class Solution {
    public int minDistance(String word1, String word2) {
        if(word1 == null || word2 == null){
            return Integer.MAX_VALUE;
        }
        return helper(word1, word1.length() - 1, word2, word2.length() - 1);
    }
    private int helper(String word1, int idx1, String word2, int idx2){
        if(idx1 < 0 && idx2 < 0){
            return 0;
        }
        else if(idx1 < 0){
            return idx2 + 1;
        }
        else if(idx2 < 0){
            return idx1 + 1;
        }
        if(word1.charAt(idx1) == word2.charAt(idx2)){
            return Math.min(1 + Math.min(helper(word1, idx1- 1, word2, idx2), helper(word1, idx1, word2, idx2 - 1)), helper(word1, idx1 - 1, word2, idx2 - 1));
        }
        return Math.min(1 + Math.min(helper(word1, idx1- 1, word2, idx2), helper(word1, idx1, word2, idx2 - 1)), 1 + helper(word1, idx1 - 1, word2, idx2 - 1));
    }
}

 

Solution 2. Top down DFS search with Memoization, (Dynamic Programming in essence)

Solution 1 does a lot of duplicate work by computing answers of the same subproblems over and over.

Caching subproblems' results with memoization optimizes on solution 1. 

 

public class Solution {
    private int[][] T;
    public int minDistance(String word1, String word2) {
        if(word1 == null || word2 == null){
            return Integer.MAX_VALUE;
        }
        T = new int[word1.length()][word2.length()]; 
        for(int i = 0; i < word1.length(); i++){
            for(int j = 0; j < word2.length(); j++){
                T[i][j] = Integer.MAX_VALUE;
            }
        }
        return helper(word1, word1.length() - 1, word2, word2.length() - 1);
    }
    private int helper(String word1, int idx1, String word2, int idx2){
        if(idx1 < 0 && idx2 < 0){
            return 0;
        }
        else if(idx1 < 0){
            return idx2 + 1;
        }
        else if(idx2 < 0){
            return idx1 + 1;
        }
        if(T[idx1][idx2] != Integer.MAX_VALUE){
            return T[idx1][idx2];
        }
        int r = Integer.MAX_VALUE;
        if(word1.charAt(idx1) == word2.charAt(idx2)){
            r = Math.min(1 + Math.min(helper(word1, idx1- 1, word2, idx2), helper(word1, idx1, word2, idx2 - 1)), helper(word1, idx1 - 1, word2, idx2 - 1));
        }
        else{
            r = Math.min(1 + Math.min(helper(word1, idx1- 1, word2, idx2), helper(word1, idx1, word2, idx2 - 1)), 1 + helper(word1, idx1 - 1, word2, idx2 - 1));            
        }
        T[idx1][idx2] = r;
        return r;
    }
}

 

Solution 3. Bottom up dynamic programming

State functions are derived directly from the above recursive solution. 

dp[i][j]: the minimum number of operations needed to covert word1's first ith characters to word2's first jth characters.

Function: 

if(word1.charAt(i - 1) == word2.charAt(j - 1)){
    dp[i][j] = Math.min(1 + Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]);
}
else{
    dp[i][j] = 1 + Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]);
}

　　

Initializations:

dp[i][0]: delete a character from word1 i times;

dp[0][j]: insert a character to word1 j times;

 

public class Solution {
    public int minDistance(String word1, String word2) {
        if(word1 == null || word2 == null){
            return Integer.MAX_VALUE;
        }
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        dp[0][0] = 0;
        for(int i = 1; i <= word1.length(); i++){
            dp[i][0] = i;
        }
        for(int j = 1; j <= word2.length(); j++){
            dp[0][j] = j;
        }
        for(int i = 1; i <= word1.length(); i++){
            for(int j = 1; j <= word2.length(); j++){
                if(word1.charAt(i - 1) == word2.charAt(j - 1)){
                    dp[i][j] = Math.min(1 + Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]);
                }
                else{
                    dp[i][j] = 1 + Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]);
                }
            }
        }
        return dp[word1.length()][word2.length()];
    }
}

 

Related Problems

Edit Distance II