hdu1231 连续子数组最大和（分治，动态规划）

///后来补充，以HDU1231为例

//朴素算法
#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;

typedef long long ll;
int a[10010];
ll sum[10010];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF&&n!=0){
        sum[0]=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            sum[i]=sum[i-1]+a[i];
        }
        ll res=0;
        int flag=0;
        int tempx=a[1];
        int tempy=a[n];
        for(int i=1;i<=n;i++){
            for(int j=0;j<i;j++){
                if(res<=sum[i]-sum[j]){
                    if(res==sum[i]-sum[j]&&flag) continue;
                    if(flag==0&&res==0){
                        flag=1;
                    }
                    res=sum[i]-sum[j];
                    tempx=a[j+1];
                    tempy=a[i];
                }
            }
        }
        cout<<res<<" "<<tempx<<" "<<tempy<<endl;
    }
}


//算贪心吧，当前和如果小于0则重新从0开始，否则继续累加，维护一个出现过的最大值
//也算DP，状态转移方程为：sum[i]=max(sum[i-1]+a[i],0)
#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long ll;
int a[10010];
ll sum[10010];
ll maxn;
int flag;
int main()
{
    int n;
    while(~scanf("%d",&n)&&n){
        sum[0]=0;
        maxn=0;
        int left,right,cou_left,cou_right;
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
        }
        flag=0;
        left=cou_left=a[1];
        right=cou_right=a[n];
        for(int i=1;i<=n;i++){
            //dp[i]=max((ll)0,dp[i-1]+a[i]);
            if(sum[i-1]+a[i]>0){
                sum[i]=sum[i-1]+a[i];
                if(flag==0){
                    left=a[i];
                    flag=1;
                }
            }
            else{
                sum[i]=0;
                flag=0;
            }
            //maxn=max(maxn,dp[i]);
            if(maxn<sum[i]){
                maxn=sum[i];
                cou_right=right=a[i];
                cou_left=left;
            }
        }
        if(maxn==0){
            for(int i=1;i<=n;i++){
                if(a[i]==0){
                    cou_left=cou_right=0;
                    break;
                }
            }
        }
        cout<<maxn<<" "<<cou_left<<" "<<cou_right<<endl;
    }
}

///之前写的:

1）开心，学习伪码之后，自己敲完的代码；发现《导论》在纯粹的算法知识方面比紫书讲的更细致，更好懂一些。

分治策略，旨在将原先的大问题不断分解成规模小的问题，比如求最大连续子数组之和，先将原数组以中间界线分为三部分，左边是中界线左边的元素，右边是中界线右边的元素，第三部分是两边都有分布的元素的集合，因为最大连续子数组之和一定是这三部分之其中的一个，所以最后比较这三部分中最大的，就是最大连续子数组之和，也是该函数的返回值。而左边、右边的计算都继续递归分治函数，直到只有一个元素为止，而第三部分是以中间界线分别向左、向右连续相加，找出最大连续子数组之和，这是最关键的一步，迭代次数为n=（mid-low+1）+(high-mid),也是将原本O（n^2）算法通过分治降为O（nlogn）的主要原因。

#include <iostream>

using namespace std;
int A[13];
int hebing(int low,int mid,int high)
{
    int sum_left=A[mid];
    int temp=0;
    for(int i=mid;i>=low;i--){
        temp+=A[i];
        if(temp>sum_left)
            sum_left=temp;
    }
    int sum_righ=A[mid];
    temp=0;
    for(int i=mid+1;i<=high;i++){
        temp+=A[i];
        if(temp>sum_righ)
            sum_righ=temp;
    }
    return sum_left+sum_righ;
}
int fenzhi(int low,int high)
{
   if(low==high){
        return A[low];
   }
   else{
        int mid=(low+high)/2;
        int left_max=fenzhi(low,mid);
        int righ_max=fenzhi(mid+1,high);
        int mid_max=hebing(low,mid,high);
        if(left_max>righ_max&&left_max>mid_max){
            return left_max;
        }
        else if(righ_max>left_max&&righ_max>mid_max){
            return righ_max;
        }
        else{
            //cout<<mid_max<<endl;
            return mid_max;
        }
   }
}
int main()
{
    for(int i=0;i<=4;i++){
        cin>>A[i];
    }
    cout<<fenzhi(0,4);
}