Number of Great Partitions - Problem

You are given an array nums consisting of positive integers and an integer k.

Partition the array into two ordered groups such that each element is in exactly one group. A partition is called great if the sum of elements of each group is greater than or equal to k.

Return the number of distinct great partitions. Since the answer may be too large, return it modulo 10⁹ + 7.

Two partitions are considered distinct if some element nums[i] is in different groups in the two partitions.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Only one great partition: Group A = {1,1} with sum 2, Group B = {2} with sum 2. Both sums ≥ k=2.

Example 2 — Multiple Partitions

$ Input: nums = [3,3,3], k = 4

› Output: 0

💡 Note: No great partitions possible. To have both groups with sum ≥ 4, we would need total sum ≥ 8, but with [3,3,3] the maximum one group can have is 6 (two elements) while the other gets 3, which is < 4.

Example 3 — Impossible Case

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

› Output: 0

💡 Note: Total sum is 4, but we need both groups to have sum ≥ 5. Impossible since 4 < 2×5.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 100
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use dynamic programming to count partitions efficiently rather than generating all 2^n possibilities. We build a DP table tracking how many ways we can achieve each possible sum, then count valid partitions where both groups have sum ≥ k. Best approach is 2D DP with Time: O(n×sum), Space: O(n×sum).

Common Approaches

✓ Brute Force - Try All Partitions

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

For each element, we have 2 choices: put it in group A or group B. We try all 2^n combinations and count those where both groups have sum >= k.

Dynamic Programming - Count Valid Partitions

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

Build a DP table where dp[i][s] represents number of ways to partition first i elements such that one group has sum s. We ensure both groups satisfy the minimum sum requirement.

Brute Force - Try All Partitions — Algorithm Steps

Generate all 2^n possible partitions using bit manipulation
For each partition, calculate sum of both groups
Count partitions where both sums >= k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Masks

Each bit represents group assignment (0=A, 1=B)

Calculate Sums

Sum elements in each group for current partition

Count Valid

Increment counter if both sums >= k

Code -

solution.c — C

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

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp /= 2;
    }
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int* nums, int numsSize, int k) {
    const int MOD = 1000000007;
    int n = numsSize;
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += nums[i];
    }
    int count = 0;
    
    // Early termination if impossible
    if (total < 2 * k) {
        return 0;
    }
    
    // Try all 2^n partitions
    for (int mask = 0; mask < (1 << n); mask++) {
        int sum_A = 0;
        int sum_B = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                sum_A += nums[i];
            } else {
                sum_B += nums[i];
            }
        }
        
        // Count if both groups satisfy constraint
        if (sum_A >= k && sum_B >= k) {
            count++;
        }
    }
    
    // Divide by 2 since each partition is counted twice
    return (count * modPow(2, MOD - 2, MOD)) % MOD;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    static int nums[20];
    int numsSize;
    parseArray(line, nums, &numsSize);
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^n partitions and check each one

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track sums

⚡ Linearithmic Space

12.4K Views

Medium Frequency

~35 min Avg. Time

387 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

Number of Great Partitions - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Partitions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler