暴力法、分治法、动态规划法求解最大字段和

实验项目4———最大子段和问题
代码：https://www.cnblogs.com/snake-hand/archive/2011/11/26/2454431.html《发现这个博主的代码实在是太棒了》

1.问题分析: 给定由n个整数(可能有负整数)组成的序列，求该序列形如的子段和的最大值，当所有整数均为负整数时,其最大子段和为0。

2. 算法设计思路

暴力法： 对于起点 i，遍历所有长度为1,2,…,n-i+1的子区间和，遍历所有的字段，找出最大字段和。
分治算法：求解区间及其最大和，从结构上是非常适合分治法的，因为所有的子区间[start,end]之可能有以下三种可能性：
1.在【1，n/2】这个区域
2.在【n/2+1，n】这个区域
3.起点位于【1，n/2】，终点【n/2+1，n】区域

以上三种情形的最大值，就是所求的内容，前面两种情形符合子问题递归的特性，所以递归可以求出，对于第三者情形，则必然包括了n/2和n/2+1两个位置，这样就可以利用第二种穷举的思路分别向左右扩张求出
动态规划：扩展到二维空间令b[j]表示以位置 j 为终点的所有子区间中和最大的一 个子问题:如j为终点的最大子区间包含了位置j-1,则以j-1为终点的最 大子区间必然包括在其中，如果b[j-1] >0, 那么显然b[j] = b[j-1] +  a[j]，用之前最大的一个加上a[j]即可，因为a[j]必须包含；如果 b[j-1]<=0,那么b[j] = a[j] ,因为既然最大，前面的负数必然不能使你 更大。
 

3. 算法实现1.暴力法：
 

#include<iostream>
using namespace std;
int MaxSum(int a[],int n,int &besti,int &bestj){
    int sum=0;
    int i,j,k;
    for(i=1;i<=n;i++){
        int thissum=0;
        for(j=i;j<=n;j++)
        {
            thissum+=a[j];
            if(thissum>sum){
                sum=thissum;
                besti=i;
                bestj=j;
            }
        }
    }
    return sum;
    }
int main(){
    int n,a[100],m,i,j,maxsum;
    cout<<"请输入整数序列的元素个数n:"<<endl;
    cin>>n;
    cout<<"请输入序列中各元素的值a[i](一共"<<n<<"个)"<<endl;
    for(m=0;m<n;m++)
        cin>>a[m];
    int b[100];
    for(m=0;m<n;m++)
        b[m+1]=a[m];
    maxsum=MaxSum(b,n,i,j);
    cout<<"整数序列的最大子段和是："<<maxsum<<endl;
    cout<<"besti="<<i<<endl;
    cout<<"bestj="<<j<<endl;
    return 0;
}

2.分治法：

#include<iostream>

using namespace std;

int MaxSubSum(int a[],int left,int right){

    int sum=0;

    if(left==right)sum=a[left]>0?a[left]:0;

    else{

         int center=(left+right)/2;

         int leftsum=MaxSubSum(a,left,center);

         int rightsum=MaxSubSum(a,center+1,right);

         int s1=0;

         int lefts=0;

         for(int i=center;i>=left;i--){

                 lefts+=a[i];

                 if(lefts>s1)s1=lefts;

                 }

         int s2=0;

         int rights=0;

         for(int i=center+1;i<=right;i++){

                 rights+=a[i];

                 if(rights>s2)s2=rights;

                 }

         sum=s1+s2;

         if(sum<leftsum)sum=leftsum;

         if(sum<rightsum)sum=rightsum;

         }

    return sum;

}

int main(){

    int n,a[100],m,maxsum;

    cout<<"请输入整数序列的元素个数n:"<<endl;

    cin>>n;

    cout<<"请输入序列中各元素的值a[i](一共"<<n<<"个)"<<endl;

    for(m=0;m<n;m++)

        cin>>a[m];

    int b[100];

    for(m=0;m<n;m++)

        b[m+1]=a[m];

    maxsum=MaxSubSum(b,1,n);

    cout<<"整数序列的最大子段和是："<<maxsum<<endl;

    return 0;

    }

3.动态规划法：

#include<iostream>

using namespace std;

int MaxSubSum(int a[],int left,int right){

    int sum=0;

    if(left==right)sum=a[left]>0?a[left]:0;

    else{

         int center=(left+right)/2;

         int leftsum=MaxSubSum(a,left,center);

         int rightsum=MaxSubSum(a,center+1,right);

         int s1=0;

         int lefts=0;

         for(int i=center;i>=left;i--){

                 lefts+=a[i];

                 if(lefts>s1)s1=lefts;

                 }

         int s2=0;

         int rights=0;

         for(int i=center+1;i<=right;i++){

                 rights+=a[i];

                 if(rights>s2)s2=rights;

                 }

         sum=s1+s2;

         if(sum<leftsum)sum=leftsum;

         if(sum<rightsum)sum=rightsum;

         }

    return sum;

}

int main(){

    int n,a[100],m,maxsum;

    cout<<"请输入整数序列的元素个数n:"<<endl;

    cin>>n;

    cout<<"请输入序列中各元素的值a[i](一共"<<n<<"个)"<<endl;

    for(m=0;m<n;m++)

        cin>>a[m];

    int b[100];

    for(m=0;m<n;m++)

        b[m+1]=a[m];

    maxsum=MaxSubSum(b,1,n);

    cout<<"整数序列的最大子段和是："<<maxsum<<endl;

    return 0;

    }

4. 运行结果（截图）

1.暴力法运行截图：

2.分治法运行截图：

3.动态规划法运行截图：

5. 算法分析

暴力法：经过两次嵌套循环时间复杂度：O(n2) 

分治算法：每递归一次需logn，全部需要n次运算量，时间复杂度：O(nlogn)
动态规划算法：只经历了一次循环，时间复杂度：O(n)

6. 经验归纳与总结

通过时间复杂度的分析和实验结果可以看出各算法的好坏依次是动态规划算法、分治算法，BF算法，当数据较小时各算法之间的差距并不大，甚至有时BF算法还优于分治，而且数据越大，BF算法的缺点越明显，与动态规划的差距越大。