Count Number of Special Subsequences - Practice Coding Problems

Count Number of Special Subsequences - Problem

Imagine you're organizing a three-stage tournament where participants must progress through stages in a specific order: Training (0), Qualifying (1), and Championship (2). A special subsequence represents a valid tournament path that includes at least one participant from each stage, in the correct order.

Given an array nums containing only integers 0, 1, and 2 (representing the three tournament stages), your task is to count how many different subsequences form valid tournament paths.

A special subsequence must follow this pattern:

Start with one or more 0s (Training stage)
Follow with one or more 1s (Qualifying stage)
End with one or more 2s (Championship stage)

Examples of valid paths:

[0,1,2] - Basic path through all stages
[0,0,1,1,1,2] - Multiple participants at each stage

Invalid paths:

[2,1,0] - Wrong order
[1] - Missing stages
[0,1,2,0] - Going backwards

Return the total count modulo 10⁹ + 7 since the answer can be very large.

Input & Output

example_1.py — Basic Special Subsequence

$ Input: nums = [0,1,2]

› Output: 1

💡 Note: The only special subsequence is [0,1,2] itself, following the required pattern of 0+ 1+ 2+

example_2.py — Multiple Valid Paths

$ Input: nums = [0,1,2,1,2]

› Output: 5

💡 Note: Valid subsequences are: [0,1,2] (index 0,1,2), [0,1,1,2] (index 0,1,3,4), [0,1,2,2] (index 0,1,2,4), [0,1,1,2] (index 0,1,3,2), [0,1,2,1,2] (all indices). Total count = 5

example_3.py — Edge Case

$ Input: nums = [2,1,0]

› Output: 0

💡 Note: No special subsequences possible since the array is in reverse order. We need at least one 0, followed by at least one 1, followed by at least one 2.

Visualization

Tap to expand

Understanding the Visualization

Training Stage

Count all possible ways to select training participants (0s)

Qualifying Stage

For each training group, count ways to add qualifying participants

Championship Stage

For each training+qualifying group, add championship participants

Valid Paths

Only complete paths through all three stages count as special subsequences

Key Takeaway

🎯 Key Insight: Each element can either extend existing subsequences (doubling the count) or create new ones by combining with the previous stage, leading to an elegant O(n) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only three variables needed to track DP states

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] ∈ {0, 1, 2}
Return result modulo 10⁹ + 7

Asked in

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

The optimal solution uses dynamic programming with three states to count subsequences efficiently. We maintain counters for subsequences ending with 0s, 1s, and 2s. For each element, we either extend existing subsequences or start new ones, using the formula count = count × 2 + previous_state. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track count of subsequences ending at each stage using three DP states
Brute Force (Generate All Subsequences)	O(2^n * n)	O(n)	Generate all possible subsequences and check if each follows the 0→1→2 pattern

Dynamic Programming (Optimal) — Algorithm Steps

Initialize three counters: zeros=0, ones=0, twos=0
For each element in the array:
If element is 0: zeros = (zeros * 2 + 1) % MOD
If element is 1: ones = (ones * 2 + zeros) % MOD
If element is 2: twos = (twos * 2 + ones) % MOD
Return twos as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

Start with zeros=0, ones=0, twos=0

Process Element 0

zeros = zeros*2 + 1 (double existing + new)

Process Element 1

ones = ones*2 + zeros (extend 0-sequences)

Process Element 2

twos = twos*2 + ones (extend 01-sequences)

Code -

solution.c — C

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

#define MOD 1000000007

int numSubseq(int* nums, int n) {
    long long zeros = 0;  // subsequences ending with 0
    long long ones = 0;   // subsequences ending with 1
    long long twos = 0;   // subsequences ending with 2
    
    for (int i = 0; i < n; i++) {
        if (nums[i] == 0) {
            zeros = (zeros * 2 + 1) % MOD;
        } else if (nums[i] == 1) {
            ones = (ones * 2 + zeros) % MOD;
        } else { // nums[i] == 2
            twos = (twos * 2 + ones) % MOD;
        }
    }
    
    return (int)twos;
}

int main() {
    int nums[100000];
    int n = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        nums[n++] = num;
    }
    
    printf("%d\n", numSubseq(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only three variables needed to track DP states

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] ∈ {0, 1, 2}
Return result modulo 10⁹ + 7

42.0K Views

Medium-High Frequency

~25 min Avg. Time

1.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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler