Split Array Largest Sum

Split Array Largest Sum - Problem

Array Binary Search Dynamic Programming Greedy Prefix Sum Hard

Given an integer array nums and an integer k, split nums into k non-empty subarrays such that the largest sum of any subarray is minimized.

Return the minimized largest sum of the split.

A subarray is a contiguous part of the array.

Input & Output

Example 1 — Basic Split

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

› Output: 18

💡 Note: Split into [7,2,5] and [10,8]. The sums are 14 and 18, so the largest sum is 18, which is minimal among all possible splits.

Example 2 — Multiple Small Subarrays

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

› Output: 9

💡 Note: Split into [1,2,3,4] and [5]. The sums are 10 and 5, giving largest sum 10. Better split: [1,2,3] and [4,5] gives sums 6 and 9, so answer is 9.

Example 3 — Edge Case k=1

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

› Output: 9

💡 Note: Cannot split array when k=1, so return sum of entire array: 1+4+4=9.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ k ≤ min(50, nums.length)
0 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is that we can binary search on the answer space - the minimum possible largest sum lies between max(nums) and sum(nums). Best approach is Binary Search on Answer with greedy validation. Time: O(n log(sum)), Space: O(1)

Common Approaches

✓ Binary Search on Answer Space

⏱️ Time: O(n log(sum)) Space: O(1)

The answer lies between max(nums) and sum(nums). Use binary search on this range. For each candidate max sum, greedily check if we can split the array into k subarrays with no subarray sum exceeding the candidate.

Brute Force - Try All Splits

⏱️ Time: O(k^n) Space: O(k)

Use recursion to try every possible position for each split point. For each valid split, calculate the maximum subarray sum and track the minimum across all splits.

Dynamic Programming - 2D Table

⏱️ Time: O(n²k) Space: O(nk)

Use dynamic programming where dp[i][j] represents the minimum largest sum when splitting the first i elements into j subarrays. Build the table bottom-up.

Binary Search on Answer Space — Algorithm Steps

Set search range: left = max(nums), right = sum(nums)
Binary search: for each mid value, check if achievable with k splits
Greedy validation: try to form subarrays with sum ≤ mid using minimum splits

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Range

left = max(nums), right = sum(nums)

Check Mid

For each mid, validate if achievable with k splits

Narrow Range

Adjust search range based on validation result

Code -

solution.c — C

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

bool canSplit(int* nums, int n, int k, int maxSum) {
    int splits = 1;
    int currentSum = 0;
    
    for (int i = 0; i < n; i++) {
        if (currentSum + nums[i] <= maxSum) {
            currentSum += nums[i];
        } else {
            splits++;
            currentSum = nums[i];
            if (splits > k) {
                return false;
            }
        }
    }
    
    return splits <= k;
}

int solution(int* nums, int n, int k) {
    int left = nums[0], right = nums[0];
    
    for (int i = 1; i < n; i++) {
        if (nums[i] > left) left = nums[i];
        right += nums[i];
    }
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canSplit(nums, n, k, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(sum))

Binary search O(log(sum)) × validation O(n) for each candidate

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for binary search and validation

⚡ Linearithmic Space

120.0K Views

High Frequency

~25 min Avg. Time

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

Binary Search on Answer Space — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler