Number of Great Partitions - Practice Coding Problems

Number of Great Partitions - Problem

Imagine you're a team leader dividing your team into two groups for a competitive challenge. You need to ensure both groups are strong enough to handle their tasks effectively.

Given an array nums of positive integers and an integer k, you must partition the array into exactly two ordered groups such that:

Each element belongs to exactly one group
Both groups have a sum ≥ k (making them "great" partitions)
The order of elements within each group matches their original order in the array

Goal: Count all possible distinct great partitions. Since the answer can be huge, return it modulo 10⁹ + 7.

Example: With nums = [1,1,1,1] and k = 2, you could have group1=[1,1] and group2=[1,1], or group1=[1,1,1] and group2=[1], etc.

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: Valid partitions: ([1],[1,1,1]), ([1,1],[1,1]), ([1,1,1],[1]), ([1],[1,1,1]), ([1,1],[1,1]), ([1,1,1],[1]). Wait, we need to count distinct partitions based on positions, not values. Actually there are 6 valid ways to split.

example_2.py — Impossible Case

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

› Output: 0

💡 Note: Total sum is 6, so it's impossible to have both groups with sum ≥ 10. No valid partitions exist.

example_3.py — Edge Case

$ Input: nums = [6,6], k = 6

› Output: 2

💡 Note: Two valid partitions: ([6],[6]) and ([6],[6]). Since elements are at different positions, both ways count: group1=[nums[0]], group2=[nums[1]] and group1=[nums[1]], group2=[nums[0]].

Visualization

Tap to expand

Understanding the Visualization

Decision Point

At each contestant, decide which team they join

Track Progress

Keep track of current team compositions and skill totals

Validate & Count

Check if both teams meet requirements and count valid formations

Key Takeaway

🎯 Key Insight: Use dynamic programming to efficiently explore all possible team formations while avoiding redundant calculations through memoization. Track one team's skill total since the other is automatically determined.

Time & Space Complexity

Time Complexity

⏱️

O(n × S)

n positions × S possible sums (where S is the total sum)

✓ Linear Growth

Space Complexity

O(n × S)

Memoization table size plus recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
Both groups must be non-empty

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses dynamic programming with memoization to count valid partitions efficiently. We track the current position and first group's sum, making decisions to put each element in group 1 or group 2. The key insight is that we only need to track one group's sum since the other is determined by total_sum - group1_sum. Time complexity is O(n × S) where S is the total sum.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Memoized Recursion)	O(n × S)	O(n × S)	Use recursion with memoization to count valid partitions efficiently

Dynamic Programming (Memoized Recursion) — Algorithm Steps

Define state: dp(index, group1_sum) = number of ways to partition remaining elements
For each element, try putting it in group 1 or group 2
Use memoization to cache results
Base case: when all elements are assigned, check if both groups are valid

Visualization

Tap to expand

Step-by-Step Walkthrough

Decision Tree

Each node represents a choice: put element in group 1 or 2

Memoization

Cache results to avoid recalculating same states

Combine Results

Sum up all valid partitions from both choices

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 10000

typedef struct {
    int index;
    int group1Sum;
    int result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;
int* nums;
int numsSize;
int k;
int totalSum;

int findMemo(int index, int group1Sum) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].index == index && memo[i].group1Sum == group1Sum) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int index, int group1Sum, int result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].index = index;
        memo[memoSize].group1Sum = group1Sum;
        memo[memoSize].result = result;
        memoSize++;
    }
}

int dp(int index, int group1Sum) {
    if (index == numsSize) {
        int group2Sum = totalSum - group1Sum;
        return (group1Sum >= k && group2Sum >= k) ? 1 : 0;
    }
    
    int cached = findMemo(index, group1Sum);
    if (cached != -1) {
        return cached;
    }
    
    // Put current element in group 1
    int result = dp(index + 1, group1Sum + nums[index]);
    
    // Put current element in group 2
    result = (result + dp(index + 1, group1Sum)) % MOD;
    
    addMemo(index, group1Sum, result);
    return result;
}

int waysToPartition(int* arr, int size, int target) {
    nums = arr;
    numsSize = size;
    k = target;
    totalSum = 0;
    memoSize = 0;
    
    for (int i = 0; i < size; i++) {
        totalSum += arr[i];
    }
    
    return dp(0, 0);
}

int main() {
    int nums_arr[] = {1, 1, 1, 1};
    int k_val = 2;
    printf("%d\n", waysToPartition(nums_arr, 4, k_val));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × S)

n positions × S possible sums (where S is the total sum)

✓ Linear Growth

Space Complexity

O(n × S)

Memoization table size plus recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 10⁹
Both groups must be non-empty

27.4K Views

Medium Frequency

~35 min Avg. Time

890 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 (Memoized Recursion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler