LeetCode 1388. 3n 块披萨

LeetCode 1388. 3n 块披萨

描述

给你一个披萨，它由 3n 块不同大小的部分组成，现在你和你的朋友们需要按照如下规则来分披萨：

你挑选 任意 一块披萨。
Alice 将会挑选你所选择的披萨逆时针方向的下一块披萨。
Bob 将会挑选你所选择的披萨顺时针方向的下一块披萨。
重复上述过程直到没有披萨剩下。

每一块披萨的大小按顺时针方向由循环数组 slices 表示。

请你返回你可以获得的披萨大小总和的最大值。

示例 1：

输入：slices = [1,2,3,4,5,6]
输出：10

解释：选择大小为 4 的披萨，Alice 和 Bob 分别挑选大小为 3 和 5 的披萨。然后你选择大小为 6 的披萨，Alice 和 Bob 分别挑选大小为 2 和 1 的披萨。你获得的披萨总大小为 4 + 6 = 10 。

示例 2：

输入：slices = [8,9,8,6,1,1]
输出：16

解释：两轮都选大小为 8 的披萨。如果你选择大小为 9 的披萨，你的朋友们就会选择大小为 8 的披萨，这种情况下你的总和不是最大的。

提示：

1 <= slices.length <= 500
slices.length % 3 == 0
1 <= slices[i] <= 1000

题解

• 等价于：
  给一个长度为 3n 的环状序列，你可以在其中选择 n 个数，并且任意两个数不能相邻，求这 n 个数的最大值。
• 动态规划：

  转化方程 dp[i][j] = Math.max(dp[i-1][j],dp[i-2][j-1]+nums[i]);

class Solution {
    public int maxSizeSlices(int[] slices) {

        
        //  dp[i][j] = Math.max(dp[i - 1][j], dp[i - 2][j - 1] + nums[i])

        int n = slices.length;
        int [] arr1 = new int[n-1];
        //去尾
        System.arraycopy(slices,0,arr1,0,n-1);
        int [] arr2 = new int[n-1];
        // 去头
        System.arraycopy(slices,1,arr2,0,n-1);
        // 选取n/3个数，获取最大和
        int max1 = getMax(arr1,n/3);
        int max2 = getMax(arr2,n/3);

        //返回最大值
        return Math.max(max1,max2);
    }
    public int getMax(int [] arr,int k){
        // 获取数组长度
        int n = arr.length;
        // 动态规划
        // dp[i][j] 前 i+1 个数，选取不相邻的 j 个数的和的最大值
        int [][] dp = new int [n][k+1];
        // dp 初始化
        // 前一个数字 选取一个数字
        dp [0][1] = arr[0];
        // 前两个数字 选取一个数字
        dp [1][1] = Math.max(arr[0],arr[1]);

        for(int i = 2;i<n;i++){
            for(int j = 1;j <= k;j++){
                dp [i][j] = Math.max(dp[i-1][j],dp[i-2][j-1]+arr[i]);
            }
        }

        // 返回 前 n 个数字选取k个的最大和
        return dp[n-1][k];
    }
}