[LeetCode 312] Burst Balloons

Given n balloons, indexed from 0 to n-1. Each balloon is painted with a number on it represented by array nums. You are asked to burst all the balloons. If the you burst balloon i you will get nums[left] * nums[i] * nums[right] coins. Here left and right are adjacent indices of i. After the burst, the left and right then becomes adjacent.

Find the maximum coins you can collect by bursting the balloons wisely.

- You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can not burst them.
- 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100

 

Example

Given [4, 1, 5, 10]
Return 270

nums = [4, 1, 5, 10] burst 1, get coins 4 * 1 * 5 = 20
nums = [4, 5, 10]    burst 5, get coins 4 * 5 * 10 = 200 
nums = [4, 10]       burst 4, get coins 1 * 4 * 10 = 40
nums = [10]          burst 10, get coins 1 * 10 * 1 = 10

Total coins 20 + 200 + 40 + 10 = 270

Dynamic Programming Solution

A straightforward solution is to use recursion. Take the given example[4, 1, 5, 10].

The following recursion tree shows that the recursive approach has an overlapping subproblems issue. 

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　4, 1, 5, 10

　　　　　　1, 5, 10　　　　　　　　　　　　4, 5, 10　　　　　　　　　　　　　　　　4, 1, 10, 　　　　　　　　　　　　　　　　4, 1, 5　　　　　　　　

5, 10             1, 10           1, 5　　　　5, 10         4, 10　      4,5　　　　　　　　　1, 10　　4,10　　　4,1　　　　　　　　1,5　　　　4,5　　　　　4,1　

Dynamic Programming Solution

State: T[i][j] stores the max value of bursting ballons i to j and the last ballon that is bursted to get this max.

Function: T[i][j].maxV = max{T[i][k - 1].maxV + T[k + 1][j].maxV + arr[i - 1] * arr[k] * arr[j + 1]};

　　　　 T[i][j].lastBurstIdx is the k in [i, j] that gives the max value to T[i][j].maxV.

Init: T[i][i].maxV = arr[i - 1] * arr[i] * arr[i + 1]; T[i][j].lastBurstIdx = i.

import java.util.Stack;

class Entry {
    int maxV;
    int lastBurstIdx;
    Entry(int v, int i) {
        this.maxV = v;
        this.lastBurstIdx = i;
    }
}
public class BurstBallon {
    private Stack<Integer> burstSeq;
    public int getMaxPoint(int[] arr) {
        burstSeq = new Stack<Integer>();
        if(arr == null || arr.length == 0) {
            return 0;
        }
        Entry[][] T = new Entry[arr.length][arr.length];
        for(int i = 0; i < T.length; i++) {
            for(int j = i; j < T.length; j++) {
                T[i][j] = new Entry(0, -1);
            }
        }
        for(int i = 0; i < T.length; i++) {
            int left = i - 1 >= 0 ? arr[i - 1] : 1;
            int right = i + 1 < T.length ? arr[i + 1] : 1;
            T[i][i].maxV = left * arr[i] * right;
            T[i][i].lastBurstIdx = i;
        }
        for(int len = 2; len <= arr.length; len++) {
            for(int i = 0; i <= arr.length - len; i++) {
                int j = i + len - 1;
                for(int lastBurst = i; lastBurst <= j; lastBurst++) {
                    int outerLeft = (i - 1) >= 0 ? arr[i - 1] : 1;
                    int outerRight = (j + 1) < arr.length ? arr[j + 1] : 1;
                    int midValue = outerLeft * arr[lastBurst] * outerRight;
                    int leftMax = i <= lastBurst - 1 ? T[i][lastBurst - 1].maxV : 0;
                    int rightMax = lastBurst + 1 <= j ? T[lastBurst + 1][j].maxV : 0;
                    int currValue = leftMax + midValue + rightMax;
                    if(currValue > T[i][j].maxV) {
                        T[i][j].maxV = currValue;
                        T[i][j].lastBurstIdx = lastBurst;
                    }
                }
            }
        }
        //reconstruct one burst sequence that gives the best result
        reconstructOneBestSequence(T, 0, arr.length - 1, burstSeq);
        return T[0][arr.length - 1].maxV;
    }
    private void reconstructOneBestSequence(Entry[][] T, int start, int end, Stack<Integer> burstSeq) {
        if(end < start) {
            return;
        }
        burstSeq.push(T[start][end].lastBurstIdx);
        reconstructOneBestSequence(T, start, T[start][end].lastBurstIdx - 1, burstSeq);
        reconstructOneBestSequence(T, T[start][end].lastBurstIdx + 1, end, burstSeq);
    }
    public static void main(String[] args) {
        int[] arr = {4,1,5,10};
        BurstBallon test = new BurstBallon();
        //expect 270
        System.out.println(test.getMaxPoint(arr));
        //expect 1, 2, 0, 3 
        while(!test.burstSeq.isEmpty()) {
            System.out.println(test.burstSeq.pop());
        }
    }
}