[LintCode] Stone Game

There is a stone game.At the beginning of the game the player picks n piles of stones in a line.

The goal is to merge the stones in one pile observing the following rules:

1. At each step of the game,the player can merge two adjacent piles to a new pile.
2. The score is the number of stones in the new pile.

You are to determine the minimum of the total score.

Example

For [4, 1, 1, 4], in the best solution, the total score is 18:

1. Merge second and third piles => [4, 2, 4], score +2
2. Merge the first two piles => [6, 4]，score +6
3. Merge the last two piles => [10], score +10

Other two examples:
[1, 1, 1, 1] return 8
[4, 4, 5, 9] return 43

From the given example[4, 1, 1, 4] it looks like a greedy alogrithm of always picking two piles with smaller values

should solve this problem. However, as most of the time that an obvious greedy alogrithm is incorrect, this time is

no exception.

Counter example: [6, 4, 4, 6]

If we pick 4 + 4, score = 8, [6, 8, 6]

then we pick 6 + 8, score = 22, [14, 6]

finally we pick 14 + 6, score = 42.

If we pick 6 + 4, score = 10, [10, 4, 6]

then we pick 4 + 6 = 10, score = 20, [10, 10]

finally we pick 10 + 10, score = 40. 

First thought: Recursion

for all stones A[0]....A[n - 1], we can solve this problem using the following formula.

f(0, n - 1) = min{f(0, k) + f(k + 1, n - 1) + sum[0... n - 1]}, for all k: [0, n - 2]

Using this formula, we can recursively solve all subproblems.

Alert:  do we have the overlapping subproblems issue?

Yes, we do have. 

For example: to solve f(0, 4), we have to solve f(0, 0), f(1, 4), f(0, 1), f(2, 4), f(0, 2), f(3, 4), f(0, 3), f(4, 4)

　　　　　　   to solve f(0, 3), we have to solve f(0, 0), f(1, 3), f(0, 1), f(2, 3), f(0, 2), f(3, 3)

The subproblems in red are redundantly computed. 

So there is the all-mighty dynamic programming solution.

State:

dp[i][j] represents the min cost of merging A[i...j];

Function:

dp[i][j] = min{dp[i][k] + dp[k + 1][j] + prefixSum[j + 1] - prefixSum[i]} for all k: [i, j - 1]

Initialization:

dp[i][i] = 0;

dp[i][j] = Integer.MAX_VALUE for all j > i;

prefixSum[i]: the sum of the first ith elements of A;

Answer:

dp[0][A.length - 1];

Runtime: O(n^2)   n - 1 + n - 2 + n - 3 + ...... + 1, for each fixed length len, we have n - len + 1 different start positions.

Space: O(n^2)

This problem is different with typical dp problems in the for-loop.

To correctly solve this problem, we must solve all subproblems of smaller length. 

As a result, instead of the typical for loop as shown in the following incorrect 

solution, we need to do a for loop with subproblem's length and its start index.

For example, in the incorrect solution, to solve dp[0][3], we need to solve

dp[0][0], dp[1][3], dp[0][1], dp[2][3], dp[0][2], dp[3][3].

But when trying to solve dp[0][3], i == 0, dp[1][3] and dp[2][3] have not been

solved yet!!

But if we first solve smaller subproblems of length 2 and 3, we can then solve 

dp[0][3] of length 4 correctly.

length 2: dp[0][1]  dp[2][3]

length 3: dp[1][3]  dp[0][2]

Incorrect bottom up dp algorithm

public class Solution {
    public int stoneGame(int[] A) {
        if(A == null || A.length <= 1){
            return 0;
        }
        int[] prefixSum = new int[A.length + 1];
        for(int i = 1; i <= A.length; i++){
            prefixSum[i] = prefixSum[i - 1] + A[i - 1];
        }
        int[][] dp = new int[A.length][A.length];
        for(int i = 0; i < A.length - 1; i++){
            for(int j = i + 1; j < A.length; j++){
                dp[i][j] = Integer.MAX_VALUE;
            }
        }
        for(int i = 0; i < A.length; i++){
            dp[i][i] = 0;
        }
        for(int i = 0; i < A.length - 1; i++){
            for(int j = i + 1; j < A.length; j++){
                for(int k = i; k < j; k++){
                    dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k + 1][j] + prefixSum[j + 1] - prefixSum[i]);
                }
            }
        }
        return dp[0][A.length - 1];
    }
}

Correct bottom up dp solution 

public class Solution {
    public int stoneGame(int[] A) {
        if(A == null || A.length <= 1){
            return 0;
        }
        int[] prefixSum = new int[A.length + 1];
        for(int i = 1; i <= A.length; i++){
            prefixSum[i] = prefixSum[i - 1] + A[i - 1];
        }
        int[][] dp = new int[A.length][A.length];
        for(int i = 0; i < A.length - 1; i++){
            for(int j = i + 1; j < A.length; j++){
                dp[i][j] = Integer.MAX_VALUE;
            }
        }
        for(int i = 0; i < A.length; i++){
            dp[i][i] = 0;
        }
        for(int len = 2; len <= A.length; len++){
            for(int start = 0; start + len - 1 < A.length; start++){
                int end = start + len - 1;
                for(int k = start; k < end; k++){
                    dp[start][end] = Math.min(dp[start][end], 
                                     dp[start][k] + dp[k + 1][end] + prefixSum[end + 1] - prefixSum[start]);
                }
            }
        }
        return dp[0][A.length - 1];
    }
}

Related Problems

Stone Game II

Minimum Cost to Merge Stones (Generalized version)