Count the Number of Good Partitions - Problem

You are given a 0-indexed array nums consisting of positive integers.

A partition of an array into one or more contiguous subarrays is called good if no two subarrays contain the same number.

Return the total number of good partitions of nums. Since the answer may be large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,3,4]

› Output: 8

💡 Note: All elements are unique, so we can partition after any position. With 3 possible split points, we have 2³ = 8 ways: [1,2,3,4], [1][2,3,4], [1,2][3,4], [1,2,3][4], [1][2][3,4], [1][2,3][4], [1,2][3][4], [1][2][3][4]

Example 2 — Repeated Elements

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

› Output: 2

💡 Note: Element 2 appears at positions 1 and 3, so we cannot split between them. We can only split after position 0. This gives us 2^1 = 2 valid partitions: [1,2,3,2] and [1][2,3,2]

Example 3 — All Same Elements

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

› Output: 1

💡 Note: Since all elements are the same, we cannot split anywhere. Only one partition possible: [1,1,1,1]

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 32 a Amazon 28

The key insight is that we can only split the array at positions where no element's span (first to last occurrence) would be broken. The optimal approach finds these valid split points and uses the formula 2^k where k is the number of valid splits. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Partitions

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

For each possible way to partition the array, check if any number appears in multiple subarrays. Use bit manipulation to represent all partition points.

Optimal - Combinatorial Analysis

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

Calculate the span (first to last occurrence) of each element. A partition is valid only if we don't split any element's span. Count valid partition points combinatorially.

Brute Force - Try All Partitions — Algorithm Steps

Generate all possible partition combinations
For each partition, check if any number appears in multiple subarrays
Count valid partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Use bit manipulation to create all possible ways to split the array

Check Each Partition

For each partition, verify no number appears in multiple subarrays

Count Valid

Count partitions where all subarrays have unique elements

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    const int MOD = 1000000007;
    int count = 0;
    
    // Try all possible partitions using bit manipulation
    for (int mask = 0; mask < (1 << (numsSize-1)); mask++) {
        int partitions[1000][1000];
        int partitionSizes[1000];
        int numPartitions = 0;
        int start = 0;
        
        // Create partitions based on mask
        for (int i = 0; i < numsSize-1; i++) {
            if (mask & (1 << i)) {
                partitionSizes[numPartitions] = 0;
                for (int j = start; j <= i; j++) {
                    partitions[numPartitions][partitionSizes[numPartitions]++] = nums[j];
                }
                numPartitions++;
                start = i + 1;
            }
        }
        partitionSizes[numPartitions] = 0;
        for (int j = start; j < numsSize; j++) {
            partitions[numPartitions][partitionSizes[numPartitions]++] = nums[j];
        }
        numPartitions++;
        
        // Check if partition is good
        int allNumbers[10001] = {0};
        int isGood = 1;
        
        for (int p = 0; p < numPartitions && isGood; p++) {
            int partitionSet[10001] = {0};
            for (int i = 0; i < partitionSizes[p]; i++) {
                int num = partitions[p][i];
                if (allNumbers[num]) {
                    isGood = 0;
                    break;
                }
                partitionSet[num] = 1;
            }
            if (isGood) {
                for (int i = 0; i < partitionSizes[p]; i++) {
                    allNumbers[partitions[p][i]] = 1;
                }
            }
        }
        
        if (isGood) count++;
    }
    
    return count % MOD;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int size = 0;
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n²)

2^n possible partitions, each taking O(n²) to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current partition and checking duplicates

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Count the Number of Good Partitions - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Partitions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler