leetcode 312. Burst Balloons 气球爆炸计算分数 + 一个按照length做动态规划DP的很棒的做法

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

也就是k点被踩破之前，N1和N2重点的气球都不会相互影响。于是我们就成功构造了子问题。因此分治加dp就可以对问题进行求解了。
写一下状态传递方程：dp[i][j]表示气球i到气球j的最佳coins

感觉和这一道题leetcode 546. Remove Boxes 删除箱子获得最大的分数 + 很复杂的DP + z做不出来很像

dp[left][right] = max{dp[left][right] , nums[left] * nums[i] * nums[right]  +  nums[left] * nums[i]  +  nums[i] * nums[right]}

其中 left<i<right , dp[left][right]即为当前子问题：第left和第right之间位置的气球的maxcoin

就是按照这个转移方程来做，我也是长知识了，这道题很值得学习，是学习DP的一个很好的例子。

注意这个DP的循环是按照len递增的。

/*
 * DP的高级做法，记住这道题吧
 * 也就是k点被踩破之前，N1和N2重点的气球都不会相互影响。于是我们就成功构造了子问题。因此分治加dp就可以对问题进行求解了。
 * 写一下状态传递方程：
 * dp[i][j]表示气球i到气球j的最佳coins
 * dp[left][right] = max{dp[left][right] , 
 * nums[left] * nums[i] * nums[right]  +  nums[left] * nums[i]  +  nums[i] * nums[right]};
 * 其中 left<i<right , dp[left][right]即为当前子问题：第left和第right之间位置的气球的maxcoin。
 * */
class Solution 
{    
    public int maxCoins(int[] nums) 
    {
        if(nums==null || nums.length<=0)
            return 0;

        int[] coins=new int[nums.length+2];
        coins[0]=coins[nums.length+1]=1;
        for(int i=0;i<nums.length;i++)
            coins[i+1]=nums[i];

        int[][] dp=new int[nums.length+2][nums.length+2];
        for(int len=2;len<nums.length+2;len++)
        {
            for(int left=0;left+len<nums.length+2;left++)
            {
                int right=left+len;
                for(int i=left+1;i<right;i++)
                {
                    dp[left][right] = Math.max(dp[left][right],dp[left][i] +coins[left]*coins[i]*coins[right] + dp[i][right]);  
                }
            }
        }
        return dp[0][nums.length+1];
    }
}

下面是C++的做法，就是一个简单的DP动态规划求解的问题，这个问题比较难，很重的学习

代码如下：

#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <stack>
#include <string>
#include <climits>
#include <algorithm>
#include <sstream>
#include <functional>
#include <bitset>
#include <numeric>
#include <cmath>
#include <regex>

using namespace std;


class Solution
{
public:
    int maxCoins(vector<int>& nums) 
    {
        vector<int> a(nums.size() + 2, 0);
        a[0] = a[nums.size() + 1] = 1;
        for (int i = 1; i <= nums.size(); i++)
            a[i] = nums[i - 1];

        vector<vector<int>> dp(a.size(), vector<int>(a.size(), 0));

        for (int len = 2; len < a.size(); len++)
        {
            for (int left = 0; left + len < a.size(); left++)
            {
                int right = left + len;
                for (int i = left + 1; i < right; i++)
                {
                    dp[left][right] = max(dp[left][right], dp[left][i] + a[left] * a[i] *a[right] + dp[i][right]);
                }
            }
        }
        return dp[0][a.size() - 1];
    }
};