Delete Operation for Two Strings

Delete Operation for Two Strings - Problem

Given two strings word1 and word2, return the minimum number of steps required to make word1 and word2 the same.

In one step, you can delete exactly one character in either string.

The goal is to find the minimum number of deletions needed so that both strings become identical.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Delete 's' from word1 and 't' from word2 to make both strings "ea". Total: 2 deletions.

Example 2 — No Common Characters

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

› Output: 6

💡 Note: No common characters, so delete all 3 characters from word1 and all 3 from word2. Total: 6 deletions.

Example 3 — Identical Strings

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

› Output: 0

💡 Note: Strings are already identical, no deletions needed.

Constraints

1 ≤ word1.length, word2.length ≤ 500
word1 and word2 consist of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is to find the longest common subsequence (LCS) between both strings and delete everything else. The minimum deletions needed equals the total length of both strings minus twice the LCS length. Best approach uses 2D dynamic programming or LCS-based solution. Time: O(m×n), Space: O(min(m,n)) with optimization.

Common Approaches

✓ 2D Dynamic Programming

⏱️ Time: O(m×n) Space: O(m×n)

Build a 2D DP table where dp[i][j] represents the minimum deletions needed to make word1[0:i] and word2[0:j] equal. Fill the table bottom-up using the recurrence relation based on character matches.

LCS-Based Approach

⏱️ Time: O(m×n) Space: O(min(m,n))

The key insight is that we want to keep the longest common subsequence (LCS) and delete everything else. Total deletions = (length of word1 - LCS) + (length of word2 - LCS). We can find LCS using space-optimized DP.

Memoized Recursion

⏱️ Time: O(m×n) Space: O(m×n)

Same recursive approach as brute force, but we store results of subproblems in a memoization table. This eliminates redundant calculations and reduces time complexity significantly.

Recursive Brute Force

⏱️ Time: O(2^(m+n)) Space: O(m+n)

For each position in both strings, we have three choices: delete from word1, delete from word2, or keep both characters if they match. We recursively explore all possibilities and return the minimum deletions needed.

2D Dynamic Programming — Algorithm Steps

Create DP table with base cases
Fill table using recurrence relation
If characters match, take diagonal value
If different, take minimum of left/top + 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Cases

Fill last row and column with remaining characters

Fill Table

Work backwards using recurrence relation

Get Answer

dp[0][0] contains the minimum deletions needed

Code -

solution.c — C

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

int solution(char* word1, char* word2) {
    int m = strlen(word1), n = strlen(word2);
    int** dp = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (int*)malloc((n + 1) * sizeof(int));
    }
    
    // Base cases
    for (int i = 0; i <= m; i++) {
        dp[i][n] = m - i;
    }
    for (int j = 0; j <= n; j++) {
        dp[m][j] = n - j;
    }
    
    // Fill DP table
    for (int i = m - 1; i >= 0; i--) {
        for (int j = n - 1; j >= 0; j--) {
            if (word1[i] == word2[j]) {
                dp[i][j] = dp[i + 1][j + 1];
            } else {
                dp[i][j] = 1 + (dp[i + 1][j] < dp[i][j + 1] ? dp[i + 1][j] : dp[i][j + 1]);
            }
        }
    }
    
    int result = dp[0][0];
    
    // Free memory
    for (int i = 0; i <= m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char word1[1001], word2[1001];
    fgets(word1, sizeof(word1), stdin);
    fgets(word2, sizeof(word2), stdin);
    word1[strcspn(word1, "\n")] = 0;
    word2[strcspn(word2, "\n")] = 0;
    int result = solution(word1, word2);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Fill m×n DP table with constant work per cell

✓ Linear Growth

Space Complexity

O(m×n)

DP table stores values for all string position combinations

⚡ Linearithmic Space

78.5K Views

Medium Frequency

~25 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler