Program to find minimum cost to merge stones in Python

The minimum cost to merge stones problem involves merging K consecutive piles of stones into one pile, where the cost equals the total stones in those K piles. We need to find the minimum cost to merge all piles into a single pile.

This is a classic dynamic programming problem that uses interval DP to find the optimal way to merge stone piles.

Understanding the Problem

Given N piles of stones and a merge factor K, we can only merge exactly K consecutive piles at a time. The key insight is that for a solution to exist, we need (n-1) % (k-1) == 0, where n is the number of piles.

Algorithm Steps

The solution uses dynamic programming with the following approach:

• Check if merging is possible using the mathematical condition
• Create a DP table where dp[i][j] represents minimum cost to merge stones from index i to j
• Use prefix sums for quick range sum calculation
• Fill the DP table using interval DP technique

Example

Let's trace through the algorithm with the given example ?

def solve(stones, k):
    n = len(stones)
    
    # Check if solution exists
    if (n - 1) % (k - 1) != 0:
        return -1
    
    # Initialize DP table and prefix sums
    dp = [[0] * n for _ in range(n)]
    prefix_sum = [0] * (n + 1)
    
    # Build prefix sum array
    for i in range(1, n + 1):
        prefix_sum[i] = prefix_sum[i - 1] + stones[i - 1]
    
    # Fill DP table for different lengths
    for length in range(k, n + 1):
        for i in range(n - length + 1):
            j = i + length - 1
            dp[i][j] = float('inf')
            
            # Try all possible split points
            for t in range(i, j, k - 1):
                dp[i][j] = min(dp[i][j], dp[i][t] + dp[t + 1][j])
            
            # If we can merge this range into one pile, add the cost
            if (j - i) % (k - 1) == 0:
                dp[i][j] += prefix_sum[j + 1] - prefix_sum[i]
    
    return dp[0][n - 1]

# Test with the example
stones = [3, 2, 4, 1]
k = 2
result = solve(stones, k)
print(f"Minimum cost to merge stones: {result}")

# Let's trace the merging process
print(f"\nTracing merges for {stones} with k={k}:")
print("Step 1: [3, 2, 4, 1] -> merge [3,2] -> [5, 4, 1] (cost: 5)")
print("Step 2: [5, 4, 1] -> merge [4,1] -> [5, 5] (cost: 5)")  
print("Step 3: [5, 5] -> merge [5,5] -> [10] (cost: 10)")
print("Total cost: 5 + 5 + 10 = 20")

Minimum cost to merge stones: 20

Tracing merges for [3, 2, 4, 1] with k=2:
Step 1: [3, 2, 4, 1] -> merge [3,2] -> [5, 4, 1] (cost: 5)
Step 2: [5, 4, 1] -> merge [4,1] -> [5, 5] (cost: 5)
Step 3: [5, 5] -> merge [5,5] -> [10] (cost: 10)
Total cost: 5 + 5 + 10 = 20

Testing Different Cases

Let's test with different inputs to understand when solutions exist ?

def test_merge_stones():
    test_cases = [
        ([3, 2, 4, 1], 2),
        ([3, 2, 4, 1], 3),
        ([3, 5, 1, 2, 6], 3),
        ([1, 1, 1, 1], 2)
    ]
    
    for stones, k in test_cases:
        result = solve(stones, k)
        print(f"Stones: {stones}, k={k} -> Result: {result}")

test_merge_stones()

Stones: [3, 2, 4, 1], k=2 -> Result: 20
Stones: [3, 2, 4, 1], k=3 -> Result: -1
Stones: [3, 5, 1, 2, 6], k=3 -> Result: 25
Stones: [1, 1, 1, 1], k=2 -> Result: 8

How It Works

The algorithm works by:

• Mathematical Check: First verifies if merging is possible using (n-1) % (k-1) == 0
• Dynamic Programming: Uses interval DP where dp[i][j] stores minimum cost for range [i,j]
• Prefix Sums: Quickly calculates the cost of merging any range of stones
• Optimal Substructure: Builds solution by combining optimal solutions of smaller subproblems

Time Complexity

The time complexity is O(n³/k) where n is the number of stone piles, and space complexity is O(n²) for the DP table.

Conclusion

This dynamic programming solution efficiently finds the minimum cost to merge stone piles by using interval DP and prefix sums. The key insight is checking the mathematical condition for feasibility before attempting to solve.