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.

Note:

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:

Input: [3,1,5,8]
Output: 167
Explanation: nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
coins = 3 * 1 * 5 + 3 * 5 * 8 + 1 * 3 * 8 + 1 * 8 * 1 = 167

扎气球的游戏，每个气球上写的有coin数，每次扎破的时候可以得到扎破的气球* 它左边 * 它右边的coin奖励，问采用怎样的扎破顺序可以得到最大的coin

在只有一个气球的时候默认它左边右边都是coin=1

思路：
先把左右两端默认的1补上作padding
[3, 1, 5, 8]补成[1, 3, 1, 5, 8, 1]

然后选一个左端的气球，选一个右端的气球，在它们中间可以选择任意一个不被扎破
比如选左边是3，右边是8，那么中间有两种选择，可以不扎1，或者不扎5
不扎1的时候，1留到最后，就先扎5，先得到扎5的coin
然后得到3* 1 * 8 + 扎5得到的coin

同理如果不扎5，5留到最后，就先扎1，得到扎1的coin
然后得到3* 5* 8 + 扎1得到的coin

所以把从left到right的气球可以得到的coin定义成dp
中间从左到右选择一个mid，即保留到最后的那个
coin[left][right] =
coin[left][mid - 1] + coin[mid + 1][right] + nums[left - 1] * nums[mid] * nums[right + 1]

mid: 保留到最后
left-1, left, … mid- 1, mid, mid + 1, …,right, right + 1

刚开始先算长度为1的，即只有1个气球，然后慢慢增加长度，直到长度为nums.length

// 8ms
    int maxCoins(vector<int>& nums) {
        if (nums.empty()) {
            return 0;
        }
        
        int bal_num = nums.size();
        
        nums.insert(nums.begin() , 1);
        nums.push_back(1);
        
        //dp..      
        vector<vector<int>> coins(bal_num + 2, vector<int>(bal_num + 2, 0));
        
        for (int len = 1; len <= bal_num; len++) {
            for (int left = 1; left <= bal_num - len + 1; left++) {
                int right = left + len - 1;
                for (int mid = left; mid <= right; mid++) {
                    coins[left][right] = max(coins[left][right],
                           coins[left][mid - 1] + coins[mid + 1][right] + nums[left - 1] * nums[mid] * nums[right + 1]); 
                }
            }
        }
        
        return coins[1][bal_num];
    }

java版

    public int maxCoins(int[] nums) {
        if(nums == null || nums.length == 0) {
            return 0;
        }
        
        int n = nums.length;
        int[][] dp = new int[n+2][n+2];
        
        //区间段的长度
        for(int len = 1; len <= n; len++) {
            for(int left = 1; left <= n - len + 1; left++) {
                int right = left + len - 1;
                for(int mid = left; mid <= right; mid ++) {
                //nums的index从0开始，left从1开始，要left-1对应nums的index，同理right，mid
                    int leftBorder = (left == 1) ? 1 : nums[left - 2];
                    int rightBorder = (right == n) ? 1 : nums[right];
                    //选不同的mid分别算出所有的dp[left][right],取最大的
                    dp[left][right] = Math.max(dp[left][right], 
                            dp[left][mid-1] + leftBorder * nums[mid-1] * rightBorder
                                    + dp[mid+1][right]);
                }
            }
        }
        
        return dp[1][n];
    }