Minimum Cost to Divide Array Into Subarrays

Minimum Cost to Divide Array Into Subarrays - Problem

You are given two integer arrays, nums and cost, of the same size, and an integer k.

You can divide nums into subarrays. The cost of the i-th subarray consisting of elements nums[l..r] is:

(nums[l] + nums[l+1] + ... + nums[r] + k * i) * (cost[l] + cost[l+1] + ... + cost[r])

Note that i represents the order of the subarray: 1 for the first subarray, 2 for the second, and so on.

Return the minimum total cost possible from any valid division.

Input & Output

Example 1 — Basic Division

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

› Output: 24

💡 Note: Optimal division: [1] | [3] | [2]. First subarray: (1+1*1)*2 = 4. Second subarray: (3+1*2)*3 = 15. Third subarray: (2+1*3)*1 = 5. Total: 4+15+5 = 24.

Example 2 — Single Element

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

› Output: 16

💡 Note: Only one way to divide: single subarray [5]. Cost = (5 + 3*1) * 2 = 8 * 2 = 16

Example 3 — All Separate vs Together

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

› Output: 10

💡 Note: Option 1: [1] | [1] gives (1+2*1)*1 + (1+2*2)*1 = 3 + 5 = 8. Option 2: [1,1] gives (1+1+2*1)*2 = 4*2 = 8. Both give same result.

Constraints

1 ≤ nums.length ≤ 1000
nums.length == cost.length
-1000 ≤ nums[i] ≤ 1000
1 ≤ cost[i] ≤ 1000
1 ≤ k ≤ 1000

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 A Amazon 6

This problem requires dynamic programming to find the optimal way to partition an array. The key insight is that each subarray's cost depends on both its content and its position in the sequence. The memoization approach with O(n²) time complexity provides the best balance of efficiency and clarity.

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n²) Space: O(n)

Use a DP table where dp[i] represents minimum cost to divide nums[0..i-1]. For each position, try all possible previous division points.

Brute Force Recursion

⏱️ Time: O(2ⁿ) Space: O(n)

For each position, try making a cut or continuing the current subarray. Recursively explore all possibilities and return the minimum cost.

Dynamic Programming with Memoization

⏱️ Time: O(n²) Space: O(n²)

Same recursive approach as brute force, but store results of subproblems in a memo table to avoid redundant calculations.

Bottom-Up Dynamic Programming — Algorithm Steps

Create DP array where dp[i] = min cost for nums[0..i-1]
For each position i, try all possible start positions j
Calculate cost of subarray nums[j..i-1] as k-th subarray
Update dp[i] with minimum cost

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create table for all positions and subarray counts

Fill Table

For each cell, try all possible previous divisions

Find Minimum

Return minimum cost across all possible divisions

Code -

solution.c — C

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

#define min(a,b) ((a)<(b)?(a):(b))

long long solution(int* nums, int* cost, int n, int k) {
    if (n == 0) return 0;
    
    long long* numsPrefix = (long long*)calloc(n + 1, sizeof(long long));
    long long* costPrefix = (long long*)calloc(n + 1, sizeof(long long));
    
    for (int i = 0; i < n; i++) {
        numsPrefix[i + 1] = numsPrefix[i] + nums[i];
        costPrefix[i + 1] = costPrefix[i] + cost[i];
    }
    
    long long** dp = (long long**)malloc((n + 1) * sizeof(long long*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (long long*)malloc((n + 1) * sizeof(long long));
        for (int j = 0; j <= n; j++) {
            dp[i][j] = LLONG_MAX;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++) {
            for (int prev = j - 1; prev < i; prev++) {
                if (dp[prev][j - 1] != LLONG_MAX) {
                    long long numsSum = numsPrefix[i] - numsPrefix[prev];
                    long long costSum = costPrefix[i] - costPrefix[prev];
                    long long subarrayCost = (numsSum + (long long)k * j) * costSum;
                    dp[i][j] = min(dp[i][j], dp[prev][j - 1] + subarrayCost);
                }
            }
        }
    }
    
    long long result = LLONG_MAX;
    for (int j = 1; j <= n; j++) {
        result = min(result, dp[n][j]);
    }
    
    free(numsPrefix);
    free(costPrefix);
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100], cost[100], n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL && n < 100) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    fgets(line, sizeof(line), stdin);
    int costCount = 0;
    token = strtok(line, "[],\n");
    while (token != NULL && costCount < 100) {
        if (strlen(token) > 0 && token[0] != ' ') {
            cost[costCount++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%lld\n", solution(nums, cost, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop runs n times, inner loop runs up to n times for each position

✓ Linear Growth

Space Complexity

O(n)

DP array of size n plus prefix sum arrays

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler