Count Number of Special Subsequences

Count Number of Special Subsequences - Problem

A sequence is special if it consists of a positive number of 0s, followed by a positive number of 1s, then a positive number of 2s.

For example, [0,1,2] and [0,0,1,1,1,2] are special.

In contrast, [2,1,0], [1], and [0,1,2,0] are not special.

Given an array nums (consisting of only integers 0, 1, and 2), return the number of different subsequences that are special. Since the answer may be very large, return it modulo 10⁹ + 7.

A subsequence of an array is a sequence that can be derived from the array by deleting some or no elements without changing the order of the remaining elements. Two subsequences are different if the set of indices chosen are different.

Input & Output

Example 1 — Basic Special Sequence

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

› Output: 1

💡 Note: The only subsequence is [0,1,2] itself, which follows the pattern: one 0, then one 1, then one 2.

Example 2 — Multiple Valid Subsequences

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

› Output: 7

💡 Note: Valid subsequences: [0,1,2], [0,1,1,2], [0,0,1,2], [0,0,1,1,2], [0,1,2] (second 0 with first 1), [0,1,2] (first 0 with second 1), [0,1,2] (second 0 with second 1).

Example 3 — No Valid Subsequences

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

› Output: 0

💡 Note: No subsequence can follow the required pattern of 0s→1s→2s since elements are in reverse order.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0, 1, or 2

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12 G Google 8

The key insight is to use dynamic programming to track three states: subsequences ending with 0s only, 0s+1s, and complete 0s+1s+2s sequences. Best approach is DP with O(n) time and O(1) space.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force - Generate All Subsequences

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

Generate every possible subsequence of the array using bit manipulation or recursion. For each subsequence, check if it follows the pattern: some 0s, then some 1s, then some 2s. Count all valid subsequences.

Dynamic Programming - Count Valid States

⏱️ Time: O(n) Space: O(1)

Track three states: count of subsequences ending with 0s only, ending with 0s+1s, and ending with 0s+1s+2s (complete special sequences). For each element, update the counts based on what we can append to existing subsequences.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007

int countSpecialSubsequences(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    // dp[i] represents count of subsequences ending with digit i
    long long dp[3] = {0, 0, 0};
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 0) {
            // We can either start new subsequence with this 0
            // or extend existing subsequences ending with 0
            dp[0] = (dp[0] * 2 + 1) % MOD;
        }
        else if (nums[i] == 1) {
            // We can extend subsequences ending with 0 to end with 1
            // or extend existing subsequences ending with 1
            dp[1] = (dp[1] * 2 + dp[0]) % MOD;
        }
        else if (nums[i] == 2) {
            // We can extend subsequences ending with 1 to end with 2
            // or extend existing subsequences ending with 2
            dp[2] = (dp[2] * 2 + dp[1]) % MOD;
        }
    }
    
    return (int)dp[2];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array format [1,2,3]
    int nums[100000];
    int numsSize = 0;
    
    // Find the opening bracket
    char* ptr = strchr(line, '[');
    if (!ptr) {
        printf("0\n");
        return 0;
    }
    ptr++; // Skip '['
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            nums[numsSize++] = *ptr - '0';
        }
        ptr++;
    }
    
    int result = countSpecialSubsequences(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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