Minimum Cost to Merge Stones - Practice Coding Problems

Minimum Cost to Merge Stones - Problem

Minimum Cost to Merge Stones

You're given n piles of stones arranged in a row, where the i-th pile contains stones[i] stones. Your task is to merge all piles into a single pile with minimum cost.

📋 Rules:
• Each move merges exactly k consecutive piles into one pile
• The cost of merging equals the total stones in those k piles
• You must merge ALL piles into ONE final pile

🎯 Goal: Return the minimum cost to merge all stones, or -1 if impossible.

Example: With stones = [3,2,4,1] and k = 2:
• Merge piles 1&2: cost = 3+2 = 5, result = [5,4,1]
• Merge piles 1&2: cost = 5+4 = 9, result = [9,1]
• Merge piles 1&2: cost = 9+1 = 10, result = [10]
• Total cost = 5+9+10 = 24

Input & Output

example_1.py — Basic Case

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

› Output: 20

💡 Note: Step 1: Merge piles 1&2: [3,2,4,1] → [5,4,1], cost = 5. Step 2: Merge piles 2&3: [5,4,1] → [5,5], cost = 9. Step 3: Merge piles 1&2: [5,5] → [10], cost = 10. Total cost = 5 + 9 + 10 = 24. But there's an optimal path: Step 1: [3,2,4,1] → [3,6,1], cost = 6. Step 2: [3,6,1] → [9,1], cost = 9. Step 3: [9,1] → [10], cost = 10. Total = 20.

example_2.py — Impossible Case

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

› Output: -1

💡 Note: With k=3, we need to merge 3 piles at a time. Starting with 4 piles, after one merge we have 2 piles. But we can't merge 2 piles with k=3. The feasibility condition (n-1) % (k-1) = (4-1) % (3-1) = 3 % 2 = 1 ≠ 0, so it's impossible.

example_3.py — Single Pile

$ Input: stones = [6], k = 3

› Output: 0

💡 Note: Already have just one pile, so no merging needed. Cost is 0.

Constraints

1 ≤ stones.length ≤ 30
1 ≤ stones[i] ≤ 100
2 ≤ k ≤ stones.length
Key constraint: Solution exists only if (n-1) % (k-1) == 0

Visualization

Tap to expand

Understanding the Visualization

Check Feasibility

Verify that merging is mathematically possible using (n-1) % (k-1) == 0

Build Prefix Sums

Create prefix sum array for O(1) range sum queries during DP

Initialize Base Cases

Single piles (dp[i][i][1]) require 0 cost to 'merge' into 1 pile

Fill DP Table

For each interval [i,j], compute minimum cost to create p piles

Merge to One Pile

To get 1 pile from interval [i,j]: first create k piles, then merge them

Key Takeaway

🎯 Key Insight: This is an interval DP problem where we must first verify feasibility using (n-1) % (k-1) == 0, then use 3D dynamic programming to track the minimum cost of merging any subrange into any number of piles, ultimately building up to the answer.

Asked in

G Google 25 a Amazon 18 f Meta 12 Apple 8

The optimal solution uses 3D Dynamic Programming with time complexity O(n³×k). First check feasibility: (n-1) % (k-1) == 0. Then use dp[i][j][p] to represent the minimum cost to merge stones[i:j+1] into p piles. The key insight is that to merge into 1 pile, we must first create k piles, then merge those k piles into 1 with cost = sum of all stones in the range.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Enumeration)	O(k^n)	O(n)	Try all possible merge sequences recursively without memoization
3D Dynamic Programming (Optimal)	O(n³ × k)	O(n² × k)	Use interval DP with memoization to solve overlapping subproblems efficiently

Brute Force (Recursive Enumeration) — Algorithm Steps

Check if merging is possible: (n-1) % (k-1) == 0
For each possible position, try merging k consecutive piles
Recursively solve for the resulting smaller array
Take the minimum cost among all possibilities
Base case: when only one pile remains, cost is 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array [3,2,4,1], k=2

Try All Positions

At each level, try merging k consecutive piles at every valid position

Recursive Exploration

Recursively solve each resulting subproblem

Take Minimum

Among all explored paths, return the minimum cost

Code -

solution.c — C

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

int helper(int* arr, int size, int k) {
    if (size == 1) {
        return 0;
    }
    
    int minCost = INT_MAX;
    for (int i = 0; i <= size - k; i++) {
        int cost = 0;
        for (int j = i; j < i + k; j++) {
            cost += arr[j];
        }
        
        int* newArr = (int*)malloc((size - k + 1) * sizeof(int));
        int idx = 0;
        for (int j = 0; j < i; j++) {
            newArr[idx++] = arr[j];
        }
        newArr[idx++] = cost;
        for (int j = i + k; j < size; j++) {
            newArr[idx++] = arr[j];
        }
        
        int totalCost = cost + helper(newArr, size - k + 1, k);
        if (totalCost < minCost) {
            minCost = totalCost;
        }
        
        free(newArr);
    }
    
    return minCost;
}

int mergeStones(int* stones, int stonesSize, int k) {
    if ((stonesSize - 1) % (k - 1) != 0) {
        return -1;
    }
    
    return helper(stones, stonesSize, k);
}

int main() {
    int stones[] = {3, 2, 4, 1};
    int k = 2;
    printf("%d\n", mergeStones(stones, 4, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n)

At each step we try k different positions, and depth is roughly n, leading to exponential complexity

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is at most n levels deep

⚡ Linearithmic Space

28.4K Views

Medium Frequency

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

Brute Force (Recursive Enumeration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler