Edit Distance - Practice Coding Problems

Edit Distance - Problem

The Edit Distance problem asks you to find the minimum number of operations needed to transform one string into another. This is also known as the Levenshtein Distance, named after the Russian mathematician who formulated it.

You have exactly three operations at your disposal:
• Insert a character anywhere in the string
• Delete a character from any position
• Replace a character with any other character

For example, to transform "horse" into "ros", you could:
1. Replace 'h' with 'r': "rorse"
2. Delete 'r': "rose"
3. Delete 'e': "ros"

This gives us a minimum edit distance of 3 operations. Your goal is to find the most efficient transformation path.

Input & Output

example_1.py — Basic Transformation

$ Input: word1 = "horse", word2 = "ros"

› Output: 3

💡 Note: To transform "horse" to "ros": 1) Replace 'h' with 'r' → "rorse", 2) Remove 'r' → "rose", 3) Remove 'e' → "ros". Total: 3 operations.

example_2.py — Insert Operations

$ Input: word1 = "intention", word2 = "execution"

› Output: 5

💡 Note: Transform "intention" to "execution": 1) Replace 'i' with 'e', 2) Replace 'n' with 'x', 3) Replace 't' with 'e', 4) Replace 'n' with 'c', 5) Replace 'i' with 'u'. Keep "on" at the end.

example_3.py — Edge Case Empty String

$ Input: word1 = "", word2 = "abc"

› Output: 3

💡 Note: To transform empty string to "abc", we need to insert 3 characters: 'a', 'b', and 'c'.

Visualization

Tap to expand

Understanding the Visualization

Setup the Problem

We have a misspelled word and want to find the minimum keystrokes to correct it

Create Decision Matrix

Build a table where each cell represents the minimum corrections needed for word prefixes

Fill Base Cases

First row: insertions needed, First column: deletions needed

Make Optimal Choices

For each position, choose the cheapest operation: insert, delete, or replace

Key Takeaway

🎯 Key Insight: Build solutions incrementally by considering all possible operations at each step and choosing the optimal path using dynamic programming.

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We fill each cell in the (m+1)×(n+1) table exactly once, where m and n are string lengths

✓ Linear Growth

Space Complexity

O(m×n)

We store the entire 2D DP table of size (m+1)×(n+1)

⚡ Linearithmic Space

Constraints

0 ≤ word1.length, word2.length ≤ 500
word1 and word2 consist of lowercase English letters
Note: Empty strings are allowed as input

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses Dynamic Programming with a 2D table approach. Create a table where dp[i][j] represents the minimum edit distance between the first i characters of word1 and first j characters of word2. When characters match, copy the diagonal value; when they don't match, take the minimum of three adjacent cells (representing insert, delete, replace) and add 1. Time complexity: O(m×n), Space complexity: O(m×n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (2D Table)	O(m×n)	O(m×n)	Build a 2D table to store minimum edit distances for all substring pairs

Dynamic Programming (2D Table) — Algorithm Steps

Create a 2D DP table of size (m+1) × (n+1)
Initialize first row: dp[0][j] = j (inserting j characters)
Initialize first column: dp[i][0] = i (deleting i characters)
For each cell dp[i][j]:
- If characters match: dp[i][j] = dp[i-1][j-1]
- If they don't match: dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
Return dp[m][n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Set up base cases: first row and column represent insertions/deletions

Fill Cell by Cell

For each cell, either copy diagonal (match) or take min of 3 operations + 1

Character Match

When characters match, copy value from diagonal (no operation needed)

Character Mismatch

When characters don't match, take minimum of three adjacent cells and add 1

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int min(int a, int b, int c) {
    int min_val = a;
    if (b < min_val) min_val = b;
    if (c < min_val) min_val = c;
    return min_val;
}

int minDistance(char* word1, char* word2) {
    int m = strlen(word1), n = strlen(word2);
    
    // Create DP table
    int** dp = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (int*)malloc((n + 1) * sizeof(int));
    }
    
    // Initialize base cases
    for (int i = 0; i <= m; i++) {
        dp[i][0] = i;  // Delete all characters from word1
    }
    for (int j = 0; j <= n; j++) {
        dp[0][j] = j;  // Insert all characters to make word2
    }
    
    // Fill the DP table
    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];  // No operation needed
            } else {
                dp[i][j] = 1 + min(
                    dp[i - 1][j],      // Delete from word1
                    dp[i][j - 1],      // Insert to word1
                    dp[i - 1][j - 1]   // Replace in word1
                );
            }
        }
    }
    
    int result = dp[m][n];
    
    // Free memory
    for (int i = 0; i <= m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char word1[501], word2[501];
    scanf("%s %s", word1, word2);
    printf("%d\n", minDistance(word1, word2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We fill each cell in the (m+1)×(n+1) table exactly once, where m and n are string lengths

✓ Linear Growth

Space Complexity

O(m×n)

We store the entire 2D DP table of size (m+1)×(n+1)

⚡ Linearithmic Space

Constraints

0 ≤ word1.length, word2.length ≤ 500
word1 and word2 consist of lowercase English letters
Note: Empty strings are allowed as input

42.3K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (2D Table) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler