Segment Horizon Partition Engine 5 — Problem Statement & Solution Guide

Binary SearchHardBinary Search on Answer Matrix

TimeO(N log (S))

SpaceO(1)

Problem Description

Segment Horizon Partition Engine 5

You are given a sequence of N non‑negative integers that represent the heights of consecutive segments along a horizon. Your task is to split this sequence into exactly K contiguous groups (K ≤ N). The cost of a partition is the largest sum of heights among all groups. Determine the minimum possible cost that can be achieved by an optimal partition.

Input

The first line contains two integers N and K (1 ≤ K ≤ N ≤ 10^5). The second line contains N integers a1, a2, …, aN (0 ≤ ai ≤ 10^9).

Output

Print a single integer: the minimum possible maximum group sum.

The problem can be solved efficiently by binary searching over the answer and checking feasibility in O(N) time per check, yielding an overall complexity of O(N log S) where S is the sum of all heights.

DSA Pattern Breakdown

"Segment Horizon Partition Engine 5"

hard

WHY DOES IT MATTER?

This pattern—binary search on answer combined with a greedy feasibility check—is a cornerstone for optimization problems where the objective is to minimize the maximum of a set of values under partitioning constraints. Mastery of this technique unlocks efficient solutions for load balancing, allocation, and scheduling tasks.

OPTIMIZATION CHALLENGE

The key insight is recognizing that the feasibility test can be performed in O(N) by greedily forming groups, which turns a potentially exponential search space into a simple monotonic predicate suitable for binary search.

REAL-WORLD CONNECTION

Think of distributing video chunks across K streaming servers: you want to minimize the longest total bandwidth any server handles. The binary‑search‑plus‑greedy method mirrors how a load‑balancer iteratively probes capacity limits and reassigns chunks to keep the worst‑case load minimal.

During an interview, first write the greedy checker as a separate function, test it with edge cases, then wrap a binary search around it. Keep the search bounds tight: low = max element, high = total sum, to guarantee O(log S) iterations.

COMPLEXITY AT A GLANCE

⏱ Time:O(N log (S))

💾 Space:O(1)

Core Theory — Why This Approach?

The problem is a classic instance of the "minimum largest subarray sum" partitioning, which can be modeled as a decision problem: given a candidate cost C, can we split the array into at most K contiguous groups such that each group's sum does not exceed C? This decision can be answered greedily by scanning the array and forming a new group whenever adding the next element would breach C. The monotonic nature of the decision (if a cost C works, any larger cost also works) enables a binary search over the answer space, narrowing the optimal cost in O(log S) steps where S is the range between the maximum single element and the total sum. Naïve enumeration of all possible partitions would require exponential time because the number of ways to place K‑1 cuts among N‑1 gaps is combinatorial (C(N‑1, K‑1)). The binary‑search‑plus‑greedy paradigm reduces this to O(N log S), which is tractable for N up to 10^5 or higher.

Interview Questions on This Problem

Q1How would you modify the solution if the groups were allowed to be non‑contiguous?

The greedy check relies on contiguity; for non‑contiguous groups the problem becomes a variant of the partition problem, which is NP‑hard. You would need to use DP or approximation algorithms, and binary search would no longer guarantee a linear‑time feasibility check.

Q2Why is binary search applicable to this problem even though we are not searching a sorted array?

Binary search works on any monotonic predicate. Here the predicate is "can we partition with max sum ≤ X?" If it holds for X, it also holds for any X' ≥ X, giving a monotonic true/false sequence over the numeric range, which binary search can exploit.

Q3What is the impact of using 64‑bit integers for the sum calculations, and when would you need them?

The total sum of heights can exceed 32‑bit limits (e.g., N = 10^5, each height up to 10^9). Using 64‑bit (long long) prevents overflow in the binary search bounds and the greedy accumulation, ensuring correctness for large inputs.

Examples

Example 1

Input

5 2
1 2 3 4 5

Output

Explanation: We need two groups. Trying all splits: - [1] [2 3 4 5] → max sum 14 - [1 2] [3 4 5] → max sum 12 - [1 2 3] [4 5] → max sum 9 - [1 2 3 4] [5] → max sum 10 The smallest maximum is 9, achieved by the split [1 2 3] | [4 5].

Example 2

Input

4 3
10 20 30 40

Output

Explanation: Possible splits into three groups: - [10] [20] [30 40] → max 70 - [10] [20 30] [40] → max 50 - [10 20] [30] [40] → max 40 The optimal partition is [10 20] | [30] | [40] with maximum sum 40.

Example 3

Input

6 3
5 5 5 5 5 5

Output

Explanation: All groups must contain two segments to keep sums balanced. Partition as [5 5] | [5 5] | [5 5]. Each group sums to 10, so the minimal maximum is 10.

Constraints

1 ≤ N ≤ 10^5
1 ≤ K ≤ N
0 ≤ ai ≤ 10^9
The total sum of all ai fits in a 64‑bit signed integer
The answer fits in a 64‑bit signed integer

Optimal Approach & Strategy

Perform binary search on the possible cost range, using a greedy linear scan to test if a candidate cost can achieve a partition with at most K groups.

Brute Force Approach

Enumerate all ways to place K‑1 cuts among N‑1 positions, compute the maximum group sum for each partition, and take the minimum of those maxima.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(N log (S))

function solution(nums) {
   let n = nums.length;
   let answerMatrix = Array(n).fill(0).map(() => Array(n).fill(0));
   let targetSum = nums.reduce((a, b) => a + b, 0);
   for (let i = 0; i < n; i++) {
       for (let j = 0; j < n; j++) {
           answerMatrix[i][j] = targetSum - nums[i] - nums[j];
       }
   }
   let low = 0;
   let high = n * n - 1;
   while (low <= high) {
       let mid = Math.floor((low + high) / 2);
       let row = Math.floor(mid / n);
       let col = mid % n;
       if (answerMatrix[row][col] === targetSum) {
           return targetSum;
       } else if (answerMatrix[row][col] < targetSum) {
           low = mid + 1;
       } else {
           high = mid - 1;
       }
   }
   return -1;
}

class Solution {
   public:
       int solution(vector<int>& nums) {
           int n = nums.size();
           vector<vector<int>> answerMatrix(n, vector<int>(n, 0));
           int targetSum = 0;
           for (int num : nums) {
               targetSum += num;
           }
           for (int i = 0; i < n; i++) {
               for (int j = 0; j < n; j++) {
                   answerMatrix[i][j] = targetSum - nums[i] - nums[j];
               }
           }
           int low = 0;
           int high = n * n - 1;
           while (low <= high) {
               int mid = low + (high - low) / 2;
               int row = mid / n;
               int col = mid % n;
               if (answerMatrix[row][col] == targetSum) {
                   return targetSum;
               } else if (answerMatrix[row][col] < targetSum) {
                   low = mid + 1;
               } else {
                   high = mid - 1;
               }
           }
           return -1;
       }
   };

class Solution {
   public int solution(int[] nums) {
       int n = nums.length;
       int[][] answerMatrix = new int[n][n];
       int targetSum = 0;
       for (int num : nums) {
           targetSum += num;
       }
       for (int i = 0; i < n; i++) {
           for (int j = 0; j < n; j++) {
               answerMatrix[i][j] = targetSum - nums[i] - nums[j];
           }
       }
       int low = 0;
       int high = n * n - 1;
       while (low <= high) {
           int mid = low + (high - low) / 2;
           int row = mid / n;
           int col = mid % n;
           if (answerMatrix[row][col] == targetSum) {
               return targetSum;
           } else if (answerMatrix[row][col] < targetSum) {
               low = mid + 1;
           } else {
               high = mid - 1;
           }
       }
       return -1;
   }
}

def solution(nums):
   n = len(nums)
   answerMatrix = [[0] * n for _ in range(n)]
   targetSum = sum(nums)
   for i in range(n):
       for j in range(n):
           answerMatrix[i][j] = targetSum - nums[i] - nums[j]
   low = 0
   high = n * n - 1
   while low <= high:
       mid = (low + high) // 2
       row = mid // n
       col = mid % n
       if answerMatrix[row][col] == targetSum:
           return targetSum
       elif answerMatrix[row][col] < targetSum:
           low = mid + 1
       else:
           high = mid - 1
   return -1

function solution(nums) {
   let n = nums.length;
   let answerMatrix = Array(n).fill(0).map(() => Array(n).fill(0));
   let targetSum = nums.reduce((a, b) => a + b, 0);
   for (let i = 0; i < n; i++) {
       for (let j = 0; j < n; j++) {
           answerMatrix[i][j] = targetSum - nums[i] - nums[j];
       }
   }
   let low = 0;
   let high = n * n - 1;
   while (low <= high) {
       let mid = Math.floor((low + high) / 2);
       let row = Math.floor(mid / n);
       let col = mid % n;
       if (answerMatrix[row][col] === targetSum) {
           return targetSum;
       } else if (answerMatrix[row][col] < targetSum) {
           low = mid + 1;
       } else {
           high = mid - 1;
       }
   }
   return -1;
}

Asked in Top Tech Interviews

UberMicrosoft

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

Segment Horizon Partition Engine 5 Solution

Problem Statement

Input

Output

Input

Output

Input

Output

Constraints

More Binary Search

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Segment Horizon Partition Engine 5 — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor