【Leetcode】312. Burst Balloons

题目地址:

https://leetcode.com/problems/burst-balloons/

给定一个数组 A A A A [ i ] A[i] A[i]代表下标为 i i i的气球所带的权值。可以按某种顺序戳破气球,每次戳破气球之后,会得到一个分数,这个分数等于 A [ i ] A[i] A[i]与其左边最近的未戳破的气球的权值的乘积再乘以其右边最近的未戳破的气球的权值。如果要戳的气球刚好在边上,则设想边界上有一个权值为 1 1 1的气球即可。问最多能得多少分。

法1:记忆化搜索。先把 A A A的左右两边都添上一个 1 1 1,接着设 f [ i ] [ j ] f[i][j] f[i][j]为戳破 A [ i , . . . , j ] A[i,...,j] A[i,...,j]之后所能得到的最大分数。按照最后戳破的气球是哪个,可以进行分类。那么有 f [ i ] [ j ] = max ⁡ t ∈ { i , i + 1 , . . . , j } { f [ i ] [ t − 1 ] + f [ t + 1 ] [ j ] + A [ t ] A [ i − 1 ] A [ j + 1 ] } f[i][j]=\max_{t\in\{i,i+1,...,j\}}\{f[i][t-1]+f[t+1][j]+A[t]A[i-1]A[j+1]\} f[i][j]=t{i,i+1,...,j}max{f[i][t1]+f[t+1][j]+A[t]A[i1]A[j+1]}最后返回 f [ 1 ] [ n ] f[1][n] f[1][n]即可, n n n为原先气球总数。代码如下:

import java.util.Arrays;

public class Solution {
    public int maxCoins(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int len = nums.length;
        
        // 先把nums左右两边都加上一个1
        int[] tmp = new int[len + 2];
        tmp[0] = tmp[len + 1] = 1;
        for (int i = 1; i <= len; i++) {
            tmp[i] = nums[i - 1];
        }
        nums = tmp;
        
        // 开一个数组,代表上面所说的f,初始化为-1
        int[][] dp = new int[len + 2][len + 2];
        for (int[] row : dp) {
            Arrays.fill(row, -1);
        }
        
        return dfs(1, len, nums, dp);
    }
    
    private int dfs(int l, int r, int[] nums, int[][] dp) {
        if (l > r) {
            return 0;
        }
        
        // 有记忆则返回记忆
        if (dp[l][r] != -1) {
            return dp[l][r];
        }
        
        // base case是区间里只有一个气球
        if (l == r) {
            dp[l][l] = nums[l - 1] * nums[l] * nums[l + 1];
            return dp[l][l];
        }
        
        // 开始枚举最后一个被戳破的气球编号
        int res = 0;
        for (int i = l; i <= r; i++) {
            int left = dfs(l, i - 1, nums, dp), right = dfs(i + 1, r, nums, dp);
            res = Math.max(res, left + right + nums[i] * nums[l - 1] * nums[r + 1]);
        }
        
        // 返回前做记忆
        dp[l][r] = res;
        return res;
    }
}

时间复杂度 O ( n 3 ) O(n^3) O(n3),空间 O ( n 2 ) O(n^2) O(n2)。由于有记忆,所以dp数组里每个位置最多只会算一次,调用记忆的时候会节省很多时间。

法2:动态规划。思路和上面一样,只不过写成递推的形式。代码如下:

public class Solution {
    public int maxCoins(int[] nums) {
        int size = nums.length;
        
		// 先把nums左右两边都加上一个1
        int[] tmp = new int[size + 2];
        tmp[0] = tmp[size + 1] = 1;
        for (int i = 1; i <= size; i++) {
            tmp[i] = nums[i - 1];
        }
        nums = tmp;
        
        int[][] dp = new int[size + 2][size + 2];
    
    	// 枚举区间长度
        for (int len = 1; len <= size; len++) {
        	// 枚举区间左端点
            for (int i = 1; i + len - 1 <= size; i++) {
            	// 计算区间右端点
                int j = i + len - 1;
                // 长度为1是base case
                if (len == 1) {
                    dp[i][j] = nums[i] * nums[i - 1] * nums[i + 1];
                } else {
                	// 区间长度大于1时,枚举最后一个戳破的气球是第几个
                    for (int k = i; k <= j; k++) {
                        dp[i][j] = Math.max(dp[i][j], dp[i][k - 1] + dp[k + 1][j] + nums[k] * nums[i - 1] * nums[j + 1]);
                    }
                }
            }
        }
        
        return dp[1][size];
    }
}

时空复杂度一样。

©️2020 CSDN 皮肤主题: 创作都市 设计师:CSDN官方博客 返回首页