Split Array Largest Sum - Practice Coding Problems

Split Array Largest Sum - Problem

Array Binary Search Dynamic Programming Greedy Prefix Sum Hard

You're tasked with optimally partitioning an integer array into exactly k subarrays to minimize the maximum subarray sum.

Given an integer array nums and an integer k, you need to split nums into k non-empty contiguous subarrays such that the largest sum among all subarrays is as small as possible.

Goal: Return the minimized largest sum of the split.

Example: If nums = [7,2,5,10,8] and k = 2, you could split it as [7,2,5] + [10,8] with sums [14, 18]. The largest sum is 18. But if you split as [7] + [2,5,10,8], you get sums [7, 25] with largest sum 25. The optimal split gives the minimum possible largest sum.

Input & Output

example_1.py — Basic Split

$ Input: nums = [7,2,5,10,8], k = 2

› Output: 18

💡 Note: The optimal split is [7,2,5] and [10,8] with sums 14 and 18 respectively. The maximum sum is 18, which is the minimum possible for k=2.

example_2.py — Single Element

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

› Output: 9

💡 Note: The optimal split is [1,2,3,4] and [5] with sums 10 and 5, giving maximum 10. Wait, that's not optimal. Better split: [1,2,3] and [4,5] gives sums 6 and 9, maximum 9.

example_3.py — Edge Case

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

› Output: 4

💡 Note: When k equals array length, each element forms its own subarray. The maximum is the largest element: 4.

Visualization

Tap to expand

Understanding the Visualization

Set Bounds

Minimum possible max workload = largest single task. Maximum = all tasks to one team.

Binary Search

Try different maximum workload limits and see if k teams can handle it.

Greedy Assignment

For each limit, greedily assign consecutive tasks to teams until limit is reached.

Adjust Range

If k teams can handle it, try smaller limit. Otherwise, try larger limit.

Key Takeaway

🎯 Key Insight: Binary search works because if we can distribute tasks with maximum X hours, we can also do it with any maximum > X hours (monotonic property).

Time & Space Complexity

Time Complexity

⏱️

O(C(n-1,k-1) * n)

Need to check C(n-1,k-1) combinations of split points, each taking O(n) time to calculate sums

✓ Linear Growth

Space Complexity

O(k)

Only need space to store current split positions and calculate sums

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ min(50, nums.length)
Each subarray must be non-empty and contiguous

Asked in

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

The optimal approach uses binary search on the answer with greedy validation. We binary search on the maximum subarray sum (range: max(nums) to sum(nums)) and for each candidate, greedily check if we can form ≤ k subarrays. Time: O(n × log(sum)), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Splits)	O(C(n-1,k-1) * n)	O(k)	Generate all possible ways to split array into k parts and find minimum largest sum
Binary Search on Answer	O(n * log(sum))	O(1)	Binary search on the answer space with greedy validation

Brute Force (Try All Splits) — Algorithm Steps

Generate all possible combinations of k-1 split positions
For each combination, calculate sums of resulting k subarrays
Find the maximum sum among the k subarrays
Track the minimum maximum sum across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Split Points

Create all possible combinations of k-1 split positions

Calculate Subarray Sums

For each combination, compute the sum of each resulting subarray

Find Maximum

Identify the largest sum among all subarrays in current split

Track Minimum

Keep track of the smallest maximum sum found so far

Code -

solution.c — C

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

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

int min(int a, int b) {
    return a < b ? a : b;
}

int splitArrayBrute(int* nums, int numsSize, int k) {
    if (k == 1) {
        int sum = 0;
        for (int i = 0; i < numsSize; i++) {
            sum += nums[i];
        }
        return sum;
    }
    if (k >= numsSize) {
        int maxVal = nums[0];
        for (int i = 1; i < numsSize; i++) {
            maxVal = max(maxVal, nums[i]);
        }
        return maxVal;
    }
    
    // Simplified brute force - recursive approach
    int minLargestSum = INT_MAX;
    
    // Try all possible first split positions
    for (int i = 1; i < numsSize - k + 2; i++) {
        int firstSum = 0;
        for (int j = 0; j < i; j++) {
            firstSum += nums[j];
        }
        
        int restResult = splitArrayBrute(nums + i, numsSize - i, k - 1);
        int currentMax = max(firstSum, restResult);
        minLargestSum = min(minLargestSum, currentMax);
    }
    
    return minLargestSum;
}

int main() {
    // Parse input and call splitArrayBrute
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n-1,k-1) * n)

Need to check C(n-1,k-1) combinations of split points, each taking O(n) time to calculate sums

✓ Linear Growth

Space Complexity

O(k)

Only need space to store current split positions and calculate sums

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ min(50, nums.length)
Each subarray must be non-empty and contiguous

98.5K Views

High Frequency

~25 min Avg. Time

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

Brute Force (Try All Splits) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler