168. 吹气球

168. 吹气球

中文English

有n个气球，编号为0到n-1，每个气球都有一个分数，存在nums数组中。每次吹气球i可以得到的分数为 nums[left] * nums[i] * nums[right]，left和right分别表示i气球相邻的两个气球。当i气球被吹爆后，其左右两气球即为相邻。要求吹爆所有气球，得到最多的分数。

样例

样例 1:

输入：[4, 1, 5, 10]
输出：270
解释：
nums = [4, 1, 5, 10] 吹爆 1, 得分 4 * 1 * 5 = 20
nums = [4, 5, 10]   吹爆 5, 得分 4 * 5 * 10 = 200 
nums = [4, 10]   吹爆 4, 得分 1 * 4 * 10 = 40
nums = [10]   吹爆 10, 得分 1 * 10 * 1 = 10
总得分 20 + 200 + 40 + 10 = 270

样例 2:

输入：[3,1,5]
输出：35
解释：
nums = [3, 1, 5] 吹爆 1, 得分 3 * 1 * 5 = 15
nums = [3, 5] 吹爆 3, 得分 1 * 3 * 5 = 15
nums = [5] 吹爆 5, 得分 1 * 5 * 1 = 5
总得分 15 + 15 + 5  = 35

注意事项

1. 你可以假设nums[-1] = nums[n] = 1。-1和n位置上的气球不真实存在，因此不能吹爆它们。
2. 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100

输入测试数据 (每行一个参数)如何理解测试数据？

DP +  记忆化搜索

class Solution:
    """
    @param nums: A list of integer
    @return: An integer, maximum coins
    """

    def memorysearch(self, nums, dp, visit, left, right):
        if visit[left][right]:
            return dp[left][right]
        
        #全局
        max_value = 0 
        #循环找到中间吹气球的最大价值
        for index in range(left, right):
            print(left, right, index)
            #left和right的价值均会找完，然后给max_value赋值，表示的值在当前left,right范围找完当前index索引的两边和当前的价值，才会给max_value赋值
            left_value = self.memorysearch(nums, dp, visit, left, index - 1)
            right_value = self.memorysearch(nums, dp, visit, index + 1, right)
            #比如4 2 3 1 10 ，如果当前index索引的值为3，打包的范围是在[2, 3 , 1]，而2和1左右的价值分别打包，则均消失了，就留下了[4, 3, 10],则最后这个气球的价值为
            #左边边缘*cur*右边边缘,注意，如果左右的范围，两边气球均消失，则最终只会留下当前气球，和左右最边缘的气球
            cur_value = nums[index]*nums[left - 1]*nums[right + 1]
            #注意，如果是index为1的话，则进来，直接取nums[index]*两边边缘的价值,max_value则就是当前1的价值了,第一个气球价值
            max_value = max(max_value, cur_value + left_value + right_value)
        
        visit[left][right] = True
        dp[left][right] = max_value
        
        return max_value

    def maxCoins(self, nums):
        # write your code here
        #动态规划 + 记忆化搜索 + 区间型
        
        if not nums: return 0 
        
        #避免两边没有被打包
        values = [1, *nums, 1]
        length = len(values)
        visit = [[False for _ in range(length)]]*length
        dp = [[0 for _ in range(length)]]*length
        
        
        return self.memorysearch(values, dp, visit, 1, length - 2)

注：lintcode未通过,折腾了太久，还是懵的状态