Day_13，最大子数组求解

问题导入： 一个已知当天收盘价的17天股票情况，找出其中一天买入，并找一天卖出使其收益最大，收盘图如下。

首先要排除一种错误思想：“找到其中收盘的最大值和最小值及其对应的天数即可”。 从图上可知最大值和最小值分别出现在第一天 和 第七天，明显不可能实现。
可以将上述问题转化为，在一段时间内收益最高。
思路1： 只要卖出时间在买入时间之后即可，n天则有$$\sum _{i=1}^{n}i$$ 种情况，该想法明显需要两个for循环，因此时间复杂度是O(n^2)
思路2： 求解价格变化数组的最大子数组，价格变化如下图（C++中 索引是从0开始的）

按照思路2，我们仍需要检查 $$\sum _{i=1}^{n-1}i$$ ，时间复杂度还是O(n^2)，我们可以采用更高效的方法，引入上一篇的分治法。

分解： 将原数组分成两个尽量相等的子数组，分别去求解最大子数组。假设买入卖出天数为（i，j）此时最大子数组应该包括三个方面
1、在左侧的[left,mid]，left<=i<=j<=mid
2、在右侧的[mid+1,right]，mid+1<=i<=j<=right
3、跨越中心的，left<=i<=mid<=j<=right
第三个方面可以看成是 (i,mid)+(mid+1,j)，因此只要求出max (i,mid)和max(mid+1,j)即可

C++的实现代码如下：

#include <stdio.h>
#include <iostream>
#include <math.h>
using namespace std;

struct arrayInfo
{
	int left;
	int right;
	int sum=0;
};

arrayInfo FindMaxCross(int *arr,int len,int left,int right)
{
    arrayInfo resultArr;
    if (len <= 3) //此时已经是最小的跨mid数组
    {
        resultArr.left = left;
        resultArr.right = right;
        for (int i=0;i<len;i++)
            resultArr.sum = resultArr.sum + arr[left+i];
        return resultArr;
    }
    int sum,leftSum,rightSum,maxLeft,maxRight;
    int mid = floor(len/2);
    maxLeft = mid;
    maxRight = mid+1;
    leftSum = arr[mid];
    rightSum = arr[mid+1];
    sum = 0;
    for (int i=mid;i>=left;i--)
    {
        sum = sum + arr[i];
        if (sum > leftSum)
        {
            leftSum = sum;
            maxLeft = i;
        }
    }
    sum = 0;
    for (int i=mid+1;i<=right;i++)
    {
        sum = sum + arr[i];
        if (sum > rightSum)
        {
            rightSum = sum;
            maxRight = i;
        }
    }
    resultArr.left = maxLeft;
    resultArr.right = maxRight;
    resultArr.sum = leftSum+rightSum;
    return resultArr;
}

arrayInfo FindMax(int *arr,int len,int left,int right)
{
    arrayInfo resultArr,leftArr,rightArr,midArr;
    if (len == 1)//此时不存在mid
    {
        resultArr.left = left;
        resultArr.right = right;
        resultArr.sum = arr[left]+arr[left+1];
        return resultArr;
    }
    int mid = floor((left+right)/2);
    leftArr = FindMax(arr,mid-left+1,left,mid);
    rightArr = FindMax(arr,right-mid,mid+1,right);
    midArr = FindMaxCross(arr,right-left+1,left,right);
    if (leftArr.sum>=rightArr.sum && leftArr.sum>=midArr.sum)
        resultArr = leftArr;
    else
    {
        if (rightArr.sum>=leftArr.sum && rightArr.sum>=midArr.sum)
            resultArr = rightArr;
        else
            resultArr = midArr;
    }
    return resultArr;
}

int main()
{
    int a[]={13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7};
    arrayInfo arr;
    arr = FindMaxCross(a,sizeof(a)/sizeof(*a),0,sizeof(a)/sizeof(*a)-1);
    //數組是从0开始的，天数需要+1
    arr.left = arr.left+1;
    arr.right = arr.right+1;
    cout<<"("<<arr.left<<","<<arr.right<<") = "<<arr.sum<<endl;
    return 0;
}

时间复杂度计算
分解： 分解仅仅计算中间元素的位置，如上代码的“//分解”，因此运算时间为常量及θ(1)
计算： 对于归并排序来说，T(n)=aT(n/b)，a=b=2
合并： 合并即代码中的比较即每次θ(1)，需要比较n次，运算时间为常量及θ(n)
特殊情况 当n=1的时候，仅需要经过一次运算，因此c=1
归并排序的运行时间递归式为：

和上一篇的递归式相同，因此T(n) =θ(nlgn)