Partition Array Into Three Parts With Equal Sum

Partition Array Into Three Parts With Equal Sum - Problem

Array Greedy Easy

Given an array of integers arr, determine if we can partition it into exactly three non-empty parts with equal sums. You need to find two dividing points that split the array into three consecutive subarrays, where each subarray has the same sum.

More formally, find indices i and j where i + 1 < j such that:
• Part 1: arr[0] + arr[1] + ... + arr[i]
• Part 2: arr[i+1] + arr[i+2] + ... + arr[j-1]
• Part 3: arr[j] + arr[j+1] + ... + arr[arr.length-1]

All three parts must have equal sums and contain at least one element. Return true if such a partition exists, false otherwise.

Input & Output

example_1.py — Basic Valid Partition

$ Input: [0, 2, 1, -6, 6, 7, 9, -1, 2, 0, 1]

› Output: true

💡 Note: We can partition this array into [0,2,1,-6,6,7,9] (sum=3), [-1,2] (sum=3), and [0,1] (sum=3). Wait, that's wrong. Let me recalculate: [0,2,1] (sum=3), [-6,6,7,9,-1,2,0] (sum=17), [1] (sum=1). Actually: [0,2,1,-6,6,7,9] (sum=13), [-1,2,0] (sum=1), [1] (sum=1). Let me try: Total sum = 21, so target = 7. [0,2,1,-6,6,7,9] has sum 23, that's wrong. Actually: [0,2,1,-6,6,7,9,-1,2,0] has sum 20, [1] has sum 1. Let me recalculate properly: we can split as [0,2,1,-6,6,7,9,-1,2,0] = sum 20, and [1] = sum 1. That doesn't work either. The correct partition is: [0,2,1,-6,6,7,9,-1,2,0,1] has indices where first part [0,2,1,-6,6,7,9] sums to 23. Let me use a simpler verified example.

example_2.py — Another Valid Case

$ Input: [3, 3, 3]

› Output: true

💡 Note: We can partition into [3], [3], and [3]. Each part has sum 3, so this is a valid equal partition.

example_3.py — Invalid Partition

$ Input: [0, 1, 2]

› Output: false

💡 Note: Total sum is 3, which is divisible by 3, giving target sum 1. However, we cannot partition this into three non-empty parts with sum 1 each. The only way to get sum 1 is [0,1] and [2] individually don't work, or [1] but then we can't partition the remaining [0,2] into two parts with sum 1 each.

Constraints

3 ≤ arr.length ≤ 5 × 10⁴
-10⁴ ≤ arr[i] ≤ 10⁴
Each partition must contain at least one element

Visualization

Tap to expand

Understanding the Visualization

Count Total Toppings

First, count all toppings (array sum). If not divisible by 3, impossible!

Calculate Fair Share

Each friend should get total_toppings ÷ 3 amount

Make First Cut

Scan from left, when first friend has their fair share, make first cut

Make Second Cut

Continue scanning, when second friend has their fair share, make second cut

Verify Third Friend

Remaining slices should automatically give third friend their fair share

Key Takeaway

🎯 Key Insight: If the total sum isn't divisible by 3, it's impossible. Otherwise, we just need to find where each third of the sum ends!

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Meta 12

The optimal approach uses a single-pass greedy strategy: first calculate if the total sum is divisible by 3, then find the two partition points by tracking when the running sum reaches the target value. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass	O(n)	O(1)	Calculate target sum first, then find partition points in one pass

Optimized Single Pass — Algorithm Steps

Calculate total sum of the array
Check if total sum is divisible by 3, return false if not
Calculate target sum for each part: target = total_sum / 3
Make one pass through array keeping running sum
When running sum equals target, mark first partition point
Continue until running sum equals 2*target, mark second partition point
Verify we have at least one element in the third part

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Total & Target

Sum all elements and divide by 3 to get target sum per partition

Find First Partition

Scan left to right until running sum equals target

Find Second Partition

Continue scanning until running sum equals target again

Validate Result

Ensure we have at least one element left for the third partition

Code -

solution.c — C

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

bool canThreePartsEqualSum(int* arr, int n) {
    int totalSum = 0;
    for (int i = 0; i < n; i++) {
        totalSum += arr[i];
    }
    
    // Check if divisible by 3
    if (totalSum % 3 != 0) {
        return false;
    }
    
    int target = totalSum / 3;
    
    // Need at least 3 elements
    if (n < 3) {
        return false;
    }
    
    // Find partition points
    int runningSum = 0;
    int firstPartition = -1;
    
    // Find first partition
    for (int i = 0; i < n - 2; i++) {
        runningSum += arr[i];
        if (runningSum == target) {
            firstPartition = i;
            break;
        }
    }
    
    if (firstPartition == -1) {
        return false;
    }
    
    // Find second partition
    runningSum = 0;
    for (int i = firstPartition + 1; i < n - 1; i++) {
        runningSum += arr[i];
        if (runningSum == target) {
            return true;
        }
    }
    
    return false;
}

int main() {
    int arr[1000], n = 0;
    char ch;
    
    scanf("%c", &ch); // skip '['
    while (scanf("%d%c", &arr[n], &ch)) {
        n++;
        if (ch == ']') break;
    }
    
    printf("%s\n", canThreePartsEqualSum(arr, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to calculate total sum, then another single pass to find partitions

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track sums and partition points

✓ Linear Space

21.8K Views

Medium Frequency

~18 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

Optimized Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler