Count the Number of Good Partitions - Practice Coding Problems

Count the Number of Good Partitions - Problem

You are given a 0-indexed array nums consisting of positive integers. Your task is to find all possible ways to partition this array into contiguous subarrays such that no two subarrays share a common element.

A partition is called "good" if:

The array is divided into one or more contiguous subarrays
Each number appears in exactly one subarray
No two subarrays contain the same number

Example: For array [1,2,3,2], we cannot split after index 1 because both subarrays [1,2] and [3,2] would contain the number 2.

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

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The valid partitions are: [1,2,3,2] and [1] [2,3,2]. We cannot partition as [1,2] [3,2] because both subarrays contain the number 2.

example_2.py — All Unique Elements

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

› Output: 4

💡 Note: All possible partitions are valid since all numbers are unique: [1,2,3], [1,2] [3], [1] [2,3], [1] [2] [3].

example_3.py — Single Element

$ Input: nums = [5]

› Output: 1

💡 Note: There is only one way to partition a single element array: [5].

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Answer should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Scan Books

Record the position of each book ID's last occurrence

Track Active Range

As we process each position, track the furthest we must go to complete all current book IDs

Identify Section Breaks

When current position matches the active range end, we can close this section

Count Possibilities

Each valid section break gives us 2 choices: split or continue

Key Takeaway

🎯 Key Insight: A partition is only valid when all active book IDs (numbers) have been completely processed, meaning their ranges don't extend beyond the current position.

Asked in

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

The optimal solution uses range tracking to identify valid partition points. By mapping each number to its last occurrence and tracking the maximum range of numbers seen so far, we can determine when it's safe to make a partition cut. The final answer is 2^(valid_cuts - 1) since each cut point gives us a choice to partition or not, except the last one which is mandatory.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Partitions)	O(2^n * n^2)	O(n^2)	Generate all possible partitions and check if each is valid
Optimal Solution (Range Tracking)	O(n)	O(n)	Track the rightmost occurrence of each number to determine valid partition points

Brute Force (Try All Partitions) — Algorithm Steps

Generate all possible partition boundaries using bit manipulation
For each partition configuration, split the array into subarrays
Check if the partition is valid by ensuring no number appears in multiple subarrays
Count all valid partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Masks

Create all possible binary masks representing partition boundaries

Create Partitions

Convert each mask into actual array partitions

Validate

Check if any number appears in multiple partitions

Code -

solution.c — C

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

#define MOD 1000000007

int isValidPartition(int* nums, int n, int mask) {
    int used[100001] = {0}; // Assuming nums[i] <= 100000
    int start = 0;
    
    for (int i = 0; i < n - 1; i++) {
        if (mask & (1 << i)) {
            // End current partition
            int partitionSet[100001] = {0};
            for (int j = start; j <= i; j++) {
                if (partitionSet[nums[j]]) continue;
                if (used[nums[j]]) return 0; // Number already used
                used[nums[j]] = 1;
                partitionSet[nums[j]] = 1;
            }
            start = i + 1;
        }
    }
    
    // Handle last partition
    int partitionSet[100001] = {0};
    for (int j = start; j < n; j++) {
        if (partitionSet[nums[j]]) continue;
        if (used[nums[j]]) return 0;
        used[nums[j]] = 1;
        partitionSet[nums[j]] = 1;
    }
    
    return 1;
}

int goodPartitions(int* nums, int n) {
    int count = 0;
    
    for (int mask = 0; mask < (1 << (n - 1)); mask++) {
        if (isValidPartition(nums, n, mask)) {
            count = (count + 1) % MOD;
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", goodPartitions(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n^2)

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

⚠ Quadratic Growth

Space Complexity

O(n^2)

Space to store partition configurations and validation sets

⚠ Quadratic Space

43.7K Views

Medium-High Frequency

~25 min Avg. Time

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

Brute Force (Try All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler