Best Time to Buy and Sell Stock

最近遇到一道题，数组表示当日股价，最多进行２次买卖，而且不能连续买，只能买卖买卖。问能赚到的最大值。

知道这是一道类型题，但是我想自己独立解决。不过能力有限，最后还是参考了网络中的大牛解法。这里做一下总结。

参考推库，　一个神奇的网站。
http://www.tuicool.com/articles/rMJZj2

能够感到这是一道动态规划的题，分成２部分，然后求和的最大值，但是如何对一部分求一次买卖所能获得的最大值呢？

开始考虑记录相邻两项的差，然后看看，当时没有想到转化为，相邻差数组的连续和的最大值，所以没能找到答案。

先给出网上的做法。
找到最低点，一次计算每一点到最低点的差，然后求最大。
这里需要注意，并不是求最高点和最低点的差。因为最高点可能在最低点的前面。
仔细想一想，这也是一个动态规划的问题，动态的找到相对最高点和最低点，然后比较找出最大。

这里，用low 来记录相对的最小值，每当有元素比low小，就更新相对最小值。
如果，比low　大，那么计算差值和最大值比较。

int MaxProfitInStock(int *a, int length){    bool isArrayVaild(int *, int);    if(!isArrayVaild(a, length))        return 0;    int Max, low;    //int cur = a[0];    low = a[0];    Max = 0;    int i;    for(i = 1; i < length; ++i)    {        if(a[i] < low)            low = a[i];        else if(a[i] - low > Max)                Max = a[i] - low;    }    return Max;}

现在我们知道了如何从数组中，一次买卖能获得的最大值。
这里需要对　MaxProfitInStock(int *a, int length)　做一点儿小小改动。
求　a[start~endL]中的买卖最大值。
那么，我们就可以开始进行动态划分，然后找到两部分最大值和的最大值。

int MaxProfitInStock_DP(int *a, int start, int endL){    if(NULL == a || start >= endL)        return 0;    int Max, low;    //int cur = a[0];    low = a[start];    Max = 0;    int i;    for(i = start; i <= endL; ++i)    {        if(a[i] < low)            low = a[i];        else if(a[i] - low > Max)                Max = a[i] - low;    }    return Max;}int MaxProfitInStock_maxBuy2_DP(int *a, int length){    if(!isArrayVaild(a, length))        return 0;    int Max = 0;    int i, tmp;    for(i = 0; i < length; ++i)    {        tmp = MaxProfitInStock_DP(a, 0, i) + MaxProfitInStock_DP(a, i+1, length-1);        if(tmp > Max)            Max = tmp;    }    return Max;}

显然，求一部分的最大值复杂度　O(n)，循环也是O(n)，
所以整体是　O(n^2)。

思路２．

既然我们能在O(n)的时间求出　a[start ~ end]中差值的最大值，
那不妨记录一下 a[0 ~ i] 和　a[i ~ length-1]的最大值，在求求和的最大值。

first[i] 表示　a[0 ~ i]　的最大值
last[i]  表示　b[i ~ length-1]的最大值

那么整体的最大值　就是
max(first[i] + last[i])     0 <= i <= length-1
此时，整体的复杂度为　O(n)

int MaxProfitInStock_maxBuy2_DP_1(int *a, int length){    if(!isArrayVaild(a, length))        return 0;    int *first, *last;    first = new int[length];    last = new int[length];    first[0] = 0;    last[length - 1] = 0;    int Max = 0;    int cur, i;    int low, high;    low = a[0];    for(i = 1; i < length; ++i)    {        if(a[i] < low)            low = a[i];        else if(a[i] - low > Max)            Max = a[i] - low;        first[i] = Max;    }    Max = 0;    high = a[length - 1];    for(i = length - 2; i >= 0; --i)    {        if(a[i] > high)            high = a[i];        else if(high - a[i] > Max)            Max = high - a[i];        last[i] = Max;    }    Max = first[0] + last[0];    for(i = 1; i < length; ++i)    {        if(first[i] + last[i] > Max)            Max = first[i] + last[i];    }    delete[] first;    delete[] last;    first = last = NULL;    return Max;}

补充，我自己开始的那个想法。

先记录相邻两项差，然后求连续和的最大值。

int MaxProfitInStock_Mine(int *a, int length){    if(!isArrayVaild(a, length) || (1 == length))        return 0;    int chaNum = length - 1;    int *cha = new int[chaNum];    int i;    for(i = 0; i < chaNum; ++i)    {        cha[i] = a[i + 1] - a[i];    }    int Max = 0;    int curSum = 0;    //int start = -1;    for(i = 0; i < chaNum; ++i)    {        curSum += cha[i];        if(curSum > Max)            Max = curSum;        if(curSum < 0)        {            curSum = 0;        }    }    delete[] cha;    cha = NULL;    return Max;}