Codestin Search App

Minimum Cost to Split an Array - Problem

You are given an integer array nums and an integer k.

Your goal: Split the array into multiple non-empty subarrays to minimize the total cost of the split.

How cost is calculated:

For each subarray, create a trimmed version by removing all numbers that appear only once
The importance value of a subarray = k + length of trimmed subarray
Total cost = sum of importance values of all subarrays

Example:
If subarray is [3,1,2,4,3,4]:
• Trimmed version: [3,4,3,4] (removed 1 and 2)
• Importance value: k + 4

Key insight: You want to balance between having fewer splits (each costs at least k) and having smaller trimmed lengths (elements that repeat within the subarray).

Input & Output

example_1.py — Basic Split Decision

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

› Output: 8

💡 Note: Optimal split: [3,1] and [2,4,3,4]. First subarray has no duplicates, so cost = 3+0=3. Second subarray has duplicates [4,4], so trimmed=[4,4] with length 2, cost = 3+2=5. Total = 3+5=8.

example_2.py — Single Subarray

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

› Output: 8

💡 Note: Keep as one subarray [1,2,1,2,1,3,3]. Duplicates are [1,1,1,2,2,3,3] (6 elements), so cost = 2+6=8. Splitting would cost more due to multiple k values.

example_3.py — All Unique Elements

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

› Output: 10

💡 Note: Since all elements are unique, trimmed length is always 0. Best strategy is to split into individual elements: 5 subarrays each costing k=2, total = 5×2=10.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ nums.length
1 ≤ k ≤ 10⁹
All subarrays must be non-empty

Visualization

Tap to expand

Understanding the Visualization

Analyze Items

Look at your items: [3,1,2,4,3,4]. Items 3 and 4 appear twice.

Consider Box Options

Option 1: One big box costs k + 4 duplicates. Option 2: Split into smaller boxes.

Calculate Costs

Split [3,1] + [2,4,3,4]: First box k+0, second box k+2, total 2k+2.

Choose Optimal

Compare 1×k+4 vs 2×k+2. When k=3: 7 vs 8, so one box wins!

Key Takeaway

🎯 Key Insight: Dynamic programming finds the optimal balance between minimizing the number of boxes (each costing k) and minimizing duplicate handling fees within each box.

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 20

The optimal approach uses dynamic programming with time complexity O(n³). We define dp[i] as the minimum cost to split the first i elements, then try all possible previous split points to build the solution incrementally. The key insight is that each subarray's cost depends only on elements that appear more than once within that subarray, making local optimization possible.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n³)	O(n)	Build optimal solution incrementally using memoization

Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp array where dp[i] = minimum cost to split nums[0:i]
For each position i, try all possible previous split points j < i
Efficiently calculate cost of subarray nums[j:i] using frequency counting
Update dp[i] = min(dp[j] + cost(nums[j:i])) for all valid j
Return dp[n] as the minimum cost for the entire array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set dp[0] = 0, all others to infinity

Fill DP Table

For each position, try all previous split points

Calculate Cost

Compute subarray cost using frequency counting

Update Minimum

Take minimum over all possible transitions

Code -

solution.c — C

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

int getCost(int* nums, int start, int end, int k) {
    int freq[1001] = {0}; // Assuming nums[i] <= 1000
    for (int i = start; i < end; i++) {
        freq[nums[i]]++;
    }
    
    int trimmedLength = 0;
    for (int i = 0; i < 1001; i++) {
        if (freq[i] > 1) trimmedLength += freq[i];
    }
    return k + trimmedLength;
}

int minimumCost(int* nums, int numsSize, int k) {
    int* dp = (int*)malloc((numsSize + 1) * sizeof(int));
    dp[0] = 0;
    for (int i = 1; i <= numsSize; i++) {
        dp[i] = INT_MAX;
    }
    
    for (int i = 1; i <= numsSize; i++) {
        for (int j = 0; j < i; j++) {
            if (dp[j] != INT_MAX) {
                int cost = getCost(nums, j, i, k);
                if (dp[j] + cost < dp[i]) {
                    dp[i] = dp[j] + cost;
                }
            }
        }
    }
    
    int result = dp[numsSize];
    free(dp);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs of split points, each requiring O(n) time to compute subarray cost

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n plus space for frequency counting

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler