Maximum Number of Ways to Partition an Array

Maximum Number of Ways to Partition an Array - Problem

Array Hash Table Counting Enumeration Prefix Sum Hard

You're given a 0-indexed integer array nums of length n. Your goal is to find pivot points where you can split the array into two equal-sum parts.

A valid partition occurs at index pivot when:

1 ≤ pivot < n (can't split at the very beginning or end)
Sum of left part equals sum of right part: nums[0] + ... + nums[pivot-1] == nums[pivot] + ... + nums[n-1]

Here's the twist: you can optionally change exactly one element in the array to value k before counting partitions. This gives you the power to potentially create more valid pivot points!

Return the maximum possible number of ways to partition the array after making at most one strategic change.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Original array has 0 valid partitions. If we change nums[2] to 3: [2, -1, 3], pivot at index 2 gives left_sum = 1, right_sum = 3 (not equal). If we change nums[1] to 3: [2, 3, 2], pivot at index 2 gives left_sum = 5, right_sum = 2 (not equal). However, if we change nums[0] to 3: [3, -1, 2], pivot at index 2 gives left_sum = 2, right_sum = 2 (equal!). Maximum is 1.

example_2.py — No Change Optimal

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

› Output: 2

💡 Note: Original array already has valid partitions at indices 1 and 2. At pivot 1: left=[0], right=[1,-1,0], sums are 0 vs 0. At pivot 2: left=[0,1], right=[-1,0], sums are 1 vs -1 (not equal). Actually at pivot 3: left=[0,1,-1], right=[0], sums are 0 vs 0. The original array gives us 2 partitions, which is optimal.

example_3.py — Single Element

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

› Output: 0

💡 Note: Arrays with length 1 cannot be partitioned since we need at least one element on each side of the pivot. No valid partitions possible.

Constraints

n == nums.length
2 ≤ n ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶
-10⁶ ≤ k ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Setup

Place gems on scale, calculate weight differences for each split point

Organize

Group differences by value - differences to the left and right of current position

Transform

For each position, consider transforming that gem and count balanced splits

Update

Move differences between left and right groups as position advances

Optimize

Track maximum balanced splits found across all transformation positions

Key Takeaway

🎯 Key Insight: Instead of recalculating everything for each change, we incrementally track how differences shift between left and right sides, using hash maps to instantly count valid partitions!

Asked in

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

The optimal solution uses incremental difference tracking with dual hash maps. Key insight: as we consider changing each position, we can efficiently count valid partitions by tracking how differences change, achieving O(n) time complexity with a single pass through the array.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n³)	O(1)	Try changing each element to k and count valid partitions for each case
Two-Pass Hash Table Optimization	O(n²)	O(n)	First pass builds difference map, second pass counts solutions efficiently
One-Pass Hash Table (Optimal)	O(n)	O(n)	Single pass with incremental difference tracking using hash maps

Brute Force (Try All Combinations) — Algorithm Steps

For each possible change position (including no change)
Create a modified array with that position changed to k
For each potential pivot position, calculate left and right sums
Count how many pivots create equal sums
Track the maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

No Change

First check original array for valid partitions

Try Position 0

Change element at position 0 to k, check all pivots

Try Position 1

Change element at position 1 to k, check all pivots

Continue

Repeat for all positions, track maximum

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int waysToPartition(int* nums, int numsSize, int k) {
    int maxWays = 0;
    
    // Try not changing anything
    int ways = 0;
    long long total = 0;
    for (int i = 0; i < numsSize; i++) {
        total += nums[i];
    }
    long long leftSum = 0;
    for (int i = 0; i < numsSize - 1; i++) {
        leftSum += nums[i];
        long long rightSum = total - leftSum;
        if (leftSum == rightSum) ways++;
    }
    maxWays = max(maxWays, ways);
    
    // Try changing each position to k
    for (int changePos = 0; changePos < numsSize; changePos++) {
        ways = 0;
        int* modified = (int*)malloc(numsSize * sizeof(int));
        for (int i = 0; i < numsSize; i++) {
            modified[i] = nums[i];
        }
        modified[changePos] = k;
        total = 0;
        for (int i = 0; i < numsSize; i++) {
            total += modified[i];
        }
        leftSum = 0;
        
        for (int pivot = 0; pivot < numsSize - 1; pivot++) {
            leftSum += modified[pivot];
            long long rightSum = total - leftSum;
            if (leftSum == rightSum) ways++;
        }
        maxWays = max(maxWays, ways);
        free(modified);
    }
    
    return maxWays;
}

int main() {
    int nums[] = {2, -1, 2};
    int k = 3;
    printf("%d\n", waysToPartition(nums, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) positions to change × O(n) pivot positions × O(n) sum calculations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and tracking maximum

✓ Linear Space

26.8K Views

Medium-High 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler