2021.12.08LeetCode每日一题——三个无重叠子数组的最大和_leetcode无重复数字的数组最大和-CSDN博客

本文链接：https://blog.csdn.net/weixin_39478524/article/details/121783492

三个无重叠子数组的最大和

描述

给你一个整数数组 nums 和一个整数 k ，找出三个长度为 k 、互不重叠、且 3 * k 项的和最大的子数组，并返回这三个子数组。

以下标的数组形式返回结果，数组中的每一项分别指示每个子数组的起始位置（下标从 0 开始）。如果有多个结果，返回字典序最小的一个。

示例 1

输入：nums = [1,2,1,2,6,7,5,1], k = 2
输出：[0,3,5]
解释：子数组 [1, 2], [2, 6], [7, 5] 对应的起始下标为 [0, 3, 5]。
也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。

示例 2

输入：nums = [1,2,1,2,1,2,1,2,1], k = 2
输出：[0,2,4]

提示

$1 \le nums.length \le 2 * 10^4$
$1 \le nums[i] < 2^{16}$
$1 \le k \le floor(nums.length / 3)$

方法：前缀和+序列动态规划

若不考虑输出方案，仅是求三个无重叠子数组的最大和的最大值。

只需用动态规划求解即可：定义 f[i][j] 为考虑前 i 个数，凑成无重叠子数组数量为 j 个时的最大值。

最终答案为 f[n - 1][3]f[n−1][3]

不失一般性的考虑 f[i][j] 该如何计算（以最优方案是否包含 nums[i] 进行讨论）：

1、最优方案中包含 num[i]

由于这 jj 个无重叠，因此前面的 j - 1j−1 个子数组不能覆盖 [i - k + 1, i][i−k+1,i]。即只能在 [0, i - k][0,i−k] 中选 j - 1j−1 个子数组。此时有：

$f[i][j]=f[i-k][j-1]+\sum_{idx=i-k+1}^{i}nums[idx]$

2、最优方案不包含 num[i]：

当明确了 nums[i] 对最优方案无贡献，此时问题等价于考虑前 i−1 个数，凑成 j 个不重叠子数组的最大值。此时有：

$f[i][j]=f[i-1][j]$

最终 f[i][j] 为上述两种方案中的最大值。

然后考虑如何回溯出字典序最小的具体方案，常规的回溯具体方案的做法是，从最终答案 f[n-1][3] 开始往回追溯。

利用 f[n−1][3] 仅由两个可能的节点（f[n−2][3] 和 f[n−1−k][2]）转移而来，通过判断 f[n−1][3] 等于 f[n−2][3] 还是 $f[n - 1 - k][2] + \sum_{idx = n - k }^{n - 1} nums[idx]$ 来决定回溯点为何值。

但该做法只能确保回溯出字典序最大的方案是正确（当两个可能的前驱节点都能转移到 f[i][j] 时优先采纳靠后的位置），而我们需要回溯出字典序最小的方案。

在上述解法的基础上，有两种求解字典序最小具体方案的做法：

将正序 DP 调整为反序 DP。修改状态定义为 f[i][j] 为考虑 [i,n−1] 中进行选择，凑出无重叠子数组数量为 j 个时的最大值（最终答案为 f[0][3]）。转移过程分析同理，然后从下标 idx=0 开始进行回溯，优先采纳 idx 小的方案即可；
仍然采取正序 DP 的做法，但对原数组进行翻转，从而将回溯字典序最大转换为字典序最小具体方案。

为了避免对边界的处理，我们令动规数组 f 和前缀和数组 sun 的下标从 11 开始。

class Solution {
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
        int n = nums.length;
        long[] sum = new long[n + 1];
        for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + nums[i - 1];
        long[][] f = new long[n + 10][4];
        for (int i = n - k + 1; i >= 1; i--) {
            for (int j = 1; j < 4; j++) {
                f[i][j] = Math.max(f[i + 1][j], f[i + k][j - 1] + sum[i + k - 1] - sum[i - 1]);
            }
        }
        int[] ans = new int[3];
        int i = 1, j = 3, idx = 0;
        while (j > 0) {
            if (f[i + 1][j] > f[i + k][j - 1] + sum[i + k - 1] - sum[i - 1]) {
                i++;
            } else {
                ans[idx++] = i - 1;
                i += k; j--;
            }
        }
        return ans;
    }
}