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
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个气球开始，到第j个气球，且在这些气球中，最后引爆的是第k个气球，假设气球金币数存在vector<int> nums中，那么可以得到：

maxCoins(i, j) = max(nums[i-1] * nums[k] * nums[j+1] + maxCoins(i, k-1) + maxCoins(k+1, j)) (i<=k<=j)

那么根据这一公式，首先想到使用递归来实现：

int getMax(int start, int end) {
    int maxCoins = 0;
    for (int k = start; k <= end; k++) {
        maxCoins = max(maxCoins, nums[start - 1] * nums[k] * nums[end + 1] + getMax(start, k - 1) + getMax(k + 1, end));
    }
    return maxCoins;
}

但是，由于分治后子问题数量太多，当区间长度很长时，效率非常低下，同一个子问题会被多次计算。因此，考虑使用动态规划，利用一个二维数组matrix[][]来储存子问题的结果，matrix[i][j]代表区间nums[i][j]中所有气球引爆后，能得到的最大金币数。避免多次重复计算。首先写出状态转移方程：

matrix[i][j] = max(matrix[i][j], matrix[i][j] + nums[i-1] * nums[k] * nums[j+1] + matrix[i][k-1] + matrix[k+1][j])

注意在上式中，当i==k-1和j==k+1时，区间金币数为0。
根据这个思路，最后返回matrix[1][n]即可得到所求结果，写出完整代码实现如下：

class Solution {
public:
int maxCoins(vector<int>& nums) {
    nums.insert(nums.begin(), 1);
    nums.push_back(1);
    int size = nums.size() - 2;
    int** matrix = new int*[size + 2];
    for (int i = 0; i < size + 2; i++) {
        matrix[i] = new int[size + 2];
    }
    for (int i = 0; i < size + 2; i++) {
        for (int j = 0; j < size + 2; j++)
            matrix[i][j] = 0;
    }
    for (int len = 1; len <= size; len++) {
        for (int left = 1; left <= size - len + 1; left++) {
            int right = left + len - 1;
            for (int k = left; k <= right; k++) {
                int leftCoins = k > left ? matrix[left][k - 1] : 0;  // left == k-1 时没有左子区间
                int rightCoins = k < right ? matrix[k + 1][right] : 0;  // right == k+1 时没有右子区间
                matrix[left][right] = std::max(matrix[left][right], nums[left - 1] * nums[k] * nums[right + 1] + leftCoins + rightCoins);
            }
        }
    }
    return matrix[1][size];
}
};

注意：

• 该实现中，每次只对matrix右上角三角部分进行更新。
• nums在进行运算前，要在前后分别插入1。

显然，该算法的时间复杂度为O(n^3)，还有改进空间。