583. Delete Operation for Two Strings

Problem statement:

Given two words word1 and word2, find the minimum number of steps required to make word1 and word2 the same, where in each step you can delete one character in either string.

Example 1:

Input: "sea", "eat"
Output: 2
Explanation: You need one step to make "sea" to "ea" and another step to make "eat" to "ea".

Note:

1. The length of given words won't exceed 500.
2. Characters in given words can only be lower-case letters.

Solution:

This is a DP solution which is like 72. Edit Distance. DP array is dp[m + 1][n + 1], m = word1.size(), n = word2.size();

dp[i][j] means how many operations need to do if the first i chars in word1 match the first j chars in word2.

I believe "the first i and j" is essential to understand the key point of the DP solution.

Initialization:

dp[0][0 ... n] = 0 ... n : means the operations we want to match the word1 and word2 if  word1 is empty.

dp[0 ... m][0] = 0 ... m : means the operations we want to match the word1 and word2 if  word2 is empty.

DP formula:

There are two situations for dp[i][j]

word1[i] == word2[j] --> dp[i][j] = dp[i - 1][j - 1] --> no need any operation

word1[i] != word2[j] --> dp[i][j] = min(dp[i -1][j], dp[i][j - 1]) + 1 --> find the optimal value from previous choice.

Return value:

dp[m][n] means operations if word1 and word2 matches.

The time complexity is O(m * n)

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size();
        int n = word2.size();
        int dp[m + 1][n + 1] = {};
        for(int i = 1; i <= m; i++){
            dp[i][0] = i;
        }
        for(int j = 1; j <= n; j++){
            dp[0][j] = j;
        }
        for(int i = 1; i <= m; i++){
            for(int j = 1; j <= n; j++){
                if(word1[i - 1] == word2[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1;
                }
            }
        }
        return dp[m][n];
    }
};