Distinct Subsequences

Distinct Subsequences - Problem

Given two strings s and t, return the number of distinct subsequences of s which equals t.

A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ACE" is a subsequence of "ABCDE" while "AEC" is not).

The test cases are generated so that the answer fits on a 32-bit signed integer.

Input & Output

Example 1 — Basic Case

$ Input: s = "rabbbit", t = "rabbit"

› Output: 3

💡 Note: There are 3 ways to form "rabbit" from "rabbbit": r-a-b-b-b-i-t (skip 1st b), r-a-b-b-b-i-t (skip 2nd b), r-a-b-b-b-i-t (skip 3rd b)

Example 2 — No Match

$ Input: s = "babgbag", t = "bag"

› Output: 5

💡 Note: Five ways to form "bag": b-a-g(1st), b-a-g(2nd), b-a-g(3rd), b-a-g(4th), b-a-g(5th) using different combinations of b, a, g characters

Example 3 — Edge Case

$ Input: s = "abc", t = "def"

› Output: 0

💡 Note: No characters match between s and t, so no subsequences of s can form t

Constraints

1 ≤ s.length, t.length ≤ 1000
s and t consist of English letters only

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 F Facebook 15 M Microsoft 12

The key insight is recognizing this as a classic DP problem where we count ways to match subsequences. When characters match, we can either include or exclude them, leading to overlapping subproblems. Best approach is 2D Dynamic Programming with optional space optimization. Time: O(n×m), Space: O(m) optimized.

Common Approaches

✓ 2D Dynamic Programming

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

Build a 2D table where dp[i][j] represents the number of ways to form t[0:j] using s[0:i]. Fill the table iteratively from base cases.

Recursive Brute Force

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

For each character in s, we have two choices: include it in our subsequence or skip it. We recursively explore both options and count valid subsequences that match t.

Space-Optimized DP

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

Since we only need the previous row to compute the current row, we can optimize space by using just two 1D arrays or even a single array with careful updating.

Top-Down with Memoization

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

Same recursive logic as brute force, but we cache results for each (i, j) state to avoid recalculating the same subproblems multiple times.

2D Dynamic Programming — Algorithm Steps

Create dp table of size (n+1) × (m+1)
Initialize base cases: dp[i][0] = 1 for all i
Fill table: if s[i-1] == t[j-1], dp[i][j] = dp[i-1][j-1] + dp[i-1][j]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base cases: dp[i][0] = 1

Fill Table

For each cell, add ways from skipping + including if match

Result

Bottom-right cell contains final count

Code -

solution.c — C

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

int solution(char* s, char* t) {
    int n = strlen(s), m = strlen(t);
    int dp[n+1][m+1];
    
    // Initialize
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            dp[i][j] = 0;
        }
    }
    
    // Base case: empty t can be formed in one way
    for (int i = 0; i <= n; i++) {
        dp[i][0] = 1;
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            dp[i][j] = dp[i-1][j];  // Skip s[i-1]
            if (s[i-1] == t[j-1]) {
                dp[i][j] += dp[i-1][j-1];  // Include s[i-1]
            }
        }
    }
    
    return dp[n][m];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Fill each cell in the n×m table exactly once

✓ Linear Growth

Space Complexity

O(n×m)

2D DP table of size (n+1) × (m+1) where n=len(s), m=len(t)

✓ Linear Space

78.0K Views

Medium Frequency

~25 min Avg. Time

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