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
time limit exceeded

class Solution {
public:
    int
 
 minDistance(string word1, string word2) {
        size_t len1 = word1.size();
        size_t len2 = word2.size();
        if (len1 == 0) return len2;
        if (len2 == 0) return len1;
        int ret = max(len1, len2);
        if (word1[0] == word2[0]) {
            ret = min(ret, minDistance(string(word1.begin() + 1
 
, word1.end()), string(word2.begin() + 1, word2.end())));
        } else {
            ret = min(ret, 1 + minDistance(string(word1.begin() + 1, word1.end()), string(word2.begin() + 1, word2.end()))); // replace
            ret = min(ret, 1 + minDistance(string(word1.begin() + 1, word1.end()), word2)); // insert;
 

            ret = min(ret, 1 + minDistance(word1, string(word2.begin() + 1, word2.end()))); // delete
        }
        return ret;
    }
};

這個題自己沒有做出來， 沒有想到動態規劃，可見還是對動態規劃演算法的理解不夠深入。
參考後

class Solution {
public:
    int minDistance(string word1, string word2) {
        size_t r = word1.size();
        size_t c = word2.size();
        vector<vector<int> > dp(r + 1, vector<int>(c + 1, 0));
        for (size_t i = 0; i <= r; ++i) {
            dp[i][0] = i;
        }

        for (size_t i = 1; i <= c; ++i) {
            dp[0][i] = i;
        }

        for (size_t i = 0; i != r; ++i) { // word1
            for (size_t j = 0; j != c; ++j) { // word2
                if (word1[i] == word2[j]) {
                    dp[i + 1][j + 1] = dp[i][j];
                } else {
                    // insert dp[i + 1][j + 1] = dp[i + 1][j] + 1;
                    // delete dp[i + 1][j + 1] = dp[i][j + 1] + 1;
                    // replace dp[i + 1][j + 1] = dp[i][j] + 1;

                    dp[i + 1][j + 1] = min(dp[i + 1][j] + 1, dp[i][j + 1] +  1);
                    dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + 1);
                }
            }
        }
        return dp[r][c];
    }
};