72. Edit Distance

Hard
Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.
You have the following 3 operations permitted on a word:
  1. Insert a character
  2. Delete a character
  3. Replace a character
Example 1:
Input: word1 = "horse", word2 = "ros"
Output: 3
Explanation: 
horse -> rorse (replace 'h' with 'r')
rorse -> rose (remove 'r')
rose -> ros (remove 'e')
Example 2:
Input: word1 = "intention", word2 = "execution"
Output: 5
Explanation: 
intention -> inention (remove 't')
inention -> enention (replace 'i' with 'e')
enention -> exention (replace 'n' with 'x')
exention -> exection (replace 'n' with 'c')
exection -> execution (insert 'u')
Solution:
  1. i = 0, when first string is empty, only option to insert all  characters of second string.
  2. j = 0; when second string is empty, only option to delete all character of the first string
  3. dp(i,j) = dp(i-1,j-1) when str1[i] == str2[j]
  4. dp(i,j) = dp(i-1,j) + 1 //delete 
  5.               dp(i-1,j) + 1 //insert
  6.               dp(i-1,j-1) + 1 //replace

    public int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        int[][] dp = new int[m+1][n+1];
        for(int i = 1; i <= m; i++){
            dp[i][0] = i;//delete
        }
        for(int j = 1; j <= n; j++){
            dp[0][j] = j;//insert
        }
        
        for(int i = 1; i <= m; i++){
            for(int j = 1; j <=n; j++){
                if(word1.charAt(i-1) == word2.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    dp[i][j] = Math.min(dp[i-1][j] + 1, dp[i][j-1] + 1);
                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j-1] + 1);
                    
                }
            }
        }
        return dp[m][n];
    }

Comments

Popular posts from this blog

MockInterview:785. Is Graph Bipartite?

geeksforgeeks:findFind zeroes to be flipped so that number of consecutive 1’s is maximized

94.Binary Tree Inorder Traversal