分治策略之最大子数组问题

欢迎关注，定期更新算法问题

今天介绍一下分治算法的一个典型问题----最大子数组问题

先来看一下《算法导论》上的一个引例，

对于这个问题，我们常规的思维就是在股价最低时买进，股价最高时抛出，只要满足买进的时间在卖出的时间之前，就可以达到我们所认为的最大效益；但是情况有可能不是这样的，例如下边这个图，同样是《算法导论》上的插图：

通过这个图明显的看出，效益最大化的时间并不包含最大股价的时间，这就说明原来的想法是不可靠的。

下边介绍一下求解方法：

1、暴力求解：我们可以将可能的买入卖出时间组合，这种方法花费的时间是O(n^2)。

2、变换输入：我们这样理解，这里说的效益最大化是指一段时间里股票的净增值，把每天的股价转化成股票价格的变化值，这就转化成了寻找一个子数组使得其和最大，称这个数组为最大连续子数组。接下来可以通过分治策略来求解。

原理：假设求解的数组为A[low,high]，第一步取中点mid，将其分解成两个规模差不多的子数组A[low,mid],A[mid+1,high]，然后在考虑求解子数组。A的任何连续子数组只能有下边3种情况：

(1)、子数组完全位于A[low,mid]

(2)、子数组完全位于A[mid+1,high]

(3)、子数组跨越了中点

可以在线性时间里求解跨越了中点的最大子数组，思路即为先求解左半部分的最大子数组，再求解右半部分的最大子数组，代码如下：

vector<int> Find_Maxcrossing_Subarray(int A[],int low,int mid,int high)
{
    int left_sum=0,right_sum=0;
    int left_max=low,right_max=high;
    int i,j,sum=0;
    for(i=mid;i>=low;i--)
    {
        sum=sum+A[i];
        if(sum>left_sum)
        {
            left_max=i;
            left_sum=sum;
        }
    }
    sum=0;
    for(j=mid+1;j<=high;j++)
    {
        sum=sum+A[j];
        if(sum>right_sum)
        {
            right_max=j;
            right_sum=sum;
        }
    }
    vector<int> v{left_max,right_max,left_sum+right_sum};
    return v;
}

因为这个函数要返回三个值，最大子数组的左下标，右下标以及数组和，故返回值定义成一个vector，C++标准库的一个容器，可以简单的理解成和数组类似。

接着可以设计分治算法的求解函数，返回值包括最大子数组的边界下标和数组和，当元素只有一个时，直接返回本身，否则递归求解左、右部分的最大子数组，最后做比较，取数组和最大的作为解。代码如下：

vector<int> Find_Max_Subarray(int A[],int low,int high)
{
    if(low==high)
    {
        vector<int> v1{low,high,A[low]};
        return v1;
    }
    else
    {
        int mid=(low+high)/2;
        vector<int> leftV=Find_Max_Subarray(A,low,mid);
        vector<int> rightV=Find_Max_Subarray(A,mid+1,high);
        vector<int> Max_sumV=Find_Maxcrossing_Subarray(A,low,mid,high);
        if(leftV[2]>Max_sumV[2] && leftV[2]>rightV[2])
            return leftV;
        else if(rightV[2]>leftV[2] && rightV[2]>Max_sumV[2])
            return rightV;
        else return Max_sumV;
    }
}

时间复杂度为O(nlg(n))

全部代码：

#include <iostream>
#include <vector>
using namespace std;
vector<int> Find_Maxcrossing_Subarray(int A[],int low,int mid,int high);
vector<int> Find_Max_Subarray(int a[],int low,int high);
int main()
{
    int A[6]={-1,2,3,4,5,-4};
   // vector<int> v1=Find_Maxcrossing_Subarray(A,0,3,5);
   vector<int> v1=Find_Max_Subarray(A,0,5);
    for(vector<int>::iterator iter=v1.begin();iter!=v1.end();iter++)
    {
        cout<<*iter<<endl;
    }
    return 0;
}
vector<int> Find_Maxcrossing_Subarray(int A[],int low,int mid,int high)
{
    int left_sum=0,right_sum=0;
    int left_max=low,right_max=high;
    int i,j,sum=0;
    for(i=mid;i>=low;i--)
    {
        sum=sum+A[i];
        if(sum>left_sum)
        {
            left_max=i;
            left_sum=sum;
        }
    }
    sum=0;
    for(j=mid+1;j<=high;j++)
    {
        sum=sum+A[j];
        if(sum>right_sum)
        {
            right_max=j;
            right_sum=sum;
        }
    }
    vector<int> v{left_max,right_max,left_sum+right_sum};
    return v;
}
vector<int> Find_Max_Subarray(int A[],int low,int high)
{
    if(low==high)
    {
        vector<int> v1{low,high,A[low]};
        return v1;
    }
    else
    {
        int mid=(low+high)/2;
        vector<int> leftV=Find_Max_Subarray(A,low,mid);
        vector<int> rightV=Find_Max_Subarray(A,mid+1,high);
        vector<int> Max_sumV=Find_Maxcrossing_Subarray(A,low,mid,high);
        if(leftV[2]>Max_sumV[2] && leftV[2]>rightV[2])
            return leftV;
        else if(rightV[2]>leftV[2] && rightV[2]>Max_sumV[2])
            return rightV;
        else return Max_sumV;
    }
}