Divide an Array Into Subarrays With Minimum Cost I

Divide an Array Into Subarrays With Minimum Cost I - Problem

You're given an array of integers nums with n elements, and your task is to divide it into exactly 3 disjoint contiguous subarrays.

The cost of any subarray is defined as the value of its first element. For example:

The cost of [1, 2, 3] is 1
The cost of [3, 4, 1] is 3

Your goal is to find the minimum possible sum of the costs of these three subarrays. Since we need exactly 3 subarrays, we need to place 2 dividers in the array, creating 3 contiguous segments.

Key insight: The first subarray always starts at index 0, so its cost is always nums[0]. We only need to choose where the second and third subarrays begin!

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 3, 4, 5]

› Output: 6

💡 Note: Divide into [1], [2], [3, 4, 5]. Costs are 1 + 2 + 3 = 6. This is optimal because we take the three smallest possible starting elements.

example_2.py — Different Values

$ Input: [5, 4, 3]

› Output: 12

💡 Note: Must divide into [5], [4], [3]. Since we need exactly 3 subarrays, costs are 5 + 4 + 3 = 12. No other division is possible with length 3.

example_3.py — Strategic Division

$ Input: [10, 3, 1, 1]

› Output: 12

💡 Note: Optimal division is [10], [3], [1, 1]. Costs are 10 + 3 + 1 = 14. Alternative [10], [3, 1], [1] gives 10 + 3 + 1 = 14. Both are the same optimal cost.

Visualization

Tap to expand

Understanding the Visualization

Understand the Problem

We must create exactly 3 contiguous subarrays, and each subarray's cost is its first element

Identify the Fixed Cost

The first subarray always starts at index 0, so its cost nums[0] is unchangeable

Find Optimal Cuts

We need to place 2 cuts to create 3 pieces. Focus on minimizing the starting elements of pieces 2 and 3

Apply Strategy

For each possible start of the second subarray, find the minimum possible start for the third subarray

Key Takeaway

🎯 Key Insight: Since the first subarray always starts at index 0, focus on finding the optimal positions for the second and third subarrays to minimize their starting element values.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we still need to check all valid combinations, but with optimizations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 50
The array must be divided into exactly 3 non-empty contiguous subarrays

Asked in

G Google 25 a Amazon 20 ⊞ Microsoft 15 f Meta 12

The key insight is that the first subarray always starts at index 0, so its cost is fixed as nums[0]. We only need to choose optimal starting positions for the second and third subarrays. The brute force approach tries all valid combinations in O(n²) time, while the optimized approach finds the minimum in the remaining range for each second subarray position.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass	O(n²)	O(1)	Find the two smallest values in the valid range with one pass
Brute Force (Nested Loops)	O(n²)	O(1)	Try all possible ways to divide the array into 3 subarrays

Optimized Single Pass — Algorithm Steps

The first subarray cost is fixed as nums[0]
We need to find two positions i and j where 1 ≤ i < j ≤ n-1
Scan through indices 1 to n-2 to find the smallest value for the second subarray start
For each position i, find the smallest value from i+1 to n-1 for the third subarray start
Keep track of the minimum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix First Cost

nums[0] is always the cost of first subarray

Try Second Position

For each valid position i, consider nums[i] as second subarray start

Find Min Third

Find minimum value in range [i+1, n-1] for third subarray

Calculate Cost

Sum = nums[0] + nums[i] + min(nums[i+1:])

Update Minimum

Keep track of the overall minimum cost

Code -

solution.c — C

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

int minimumCost(int* nums, int n) {
    int minCost = INT_MAX;
    
    // First subarray cost is fixed
    int firstCost = nums[0];
    
    // Try each position for second subarray start
    for (int i = 1; i < n - 1; i++) {
        // Find minimum in remaining positions for third subarray
        int minThird = INT_MAX;
        for (int j = i + 1; j < n; j++) {
            if (nums[j] < minThird) {
                minThird = nums[j];
            }
        }
        int cost = firstCost + nums[i] + minThird;
        if (cost < minCost) {
            minCost = cost;
        }
    }
    
    return minCost;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    int nums[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    printf("%d\n", minimumCost(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we still need to check all valid combinations, but with optimizations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 50
The array must be divided into exactly 3 non-empty contiguous subarrays

28.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler