Leetcode--53--最大子序和（C++暴力求解、复杂度优化、分治法求解、在线处理）

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-subarray
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这题是在学习数据结构的课程中的第一讲习题，所以利用了PTA平台提交测试结果，仅作为个人记录~欢迎交流 😃

题目描述53

给定一个整数数组 nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1]的和最大，为6。

进阶:
如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。

算法3: 在线处理–单层循环

这里需要注意的点是将 MaxSum的初始值设置为 INT_MIN。
如果将其初始值设置为0，则在诸如[-1,-2]情况时不能正确输出结果，会返回0。
可以养成一个习惯：在求最大值最小值问题时，注意关注初始值的设置问题。

int maxSubArray(int* nums, int numsSize){
    int ThisSum=0,MaxSum=INT_MIN; 
    for(int i=0;i<numsSize;i++)
     {
        ThisSum += nums[i];
        if(ThisSum>MaxSum)
            MaxSum = ThisSum;
        if(ThisSum<0)
            ThisSum = 0;
     }
    return MaxSum;
}

只利用一层循环，时间复杂度为O(n);
只用到了常数空间 空间复杂度为O(1);

PTA 平台测试结果

算法2：分治法

#include <iostream>
#include <climits>

using namespace std;

int Max3(int A, int B, int C)
{
    if(A>B)
        return A>C?A:C;
    else
        return B>C?B:C;
}
//分治法
int DivideAndConquer(int List[], int left, int right)
{
    //递归的终止条件，子列只有一个数字
    if(left==right)
       return List[left];

    //分别存放左子列和右子列的最大值
    int MaxLeftSum, MaxRightSum;
    int center;
    //下面是“分”的过程
    center = (left + right) / 2;
    //通过递归求每次二分后两边子列的最大和
    MaxLeftSum = DivideAndConquer(List, left, center);
    MaxRightSum = DivideAndConquer(List, center+1, right);

    //求跨分界线的最大子列和
    int MaxLeftBorderSum=INT_MIN, MaxRightBorderSum=INT_MIN;
    int LeftBorderSum=0, RightBorderSum=0;
    //从中线向左扫描
    for(int i=center; i>=left; i--)
    {
        LeftBorderSum += List[i];
        if(LeftBorderSum > MaxLeftBorderSum)
            MaxLeftBorderSum = LeftBorderSum;
    }
    //从中线向右扫描
    for(int i=center+1; i<=right; i++)
    {
        RightBorderSum += List[i];
        if( RightBorderSum > MaxRightBorderSum)
            MaxRightBorderSum = RightBorderSum;
    }
    return Max3(MaxLeftSum, MaxRightSum, MaxLeftBorderSum+MaxRightBorderSum);

}
int MaxSeqSum2(int List[], int N)
{
  return DivideAndConquer(List, 0, N-1);
}
int main()
{
    int n;
    cin>>n;
    cin.get();

    int a[n];
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }

    int ans;
    ans = MaxSeqSum2(a,n);
    cout << ans << endl;

}

PTA平台测试结果

算法1：暴力解法–双层循环

int maxSubArray(int* nums, int numsSize){
int ThisSum,MaxSum=INT_MIN;
  for(int i=0; i<numsSize; i++)
  {
      ThisSum=0;
      for(int j=i; j<numsSize; j++)
      {
         ThisSum += nums[j];
         if(ThisSum > MaxSum)
            MaxSum = ThisSum;
      }
  }
  return MaxSum;
}

PTA平台提交代码

#include <iostream>
#include <climits>

using namespace std;
int MaxSeqSum1(int a[],int n)
{
  int ThisSum,MaxSum=INT_MIN;
  for(int i=0; i<n; i++)
  {
       ThisSum=0;
      for(int j=i; j<n; j++)
      {
         ThisSum += a[j];
         if(ThisSum > MaxSum)
            MaxSum = ThisSum;
      }
  }
  return MaxSum;
}
int main()
{
    int n;
    cin>>n;
    cin.get();

    int a[n];
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    int ans1;
    ans1 = MaxSeqSum1(a,n); 
    cout << ans1 << endl;
    return 0;
}

运用了双层循环，时间复杂度为O($n^2$)。
通过下图可以发现，在1000内，两者效率相差不大，但是当数据规模较大时，算法3的效率具有显著优势