312. Burst Balloons

最新推荐文章于 2020-12-06 19:16:38 发布

BigFatSheep

最新推荐文章于 2020-12-06 19:16:38 发布

阅读量307

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode Hard

本文链接：https://blog.youkuaiyun.com/BigFatSheep/article/details/83504745

Leetcode 同时被 2 个专栏收录

385 篇文章

订阅专栏

Hard

51 篇文章

订阅专栏

本文探讨了一种使用动态规划解决气球爆破问题的方法，旨在找到能够获得最大coins数量的爆破顺序。通过添加虚拟头部和尾部元素进行dp操作，详细解释了算法流程和代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description

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:

You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can not burst them.
0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
Example:

Input: [3,1,5,8]
Output: 167
Explanation: nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
coins = 315 + 358 + 138 + 181 = 167

Problem URL

Solution

给一个int数组，表示气球爆了之后能够获得的coins，得到的coins = nums[left] * nums[i] * nums[right] 。寻找能够获得最多coins的顺序，返回能得到的coin数。

Using dynamic programming. We add a to tail and head position to perform dp. dp[][] denotes the conis we could get from left to right. We start the window size with 3, so k = 2. Iterate in the window, from left to right. Return dp[0][n - 1] which means we have find to left and right most out of original nums.

Code

class Solution {
    public int maxCoins(int[] nums) {
        int[] newNums = new int[nums.length + 2];
        int n = 1;
        for (int i : nums){
            newNums[n++] = i;
        }
        newNums[0] = newNums[n++] = 1;
        
        int[][] dp = new int[n][n];
        for (int k = 2; k < n; k++){
            for (int left = 0; left < n - k; left++){
                int right = left + k;
                for (int i = left + 1; i < right; i++){
                    dp[left][right] = Math.max(dp[left][right], 
                    newNums[left] * newNums[i] * newNums[right] + dp[left][i] + dp[i][right]);
                }
            }
        }
        return dp[0][n - 1];
    }
}