lintcode -- 最大子数组II

本文介绍了一种算法,用于寻找整数数组中两个不重叠子数组的最大和,通过预计算左右最大子数组和的方法高效解决问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

给定一个整数数组,找出两个 不重叠 子数组使得它们的和最大。
每个子数组的数字在数组中的位置应该是连续的。
返回最大的和。

 注意事项

子数组最少包含一个数

样例

给出数组 [1, 3, -1, 2, -1, 2]

这两个子数组分别为 [1, 3] 和 [2, -1, 2] 或者 [1, 3, -1, 2]和 [2],它们的最大和都是 7




/*
数组left ,left[i] 表示从0 到i 这个区间内元素的最大值
同样可以求从i 到 size-1 这个区间的最大值
上面两个值之和的最大值就是答案了




第二个for循环也就是求i 到size -1区间内的全局最大值,然后就想到可以再定义一个数组
right right[i] 表示从i 到 size -1这个区间的最大
下面只需要根据这个两个数组求出最大值的和就好了
max = Math.max(left[i] + right[i+1],max)


再说明下:
left[i] 表示从0 到i 这个区间的最大值
right[i+1] 表示从 i + 1 都 size-1 这个区间的最大值
*/
//左边和右边分别计算max subarray,然后两边加起来最大的就是结果


public class Solution {
    public int maxTwoSubArrays(ArrayList<Integer> nums) {
        int size = nums.size();
        if(nums ==  null || size == 0)return 0;
        int[]left = new int[size];
        int[]right = new int[size];
        int max = Integer.MIN_VALUE;
        
        int localMax =0;
        //保存过程中的最大值
        int globalMax = Integer.MIN_VALUE;
        for(int i =0;i<size;i++){
            localMax = Math.max(localMax+nums.get(i),nums.get(i));
            globalMax = Math.max(localMax,globalMax);
            left[i] = globalMax;
        }
        
        localMax= 0;
        globalMax = Integer.MIN_VALUE;
        for(int i = size-1;i>=0;i--){
            localMax = Math.max(localMax+nums.get(i),nums.get(i));
            globalMax = Math.max(localMax,globalMax);
            right[i] = globalMax;
        }
        for(int i =0;i<size-1;i++){
            //left[i] 表示从0 到i 这个区间的最大值
            //right[i+1] 表示从 i + 1 到 size-1 这个区间的最大值
            max = Math.max(max,left[i]+right[i+1]);
        }
        return max;
    }
}

### 最大子数组和算法的实现 最大子数组和问题的目标是找到一个数组中和最大的连续子数组。该问题在算法领域中具有重要意义,尤其在动态规划和分治算法的应用中被广泛研究。 #### 方法1:蛮力法 蛮力法是最直观的解决方案,其基本思想是遍历所有可能的子数组,计算它们的和,并从中找出最大值。这种方法的时间复杂度为 $O(n^2)$,对于较小的数组规模是可行的,但对于较大的数组则效率较低。 以下是C语言实现: ```c #include <stdio.h> int maxSubArray1(int a[], int n) { int maxSum = 0; int i, j; for (i = 0; i < n; i++) { int currentSum = 0; for (j = i; j < n; j++) { currentSum += a[j]; if (currentSum > maxSum) { maxSum = currentSum; } } } return maxSum; } int main() { int arr[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4}; int n = sizeof(arr) / sizeof(arr[0]); printf("最大子数组的和为: %d\n", maxSubArray1(arr, n)); return 0; } ``` #### 方法2:动态规划法 动态规划法是解决最大子数组和问题的经典方法,其时间复杂度为 $O(n)$,效率显著优于蛮力法。其核心思想是维护一个当前子数组的和,如果当前子数组的和小于0,则丢弃之前的子数组并重新开始计算。 以下是C语言实现: ```c #include <stdio.h> int maxSubArray2(int a[], int n) { int maxSum = a[0]; int currentSum = a[0]; for (int i = 1; i < n; i++) { currentSum = (currentSum + a[i] > a[i]) ? currentSum + a[i] : a[i]; maxSum = (currentSum > maxSum) ? currentSum : maxSum; } return maxSum; } int main() { int arr[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4}; int n = sizeof(arr) / sizeof(arr[0]); printf("最大子数组的和为: %d\n", maxSubArray2(arr, n)); return 0; } ``` #### 方法3:分治法 分治法将数组分为左右两部分,分别求解左半部分和右半部分的最大子数组和,同时考虑跨越中间的最大子数组和。这种方法的时间复杂度为 $O(n \log n)$,适合大规模数据的处理。 以下是C语言实现: ```c #include <stdio.h> // 求三者中的最大值 int max(int a, int b, int c) { return (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c); } // 求跨越中间的最大子数组和 int maxCrossingSum(int a[], int left, int mid, int right) { int sum = 0; int leftSum = -999999; for (int i = mid; i >= left; i--) { sum += a[i]; if (sum > leftSum) { leftSum = sum; } } sum = 0; int rightSum = -999999; for (int i = mid + 1; i <= right; i++) { sum += a[i]; if (sum > rightSum) { rightSum = sum; } } return leftSum + rightSum; } // 分治法主函数 int maxSubArray3(int a[], int left, int right) { if (left == right) { return a[left]; } int mid = (left + right) / 2; int leftMax = maxSubArray3(a, left, mid); int rightMax = maxSubArray3(a, mid + 1, right); int crossMax = maxCrossingSum(a, left, mid, right); return max(leftMax, rightMax, crossMax); } int main() { int arr[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4}; int n = sizeof(arr) / sizeof(arr[0]); printf("最大子数组的和为: %d\n", maxSubArray3(arr, 0, n - 1)); return 0; } ``` ### 总结 - **蛮力法**:简单直观,但效率较低,时间复杂度为 $O(n^2)$。 - **动态规划法**:高效且简洁,时间复杂度为 $O(n)$。 - **分治法**:适用于大规模数据,时间复杂度为 $O(n \log n)$,但实现较复杂。 根据具体需求和数据规模,可以选择合适的算法实现最大子数组和的求解。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值