LeetCode 1186. 删除一次得到子数组最大和（中等）

最新推荐文章于 2025-04-03 15:29:45 发布

枫景Maple

最新推荐文章于 2025-04-03 15:29:45 发布

阅读量276

点赞数 5

分类专栏：算法文章标签： leetcode 算法数据结构

本文链接：https://blog.youkuaiyun.com/ZeroBugX/article/details/145987014

版权

算法专栏收录该内容

6 篇文章

订阅专栏

给你一个整数数组，返回它的某个非空子数组（连续元素）在执行一次可选的删除操作后，所能得到的最大元素总和。换句话说，你可以从原数组中选出一个子数组，并可以决定要不要从中删除一个元素（只能删一次哦），（删除后）子数组中至少应当有一个元素，然后该子数组（剩下）的元素总和是所有子数组之中最大的。

注意，删除一个元素后，子数组 不能为空。

示例 1：

输入：arr = [1,-2,0,3]
输出：4
解释：我们可以选出 [1, -2, 0, 3]，然后删掉 -2，这样得到 [1, 0, 3]，和最大。

示例 2：

输入：arr = [1,-2,-2,3]
输出：3
解释：我们直接选出 [3]，这就是最大和。

示例 3：

输入：arr = [-1,-1,-1,-1]
输出：-1
解释：最后得到的子数组不能为空，所以我们不能选择 [-1] 并从中删去 -1 来得到 0。
     我们应该直接选择 [-1]，或者选择 [-1, -1] 再从中删去一个 -1。

提示：

1 <= arr.length <= 10^5
-10^4 <= arr[i] <= 10^4

解题思路

这道题是经典的最大子数组和问题（Kadane算法）的变种。在原始问题中，我们只需要找到具有最大和的连续子数组。而在这个问题中，我们可以选择删除一个元素，然后找到最大和。

我们可以使用动态规划来解决这个问题。定义两个状态：

dp1[i] - 表示以第i个元素结尾的子数组的最大和（不删除任何元素）

dp2[i] - 表示以第i个元素结尾的子数组的最大和（删除了一个元素）

对于 dp1[i]，我们有两种选择：

将当前元素加入到前面的子数组中：dp1[i-1] + arr[i]

重新开始一个子数组：arr[i]

所以 dp1[i] = max(dp1[i-1] + arr[i], arr[i])

对于 dp2[i]，我们有三种选择：

删除当前元素，使用前面不删除元素的最大和：dp1[i-1]

不删除当前元素，使用前面已经删除了一个元素的最大和：dp2[i-1] + arr[i]

重新开始一个子数组（已经删除了一个元素）：这种情况已经包含在上面两种情况中

所以 dp2[i] = max(dp1[i-1], dp2[i-1] + arr[i])

最终的答案是 max(dp1[n-1], dp2[n-1])，其中 n 是数组的长度。

代码实现

java 动态规划

/**
 * 1186. 删除一次得到子数组最大和
 * 动态规划
 */
class Solution {
    public int maximumSum(int[] arr) {
        if (arr == null || arr.length == 0)
            return 0;
        if (arr.length == 1)
            return arr[0];
        int n = arr.length;
        // dp1[i]：以i结尾且不删除元素的最大子数组和
        // dp2[i]：以i结尾且删除了一个元素的最大子数组和
        int[] dp1 = new int[n];
        int[] dp2 = new int[n];

        // 初始化第一个元素
        dp1[0] = arr[0]; // 不删除元素
        dp2[0] = 0; // 删除元素（此时为空）

        int maxSum = arr[0];
        for (int i = 1; i < n; i++) {
            // 不删除元素的情况：
            // 1. 将当前元素加入前面的子数组
            // 2. 从当前元素重新开始
            dp1[i] = Math.max(dp1[i - 1] + arr[i], arr[i]);

            // 删除元素的情况：
            // 1. 保留当前元素，使用前面已经删除过的状态
            // 2. 删除当前元素，使用前面未删除的状态
            dp2[i] = Math.max(dp2[i - 1] + arr[i], dp1[i - 1]);

            maxSum = Math.max(maxSum, Math.max(dp1[i], dp2[i]));
        }

        return maxSum;
    }
}

时间复杂度：O(n)
- 只需要遍历一次数组
- 每个元素的处理时间是O(1)
空间复杂度：O(n)
- 需要两个数组存储状态

优化

我们可以对上述代码进行空间优化，因为每次计算只依赖于前一个状态：

java 动态规划，空间优化

/**
 * 1186. 删除一次得到子数组最大和
 * 动态规划，空间
 */
class Solution {
    /**
     * 计算删除一次元素后能得到的最大子数组和
     *
     * @param arr 输入的整数数组
     * @return 删除一次元素后能得到的最大子数组和
     */
    public int maximumSum(int[] arr) {
        // 如果数组为空或长度为0，返回0
        if (arr == null || arr.length == 0)
            return 0;
        // 如果数组长度为1，返回该元素的值
        if (arr.length == 1)
            return arr[0];

        // dp1表示当前不删除任何元素的最大子数组和
        int dp1 = arr[0];
        // dp2表示当前删除一个元素后的最大子数组和
        int dp2 = 0;
        // maxSum用于记录遍历过程中的最大子数组和
        int maxSum = arr[0];
        // 遍历数组，计算最大子数组和
        for (int i = 1; i < arr.length; i++) {
            // 更新dp2，考虑当前元素加入后，是选择删除前一个元素还是不删除当前元素
            dp2 = Math.max(dp2 + arr[i], dp1);
            // 更新dp1，考虑当前元素加入后的情况
            dp1 = Math.max(dp1 + arr[i], arr[i]);
            // 更新maxSum，记录当前的最大子数组和
            maxSum = Math.max(maxSum, Math.max(dp1, dp2));
        }
        // 返回最大子数组和
        return maxSum;
    }
}