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: 5

💡 Note: The optimal division is [1,3] | [2,6,4] | [2]. The starting indices are 0, 2, 5. Distance constraint: 5-2=3 ≤ 3 ✓. Costs are 1 + 2 + 2 = 5.

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

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

✓ Brute Force (Try All Combinations)

⏱️ Time: O(C(n,k) * k) Space: O(1)

Generate all possible ways to choose k-1 split points and check if they satisfy the distance constraint, keeping track of the minimum cost.

Dynamic Programming + Sliding Window with Heaps

⏱️ Time: O(n log k) Space: O(n + k)

This optimal approach uses dynamic programming where dp[i] represents the minimum cost to create the remaining subarrays starting from position i. We use a sliding window with two heaps to efficiently maintain the k-1 smallest elements within the distance constraint.

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of k-1 split points from valid positions
For each combination, check if the distance constraint is satisfied
Calculate the total cost (sum of first elements of each subarray)
Keep track of the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate splits

Try all ways to place k-1 dividers

Check constraint

Verify distance between 2nd and k-th subarray

Calculate cost

Sum the first elements of each subarray

Code -

solution.c — C

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

static int minCost;

void backtrack(int* nums, int* splits, int splitCount, int startIdx, int remainingSplits, int dist, int n) {
    if (remainingSplits == 0) {
        if (splitCount > 0 && splits[splitCount-1] - splits[0] <= dist) {
            int cost = nums[0];
            for (int i = 0; i < splitCount; i++) {
                cost += nums[splits[i]];
            }
            if (cost < minCost) minCost = cost;
        }
        return;
    }
    
    for (int i = startIdx; i <= n - remainingSplits; i++) {
        splits[splitCount] = i;
        backtrack(nums, splits, splitCount + 1, i + 1, remainingSplits - 1, dist, n);
    }
}

int minimumCost(int* nums, int numsSize, int k, int dist) {
    minCost = INT_MAX;
    
    if (k == 1) {
        return nums[0];
    }
    
    int* splits = (int*)malloc(k * sizeof(int));
    backtrack(nums, splits, 0, 1, k - 1, dist, numsSize);
    free(splits);
    return minCost;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[10000];
    int numsSize = 0;
    
    char* token = strtok(line, ",\n");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",\n");
    }
    
    int k, dist;
    scanf("%d", &k);
    scanf("%d", &dist);
    
    int result = minimumCost(nums, numsSize, k, dist);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * k)

We need to check C(n,k) combinations, and for each we do O(k) work to validate and calculate cost

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for tracking minimum cost

⚡ 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler