Divide an Array Into Subarrays With Minimum Cost II

Divide an Array Into Subarrays With Minimum Cost II - Problem

You are given a 0-indexed integer array nums of length n, and two positive integers k and dist.

The cost of an array is the value of its first element. For example, the cost of [1,2,3] is 1, while the cost of [3,4,1] is 3.

You need to divide nums into exactly k disjoint contiguous subarrays, such that the difference between the starting index of the second subarray and the starting index of the k-th subarray should be at most dist.

In other words, if you divide nums into subarrays nums[0..(i₁-1)], nums[i₁..(i₂-1)], ..., nums[iₖ₋₁..(n-1)], then iₖ₋₁ - i₁ ≤ dist.

Return the minimum possible sum of the costs of these subarrays.

Example: If nums = [1,3,2,6,4,2], k = 3, and dist = 3, you might divide it as [1] + [3,2] + [6,4,2] with costs 1 + 3 + 6 = 10.

Input & Output

example_1.py — Basic case

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

› Output: 8

💡 Note: The optimal division is [1] | [3,2] | [6,4,2]. The costs are 1 + 3 + 6 = 10. But we can also do [1] | [2] | [6,4,2] with costs 1 + 2 + 6 = 9. Actually the optimal is [1] | [2] | [4,2] with costs 1 + 2 + 4 = 7. Wait, let me recalculate: [1] | [3,2,6] | [4,2] gives 1 + 3 + 4 = 8.

example_2.py — Minimum k

$ Input: nums = [10,1,2,2,2,1], k = 2, dist = 4

› Output: 11

💡 Note: We need exactly 2 subarrays. The distance between the 2nd subarray start and 2nd subarray start is 0 ≤ 4. Optimal division: [10] | [1,2,2,2,1] with costs 10 + 1 = 11.

example_3.py — Distance constraint

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

› Output: 6

💡 Note: With dist = 1, the 2nd and 3rd subarrays must start within 1 position of each other. Division: [1] | [2] | [3,4] gives costs 1 + 2 + 3 = 6.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
2 ≤ k ≤ n
1 ≤ dist ≤ n - 2
The first subarray always starts at index 0

Visualization

Tap to expand

Understanding the Visualization

Identify constraints

First subarray starts at 0, need exactly k parts, distance limit between 2nd and k-th

Use sliding window

For each possible starting position, maintain k-1 cheapest options within distance

Apply dynamic programming

Build solution from right to left, using optimal substructure

Key Takeaway

🎯 Key Insight: The optimal solution combines dynamic programming with a sliding window approach, using heaps to efficiently maintain the k-1 smallest values within the distance constraint as we process positions from right to left.

Asked in

G Google 42 f Meta 35 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses dynamic programming with sliding window and heaps. We maintain the k-1 smallest elements in our window efficiently using a max heap for the k-1 smallest and a min heap for the rest. As we slide the window, we can calculate the minimum cost in O(n log k) time.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming + Sliding Window with Heaps	O(n log k)	O(n + k)	Use DP with sliding window and heaps to efficiently track k-1 minimum elements
Brute Force (Try All Combinations)	O(C(n,k) * k)	O(1)	Try every possible way to divide the array into k subarrays

Dynamic Programming + Sliding Window with Heaps — Algorithm Steps

Initialize DP array where dp[i] = minimum cost for subarrays starting at position i
Use two heaps: small_heap (k-1 smallest elements) and large_heap (remaining elements)
Slide window from right to left, maintaining heap invariants
For each position, calculate dp[i] using the sum of k-1 smallest elements in range
Return dp[1] (minimum cost starting from position 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize heaps

Set up max heap for k-1 smallest, min heap for rest

Slide window

Move window left, add/remove elements from heaps

Calculate DP

Use sum of k-1 smallest for DP transition

Code -

solution.c — C

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

// Simple implementation without heaps for demonstration
int minimumCost(int* nums, int numsSize, int k, int dist) {
    if (k == 1) return nums[0];
    
    // For simplicity, using a basic approach
    int* candidates = (int*)malloc(numsSize * sizeof(int));
    int candidateCount = 0;
    
    // Collect candidates within distance constraint
    for (int i = 2; i <= 1 + dist && i < numsSize; i++) {
        candidates[candidateCount++] = nums[i];
    }
    
    // Sort to get k-1 smallest
    for (int i = 0; i < candidateCount - 1; i++) {
        for (int j = i + 1; j < candidateCount; j++) {
            if (candidates[i] > candidates[j]) {
                int temp = candidates[i];
                candidates[i] = candidates[j];
                candidates[j] = temp;
            }
        }
    }
    
    int sum = nums[0];
    for (int i = 0; i < k - 1 && i < candidateCount; i++) {
        sum += candidates[i];
    }
    
    free(candidates);
    return sum;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

We process n positions, and for each position we do O(log k) heap operations

⚡ Linearithmic

Space Complexity

O(n + k)

O(n) for DP array and O(k) for heaps

⚡ Linearithmic Space

62.0K Views

Medium Frequency

~35 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming + Sliding Window with Heaps — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler