Delete Operation for Two Strings - Practice Coding Problems

Delete Operation for Two Strings - Problem

Given two strings word1 and word2, you need to find the minimum number of deletion operations required to make both strings identical.

In one operation, you can delete exactly one character from either string. Your goal is to transform both strings into the same final string using the fewest possible deletions.

Example: If word1 = "sea" and word2 = "eat", you can delete 's' from "sea" and 't' from "eat" to get "ea" in both cases, requiring 2 deletions total.

The key insight is that the optimal solution preserves the longest common subsequence between the two strings, as these characters don't need to be deleted from either string.

Input & Output

example_1.py — Basic Case

$ Input: word1 = "sea", word2 = "eat"

› Output: 2

💡 Note: Delete 's' from "sea" to get "ea", and delete 't' from "eat" to get "ea". Both strings become "ea" with 2 total deletions.

example_2.py — Identical Strings

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

› Output: 0

💡 Note: Both strings are already identical, so no deletions are needed.

example_3.py — No Common Characters

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

› Output: 6

💡 Note: No characters match, so we must delete all 3 characters from "abc" and all 3 characters from "xyz" to get empty strings.

Visualization

Tap to expand

Understanding the Visualization

Initialize Base Cases

First row and column represent cost of making one string empty

Compare Characters

When characters match, copy diagonal value (no deletion needed)

Handle Mismatches

When characters differ, choose minimum cost path

Trace Solution

Bottom-right cell contains the minimum total deletions

Key Takeaway

🎯 Key Insight: Dynamic programming efficiently computes the longest common subsequence, which minimizes total deletions by maximizing preserved characters.

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Fill each cell in the m×n table exactly once

✓ Linear Growth

Space Complexity

O(m×n)

2D DP table stores results for all subproblems

⚡ Linearithmic Space

Constraints

1 ≤ word1.length, word2.length ≤ 500
word1 and word2 consist of only lowercase English letters
The answer will always fit in a 32-bit integer

Asked in

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

The optimal approach uses dynamic programming to build a 2D table where each cell dp[i][j] represents the minimum deletions needed to make the first i characters of word1 identical to the first j characters of word2. The key insight is that when characters match, we inherit the solution from the diagonal (no extra cost), otherwise we take the minimum of deleting from either string plus 1. This gives us O(mn) time and space complexity, which is optimal for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(m×n)	O(m×n)	Build optimal solutions using tabular dynamic programming

Dynamic Programming (Bottom-Up) — Algorithm Steps

Create 2D DP table of size (m+1) x (n+1)
Initialize base cases: dp[i][0] = i and dp[0][j] = j
For each cell, if characters match: dp[i][j] = dp[i-1][j-1]
If characters don't match: dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1])
Return dp[m][n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Cases

Fill first row and column with deletion costs

Compare Characters

If characters match, inherit diagonal value

Handle Mismatches

Take minimum of left and top cell, add 1

Final Answer

Bottom-right cell contains minimum deletions

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

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;
    }
    for (int j = 0; j <= n; j++) {
        dp[0][j] = j;
    }
    
    // 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];
            } else {
                dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1]);
            }
        }
    }
    
    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[1000], word2[1000];
    fgets(word1, sizeof(word1), stdin);
    fgets(word2, sizeof(word2), stdin);
    
    // Remove newlines and quotes
    word1[strcspn(word1, "\n")] = 0;
    word2[strcspn(word2, "\n")] = 0;
    if (word1[0] == '"') {
        memmove(word1, word1 + 1, strlen(word1));
        word1[strlen(word1) - 1] = 0;
    }
    if (word2[0] == '"') {
        memmove(word2, word2 + 1, strlen(word2));
        word2[strlen(word2) - 1] = 0;
    }
    
    printf("%d\n", minDistance(word1, word2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Fill each cell in the m×n table exactly once

✓ Linear Growth

Space Complexity

O(m×n)

2D DP table stores results for all subproblems

⚡ Linearithmic Space

Constraints

1 ≤ word1.length, word2.length ≤ 500
word1 and word2 consist of only lowercase English letters
The answer will always fit in a 32-bit integer

67.2K 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 (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler