[leetcode] 312. Burst Balloons 解题报告

题目链接：https://leetcode.com/problems/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: 
(1) You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can not burst them.
(2) 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100

Example:

Given [3, 1, 5, 8]

Return 167

    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

思路：考虑分治法来处理的时候，如果选择以某个气球为分割点，那么其左边部分和右边部分都要依赖与那个气球，因此我们不能让这个气球先爆．也就是说我们选择分割点的时候不是选择先爆的气球，而是最后爆的气球，这样分成的左右两个部分将相互独立．即如果最后只剩下气球i，那么其最后只依赖与第０和ｎ－１个气球，而在[0, i] 和 [i, n-1]两个区间是相互独立的，这样我们就可以将问题分割为相互独立的子集．这样时间复杂为O(n^n). 但是在枚举各个分割点的时候会有很多重复的计算，因此我们可以保存已经计算过的区间．这样时间复杂度可以优化到O(n^3).

同样我们也可以使用动态规划来处理，其原理和分治一样，也是分区间由小到大最后完成整个计算．

两种代码如下：

class Solution {
public:
    int divid(vector<int>& nums, vector<vector<int>>& dp, int low, int high)
    {
        if(low+1 == high) return 0;
        if(dp[low][high] > 0) return dp[low][high];
        int ans = 0;
        for(int i = low+1; i < high; i++)
            ans=max(ans, nums[low]*nums[i]*nums[high]
                + divid(nums, dp, low, i) + divid(nums, dp, i, high));
        dp[low][high] = ans;
        return ans;
    }
    
    int maxCoins(vector<int>& nums) {
        nums.insert(nums.begin(), 1);
        nums.insert(nums.end(), 1);
        vector<vector<int>> dp(nums.size()+1, vector<int>(nums.size()+1, 0));
        return divid(nums, dp, 0, nums.size()-1);
    }
};

class Solution {
public:
    int maxCoins(vector<int>& nums) {
        if(nums.size()==0) return 0;
        nums.insert(nums.begin(), 1);
        nums.insert(nums.end(), 1);
        int len = nums.size();
        vector<vector<int>> dp(len, vector<int>(len, 0));
        for(int i = len-3; i >= 0; i--)
        {
            for(int j = i+2; j < len; j++)
            {
                for(int k = i+1; k < j; k++)
                    dp[i][j]=max(dp[i][j], nums[i]*nums[j]*nums[k]+dp[i][k]+dp[k][j]);
            }
        }
        return dp[0][len-1];
    }
};