Minimum Cost to Merge Stones

Minimum Cost to Merge Stones - Problem

There are n piles of stones arranged in a row. The i-th pile has stones[i] stones.

A move consists of merging exactly k consecutive piles into one pile, and the cost of this move is equal to the total number of stones in these k piles.

Return the minimum cost to merge all piles of stones into one pile. If it is impossible, return -1.

Input & Output

Example 1 — Basic Case

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

› Output: 20

💡 Note: Merge [3,2] for cost 5 → [5,4,1]. Merge [4,1] for cost 5 → [5,5]. Merge [5,5] for cost 10. Total: 5+5+10=20

Example 2 — Impossible Case

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

› Output: -1

💡 Note: Cannot merge 4 piles into 1 with k=3. Need (n-1) % (k-1) = 0, but (4-1) % (3-1) = 1 ≠ 0

Example 3 — Single Pile

$ Input: stones = [3,5,1,2,6], k = 3

› Output: 25

💡 Note: Merge [3,5,1] for cost 9 → [9,2,6]. Merge [9,2,6] for cost 17. Total: 9+17=26. Wait, optimal is different - need to find minimum path

Constraints

n == stones.length
1 ≤ n ≤ 30
1 ≤ stones[i] ≤ 100
2 ≤ k ≤ n

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is that merging n piles into 1 pile is only possible when (n-1) % (k-1) == 0. Use interval dynamic programming with dp[i][j] representing minimum cost to merge stones[i..j] optimally. Best approach combines bottom-up DP with prefix sums. Time: O(n³), Space: O(n²)

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Uses bottom-up approach with optimized state representation. Instead of tracking pile count explicitly, we use the mathematical property that merging is only possible when ranges satisfy certain conditions.

Recursive Backtracking

⏱️ Time: O(k^n) Space: O(n)

For each possible group of k consecutive piles, try merging them and recursively solve for the remaining configuration. This explores all possible merge sequences.

Top-Down Dynamic Programming

⏱️ Time: O(n³ × k) Space: O(n² × k)

Enhanced recursive solution that caches results of merging specific ranges. Uses interval DP where dp[i][j][p] represents minimum cost to merge stones[i..j] into p piles.

Bottom-Up Dynamic Programming — Algorithm Steps

Build prefix sum array for range sum queries
Initialize DP table for base cases
Fill table for increasing range lengths
Use prefix sums to calculate merge costs efficiently

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[i][i] = 0 for single stones

Fill Table

Process ranges of increasing length

Final Answer

dp[0][n-1] contains the minimum cost

Code -

solution.c — C

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

int solution(int* stones, int n, int k) {
    if ((n - 1) % (k - 1) != 0) {
        return -1;
    }
    
    int* prefix = (int*)malloc((n + 1) * sizeof(int));
    prefix[0] = 0;
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + stones[i];
    }
    
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    
    // Base case: single stones
    for (int i = 0; i < n; i++) {
        dp[i][i] = 0;
    }
    
    // Fill for increasing lengths
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            
            // Try all possible ways to merge into k-1 groups first
            for (int mid = i; mid < j; mid += k - 1) {
                if (dp[i][mid] != INT_MAX && dp[mid + 1][j] != INT_MAX) {
                    int cost = dp[i][mid] + dp[mid + 1][j];
                    if (cost < dp[i][j]) {
                        dp[i][j] = cost;
                    }
                }
            }
            
            // If we can merge this range into k-1 groups, we can merge into 1 group
            if ((j - i) % (k - 1) == 0 && dp[i][j] != INT_MAX) {
                dp[i][j] += prefix[j + 1] - prefix[i];
            }
        }
    }
    
    int result = dp[0][n - 1];
    
    // Clean up memory
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    free(prefix);
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int stones[100];
    int n = 0;
    
    // Parse the array format [3,2,4,1]
    char* p = line;
    // Find the opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers until closing bracket
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse the number
        char* end;
        int num = (int)strtol(p, &end, 10);
        if (end != p) {
            stones[n++] = num;
            p = end;
        } else {
            p++;
        }
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(stones, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops for start position, end position, and split point

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table stores results for all range combinations

⚠ Quadratic Space

23.4K Views

Medium Frequency

~35 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

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler