# Edit Distance LeetCode Solution | Easy Approach Share:

Given two strings `word1` and `word2`, return the minimum number of operations required to convert `word1` to `word2`.

You have the following three operations permitted on a word:

• Insert a character
• Delete a character
• 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')
```

Constraints:

• `0 <= word1.length, word2.length <= 500`
• `word1` and `word2` consist of lowercase English letters.

### Edit Distance Solutions

Time: O(mn)
Space: O(mn)→O(n)

### C++

``````class Solution {
public:
int minDistance(string word1, string word2) {
const int m = word1.length();
const int n = word2.length();
// dp[i][j] := min # of operations to convert word1[0..i) to word2[0..j)
vector<vector<int>> dp(m + 1, vector<int>(n + 1));

for (int i = 1; i <= m; ++i)
dp[i] = i;

for (int j = 1; j <= n; ++j)
dp[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 - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;

return dp[m][n];
}
};
``````

### Java

`````` class Solution {
public int minDistance(String word1, String word2) {
final int m = word1.length();
final int n = word2.length();
// dp[i][j] := min # of operations to convert word1[0..i) to word2[0..j)
int[][] dp = new int[m + 1][n + 1];

for (int i = 1; i <= m; ++i)
dp[i] = i;

for (int j = 1; j <= n; ++j)
dp[j] = j;

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], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;

return dp[m][n];
}
}

``````

### Python

``````class Solution:
def minDistance(self, word1: str, word2: str) -> int:
m = len(word1)
n = len(word2)
# dp[i][j] := min # of operations to convert word1[0..i) to word2[0..j)
dp = [ * (n + 1) for _ in range(m + 1)]

for i in range(1, m + 1):
dp[i] = i

for j in range(1, n + 1):
dp[j] = j

for i in range(1, m + 1):
for j in range(1, n + 1):
if word1[i - 1] == word2[j - 1]:
dp[i][j] = dp[i - 1][j - 1]
else:
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1

return dp[m][n]

``````

#### Watch Tutorial

Checkout more Solutions here