Longest Common Subsequence - Practice Coding Problems

Longest Common Subsequence - Problem

The Longest Common Subsequence Problem

You're given two strings text1 and text2. Your mission is to find the longest common subsequence between them and return its length.

🔍 What's a subsequence?
A subsequence is formed by deleting some (possibly zero) characters from the original string while keeping the remaining characters in their original order. For example, "ace" is a subsequence of "abcde".

🎯 What's a common subsequence?
It's a subsequence that appears in both strings. The longest one is what we're after!

Examples:
• "abcde" and "ace" → LCS = "ace" (length 3)
• "abc" and "abc" → LCS = "abc" (length 3)
• "abc" and "def" → No common subsequence (length 0)

Return the length of the longest common subsequence, or 0 if none exists.

Input & Output

example_1.py — Basic Common Subsequence

$ Input: text1 = "abcde", text2 = "ace"

› Output: 3

💡 Note: The longest common subsequence is "ace" with length 3. We can form "ace" from both strings by selecting appropriate characters while maintaining order.

example_2.py — Different Characters

$ Input: text1 = "abc", text2 = "abc"

› Output: 3

💡 Note: When both strings are identical, the entire string is the longest common subsequence. Length is 3.

example_3.py — No Common Characters

$ Input: text1 = "abc", text2 = "def"

› Output: 0

💡 Note: There are no common characters between the strings, so the longest common subsequence has length 0.

Visualization

Tap to expand

Understanding the Visualization

Set Up Laboratory Grid

Create a grid where each cell represents comparing characters from both DNA sequences

Compare Gene by Gene

When genes match, extend the best previous alignment. Record the improved match length.

Handle Mismatches

When genes don't match, take the better result from either skipping current gene in sequence 1 or sequence 2

Find Optimal Alignment

The bottom-right cell contains the length of the longest common genetic sequence

Key Takeaway

🎯 Key Insight: Dynamic Programming transforms an exponential problem into polynomial time by storing intermediate results. Each cell builds upon previous optimal solutions, ensuring we find the globally optimal answer efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We fill each cell of the m×n DP table exactly once

✓ Linear Growth

Space Complexity

O(m × n)

Space for the 2D DP table of size (m+1)×(n+1)

⚡ Linearithmic Space

Constraints

1 ≤ text1.length, text2.length ≤ 1000
text1 and text2 consist of only lowercase English characters.
Time limit: 2 seconds
Space limit: 256 MB

Asked in

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

The optimal solution uses Dynamic Programming with a 2D table. For each position, we either extend a previous match when characters are equal, or take the maximum from adjacent cells. Time complexity: O(m×n), Space: O(m×n). The DP approach efficiently builds up the solution by solving smaller subproblems first.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (2D Table)	O(m × n)	O(m × n)	Build optimal solutions using a 2D DP table

Dynamic Programming (2D Table) — Algorithm Steps

Create a DP table of size (m+1) × (n+1) initialized with zeros
For each character in text1 and text2, compare them
If characters match: dp[i][j] = dp[i-1][j-1] + 1
If they don't match: dp[i][j] = max(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 DP Table

Create (m+1)×(n+1) table with zeros

Fill Table

For matching characters: dp[i][j] = dp[i-1][j-1] + 1

Handle Mismatches

For non-matching: dp[i][j] = max(dp[i-1][j], dp[i][j-1])

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int longestCommonSubsequence(char* text1, char* text2) {
    int m = strlen(text1), n = strlen(text2);
    
    // Create DP table
    int** dp = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        dp[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    // Fill the DP table
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (text1[i-1] == text2[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
            } else {
                dp[i][j] = max(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 text1[1001], text2[1001];
    fgets(text1, sizeof(text1), stdin);
    fgets(text2, sizeof(text2), stdin);
    
    // Remove newlines and quotes
    text1[strcspn(text1, "\n")] = 0;
    text2[strcspn(text2, "\n")] = 0;
    if (text1[0] == '"') memmove(text1, text1+1, strlen(text1));
    if (text1[strlen(text1)-1] == '"') text1[strlen(text1)-1] = 0;
    if (text2[0] == '"') memmove(text2, text2+1, strlen(text2));
    if (text2[strlen(text2)-1] == '"') text2[strlen(text2)-1] = 0;
    
    printf("%d\n", longestCommonSubsequence(text1, text2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We fill each cell of the m×n DP table exactly once

✓ Linear Growth

Space Complexity

O(m × n)

Space for the 2D DP table of size (m+1)×(n+1)

⚡ Linearithmic Space

Constraints

1 ≤ text1.length, text2.length ≤ 1000
text1 and text2 consist of only lowercase English characters.
Time limit: 2 seconds
Space limit: 256 MB

125.0K Views

Very High Frequency

~15 min Avg. Time

2.9K 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