Leetcode (312) Burst Balloons

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:
(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

• 题意：给定一组数字，在不改变数字的顺序的情况下，可以将相邻的三个数相乘，得到一个积的同时，将中间的那个数从数组中删除，数组中数字的先后顺序不变。不断地进行这种操作（可以想象数组的开头前和末尾后各有一个1），求这样的操作能使得积的和的最大值是多少。

• 思路：

  1. 直观思路，利用计算机的高速运算能力，暴力求解。但是，如果暴力枚举去掉数组中的每一位数，递归求解，考虑到若是要在去掉的数字在中间，那么就要将数组分为前后两个部分分别计算了，因此，算法复杂度的递推公式约为 $$F(n) = \sum_{i=1}^{n}F(i-1)+F(n-i-1)$$ ，求解起来必然是指数级的算法复杂度。
  2. 观察式子，可以看到，枚举每个位置之后，实际上这是一种分治的思想，目的是将长的式子分为短的式子去计算。但是，又因为它有枚举的成分在里面，因此不能算是一个完全的分治算法运用。
  3. 另一方面，若是想象这样的枚举之后再递归，展开成若干棵递归树（递归森林=_=），实际上有许多分支是完全相同的，但是在算法过程中依然算了若干多遍，进而回想起斐波那契数的递归计算方法中，也会遇到同样的问题，而解决方法也很简单，就是事先记住已经算过的数，等到要用的时候，就可以避免重复计算了。其实，这是一种以空间换时间的记忆化搜索方法。
  4. 因此，若是加上下标，算法复杂度的的递归公式可以改写为 $$F_{index}(n) = \max_{i=1}^{n}F_{index}(i-1)+F_{index+i+1}(n-i-1)$$
  5. 算法复杂度方面，考虑递归森林，估算约为 $$O(n^3)$$ （应该是吧。。。），1s勉强能过。。。

class Solution {
private:
    int a[1000][1000];
    int daq(vector<int>&nums,int l , int r)
    {
        if (a[l][r]!=-1) return a[l][r];
        int ans=0;
        for (int mid=l+1;mid<r;mid++)
            ans = max(ans,nums[l]*nums[mid]*nums[r]+daq(nums,l,mid)+daq(nums,mid,r));
        a[l][r] = ans;
        return ans;
    }
public:
    int maxCoins(vector<int>& nums) {
        memset(a,-1,sizeof(a));
        vector<int> coins;
        coins.push_back(1);
        for (auto item:nums) coins.push_back(item);
        coins.push_back(1);
        return daq(coins,0,coins.size()-1);
    }
};

• 另一种思路：
  
  1. 既然提到记忆化搜索，那么这样的算法，就很可能用转化成动态规划的问题来解决了，同时，因为记忆化搜索算法常常会使用递归（如上），速度上一般比不上不会使用递归的动态规划方法，但是，有时候，由于这样的记忆化搜索方法，根据分治的思想，其实可以很快地写出简短而又正确率高的解决方法来，这算是一种优势，而优化的方向之一就是转化成动态规划来解决了。
  2. 接下来就是考虑动态规划的状态转移方程，注意到，记忆化搜索是一个自顶而下的过程，而动态规划要保证状态的转移，那么就要是一个自下而上的过程，也就是说求解的子数组长度要从1开始直到原数组长度。于是，可以得到方程： $$dp_{from, to} = max_{i=from}^{to} {dp_{from, i-1}+coins_{left-1}*coins_{i}*coins_{right+1} + dp_{i+1, to}}$$ （写的有点乱，代码比较直观。不过其中有一个细节在于，因为枚举起来相当于一个滑块从数组开头开始往后滑，因此，中间断开的位置的数，应该是和滑块开始前一个数和滑块末尾后一个数相乘，而不是断开的前后）
  3. 算法复杂度方面依然是 $$O(n^3)$$ ，但是去除了递归，优化效果应该不错。

class Solution {
public:
    int maxCoins(vector<int>& nums) {
        memset(dp, 0, sizeof(dp));
        int n = nums.size();
        vector<int> coins;
        coins.push_back(1);
        for (auto coin: nums) coins.push_back(coin);
        coins.push_back(1);
        for (int len=1;len<=n;++len)
        {
            for (int from=1;from<=n-len+1;from++)
            {
                int to=from+len-1;
                for (int del=from;del<=to;++del)
                {
                    dp[from][to] = max(dp[from][to], dp[from][del-1]+coins[from-1]*coins[del]*coins[to+1]+dp[del+1][to]);
                }
            }
        }
        return dp[1][n];
    }
private:
#define MAXN 500+5
    int dp[MAXN][MAXN];
};