分治策略

在分治策略中递归地求解一个问题，在每层递归中应用如下三个步骤：

分解 ： 将问题划分成一些子问题，子问题的形式与原问题一样，只是规模更小。

解决 ： 递归地求解子问题。如果子问题的规模足够小，则停止递归，直接求解。

合并 ： 将子问题的解组合成原问题的解。

 

最大子数组问题

分治策略求解（nlg(n) )

low         mid         high

!                !              !

#  #  #  #  #  #  #  #  #

A[low,high]的任何连续子数组的位置必然是下面的三种情况之一：

* 完全位于子数组 A[low,mid] 中，因此low<=i<=j<=mid;

* 完全位于子数组 A[mid+1,high]中， 因此mid<i<=j<=high;

* 跨越了中点，因此low<=i<=mid<j<=high;

所以A[low,high]的一个最大子数组所处的位置必然是三者之一，是 完全位于子数组 A[low,mid] 中,完全位于子数组 A[mid+1,high]中, 跨越了中点的所有子数组中和最大的；

我们可以递归地求解A[low.....mid]和A[mid+1....high]的最大子数组，因为这两个子问题仍是最大子数组问题，只是规模更小，因此剩下的工作就是寻找跨越中点的最大子数组，然后4

在三种情况中选取和最大的；

分治策略代码：

#include<iostream>
using namespace std;
const int inf=999999;
struct answer{
    int sum,left,right;
};
answer find_max_crossing_subarray(int *a,int l,int mid,int r){
    int leftsum=-inf;
    int sum=0;
    int maxleft;
    for(int i=mid;i>=l;i--){
        sum+=a[i];
        if(sum>leftsum){
            leftsum=sum;
            maxleft=i;
        }
    }
    int rightsum=-inf;
    sum=0;
    int maxright;
    for(int i=mid+1;i<=r;i++){
        sum+=a[i];
        if(sum>rightsum){
            rightsum=sum;
            maxright=i;
        }
    }
    answer ans{leftsum+rightsum,maxleft,maxright};
    return ans;    
}
answer find_max_subarray(int *a,int l,int r){
    if(l==r){
       answer ans{a[l],l,r};
       return ans;
    }else{
        int mid=(l+r)/2;
        answer ans1=find_max_subarray(a,l,mid);
        answer ans2=find_max_subarray(a,mid+1,r);
        answer ans3=find_max_crossing_subarray(a,l,mid,r);
        if(ans1.sum>=ans2.sum&&ans1.sum>=ans2.sum){
            return ans1;
        }else if(ans2.sum>=ans1.sum&&ans2.sum>=ans3.sum){
            return ans2;
        }else{
            return ans3;
        }
    }
}
int main(){
    int n;
    cin>>n; 
    int a[n];
    for(int i=0;i<n;i++)
        cin>>a[i];
    answer ans=find_max_subarray(a,0,n-1);
    cout<<ans.left<<" "<<ans.right<<" "<<ans.sum<<endl;
    return 0;
} 

 当然也有线性时间的解法（O(n) )

从头遍历一遍，当sum>max时，更新指针和max; 当sum<0时，将sum归0，因为负数加上去只会让后面的数变小，故舍弃这一段，所以sum=0,更新指针t.

#include<iostream>
using namespace std;
int main(){
    int n;
    cin>>n;
    int a[n];
    for(int i=0;i<n;i++)
        cin>>a[i];
    int sum=0,max=-999999,l=0,r=0,t=0;
    for(int i=0;i<n;i++){
        sum+=a[i];
        if(sum>max){
            max=sum;
            l=t; r=i;
        }else if(sum<0){
            sum=0;
            t=i+1;
        }
    }
    cout<<l<<" "<<r<<" "<<max<<endl; 
    return 0;
}