最大子数组（分治法+动态规划）

来源：labuladong的算发小抄

方法一：分治法

#include <iostream>

using namespace std;

//计算S3 分为两部分
//第一部分为包含mid位置的元素，依次向前遍历找最大的子数组为Sleft
//第二部分为包含mid+1位置的元素，依次向后遍历，找到最大子数组
//S3就是包含mid和mid+1位置的最大子数组，即为Sleft和Sright的和。
int CrossingSubArray(int X[],int low,int mid,int high)
{
    //计算Sleft
    int Sleft = -100000;
    int Sum = 0;
    for(int l=mid;l>=low;l--)
    {
        Sum = Sum + X[l];
        if(Sleft<Sum)
        {
            Sleft=Sum;
        }
    }
    //计算Sright
    int Sright = -100000;
    Sum = 0;
    for(int r=mid+1;r<=high;r++)
    {
        Sum = Sum + X[r];
        if(Sright<Sum)
        {
            Sright = Sum;
        }
    }
    int S3 = Sleft+Sright;
    return S3;
}


int MaxSubArray(int X[],int low,int high)
{
     int mid,S1,S2,S3,Smax=0;
    if (low == high)//说明只含有一个元素 返回
    {
        return X[low];
    }
    else
    {
        mid = (low+high)/2;
        S1=MaxSubArray(X,low,mid);
        S2=MaxSubArray(X,mid+1,high);
        S3=CrossingSubArray(X,low,mid,high);
        //S1 S2 S3其中的最大值就是最大子数组
        if(S1>=S2)
        {
            if(S1>=S3)
            {
                Smax = S1;
            }
            else
            {
                Smax = S3;
            }
        }
        else
        {
            if(S2>=S3)
            {
                Smax = S2;
            }
            else
            {
                Smax = S3;
            }
        }
        return Smax;
    }
}

int main()
{
    int n;
    printf("请输入数组的大小：");
    scanf("%d",&n);
    int a[n];
    printf("请输入数组的元素：");
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    printf("\n数组元素是：");
    for(int i = 0 ;i < n; i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    int z = MaxSubArray(a,0,n-1);
    printf("最大子数组为：%d",z);
    return 0;
}

方法二：

动态规划

思路:

1.定义好nums数组用来存储数据，其中利用“状态压缩”的方法进行缩小空间复杂度。定义好dp_0和dp_1并初始化为nums[0]和0；还有最后的结果res也初始化为dp_0.

2.遍历数组，改变dp_0 和dp_1的状态并更新res 寻找更大的子数组。

dp[i]更新时可以依据dp[i-1]的状态，来选择加不加dp[i-1].如果是负数则不加，反之则加

状态压缩：把原来的dp数组减少到两个量，依次交换使用，减少空间（dp[ ]:以nums[i]为结尾的“最大子数组的和”为的dp[i]）.

#include <iostream>

using namespace std;

int maxSubArray(int nums[],int n)
{
    if(n == 0)
        return 0;
    int dp_0 = nums[0];
    int dp_1 = 0;
    int res = dp_0;

    for(int i=1;i<n;i++)
    {
        if(nums[i]>(nums[i]+dp_0))
        {
            dp_1=nums[i];
        }
        else
        {
            dp_1= (nums[i]+dp_0);//nums[i]不是nums[1] 注意拼写问题！！！！  调试半小时！！！！！
        }
        dp_0 = dp_1;
        if(res < dp_1)
            res = dp_1;
    }
    return res;
}
int main()
{
    int n;
    cin>>n;
    int nums[n];
    for(int i=0;i<n;i++)
    {
        cin>>nums[i];
    }
    int m = maxSubArray(nums,n);
    cout<<"最大子数组的长度是："<<m<<endl;
    return 0;
}

结果如下：