312.戳气球

题解：https://qoogle.top/leetcode-312-burst-balloons/

. - 力扣（LeetCode）

正向思考

以 [3, 1, 5][3,1,5] 为例，对于第一次选择，我们有三种选择。

选择 3 将问题分解为左边的子问题： [][] 和 右边子问题： [1, 5][1,5]

其解等于： [] + [1, 5] + 1 * 3 * 1[]+[1,5]+1∗3∗1

选择1 将问题分解为左边的子问题： [3][3] 和 右边子问题： [5][5]

其解等于： [3] + [5] + 3 * 1 * 5[3]+[5]+3∗1∗5

选择5 将问题分解为左边的子问题： [3, 1][3,1] 和 右边子问题： [][]

其解等于： [3, 1] + [] * 1 * 5 * 1[3,1]+[]∗1∗5∗1

发现，上面的解时错的。因为正向思考的情况下，以选择 1 为例，在点爆 1 气球后，两个左右子问题并不是独立的，所以这给计算子问题带来了障碍，怎么处理才能忽略中间的 1 呢？

逆向思考

以 [3, 1, 5][3,1,5] 为例，首先拿一个气球，把这个气球当做最后一个气球，然后点爆它。这样就能够将这个气球的左右两个子问题独立开。

换种方式来说，我们选这1这个气球，然后优先点爆左边和右边的气球之后，再最后点爆这个气嘴，这时可以看出左右两个子问题是独立的，他们只和1这个气球有关联。

定义状态转移方程

dp[i][j] 从 i到 j个气球（闭区间）能够获取的最大的硬币数量

dp[i][j] = dp[i][k - 1] + dp[k + 1][j] + nums[i - 1] * nums[k] * nums[j + 1] (i <= k <= j)

这种方式仍然是O(n!)，但是由于利用了“记忆化”的特性，将重复的子问题写在了内存中，保证每一种子问题只计算一遍。这时能够通过，但是还可以优化。

class Solution {
private:
    vector<vector<int>> dp;
    int helper(vector<int>& nums, int i, int j) {
        // boundary
        if (i > j) return 0;
        if (dp[i][j] > 0) return dp[i][j];
        
        // search
        for (int k = i; k <= j; ++k) {
            int left = helper(nums, i, k - 1);
            int right = helper(nums, k + 1, j);
            int delta = nums[k] * nums[i - 1] * nums[j + 1];
            dp[i][j] = max(dp[i][j], left + right + delta);
        }
        return dp[i][j];
    }
public:
    int maxCoins(vector<int>& nums) {
        int n = nums.size();
        nums.insert(nums.begin(), 1);
        nums.push_back(1);
        dp = vector<vector<int>>(n + 2, vector<int>(n + 2, 0));
        int ans = helper(nums, 1, n);
        return ans;
    }
};

class Solution {
public:
    /**
     * @param nums: A list of integer
     * @return: An integer, maximum coins
     */
    int maxCoins(vector<int> &nums) {
        // write your code here
        if (nums.size() <= 0) {
            return 0;
        }
        int size = nums.size()+2;
        nums.insert(nums.begin(), 1);
        nums.push_back(1);
        // i,j之间的吹爆的和是多少，不包含i，j位置
        std::vector<std::vector<int>> dp(size, std::vector<int>(size, 0));
        for (int len = 3; len <= nums.size(); ++len) {
            for (int i = 0; i + len - 1 < nums.size(); ++i) {
                int j = i + len - 1;
                for (int k = i+1; k < j; ++k) {
                    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j] + nums[i] * nums[k] * nums[j]);
                }
            }
        }
        return dp[0][size-1];
    }
};