最大子段和问题

问题情境：

给定n个整数（有可能是负数）组成的序列，要求分别用蛮力法，减治法和动态规划法，求最该序列的最大子段和，并对它们的效率进行比较分析。

蛮力法：

也称穷举法或枚举法，是一种简单直接地解决问题的方法，常常基于问题的描述，所以，蛮力法也是最容易应用的方法。它依赖的基本技术是遍历，采用一定的策略依次处理待求解问题的所有元素，从而找出问题的解。 

 减治法：

将原问题分解为若干个子问题，并且原问题的解与子问题的解之间存在某种确定的关系，这种关系通常表现为：

1）原问题的解只存在于其中一个较小规模的子问题中；

2）原问题的解与其中一个较小规模的解之间存在某种对应关系。

动态规划法：

动态规划法将待求解问题分解成若干个相互重叠的子问题，每个子问题对应决策过程的一个阶段，一般来说，子问题的重叠关系表现在对给定问题求解的递推关系（称动态规划函数）中，将子问题的解求解一次并填入表中，当需要再次求解此子问题时，可以通过查表获得该子问题的解，从而避免了大量重复计算。

求解过程：

1）划分子问题：将原问题分解为若干个子问题，每个子问题对应一个决策阶段，并且子问题之间具有重叠关系。

2）确定动态规划函数：根据子问题之间的重叠关系找到子问题满足的递推关系式（即动态规划函数），这是关键。

3）填写表格：设计表格，以自底向上的方式计算各个子问题的解并填表，实现动态规划过程。

代码实践：

#include<iostream>
#include<time.h>
#include<Windows.h>
using namespace std;
#define MAX 10000
//蛮力法
int BF_Sum(int a[],int n)
{
	int max=0;
	int sum=0;
	int i,j;
	for(i=0;i<n-1;i++)
	{
		sum=a[i];
		for(j=i+1;j<n;j++)
		{
			if(sum>=max)
			{
				max=sum;
			}
			sum+=a[j];
		}
	}
	return max;
}
//分治法
int maxSum1(int a[],int left,int right)
{
	int sum=0;
	if(left==right)  //如果序列长度为1，直接求解
	{
		if(a[left]>0)   
			sum=a[left];
		else 
			sum=0;
	}
	else
	{
		int center=(left+right)/2;   //划分
		int leftsum=maxSum1(a,left,center);
		int rightsum=maxSum1(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 j=center+1;j<=right;j++)
		{
			rights+=a[j];
			if(rights>s2)
				s2=rights;
		}
		sum=s1+s2;
		if(sum<leftsum)
			sum=leftsum;
		if(sum<rightsum)
			sum=rightsum;
	}
	return sum;
}
//动态规划法
int DY_Sum(int a[],int n)
{
	int sum=0;
	int *b=(int*)malloc(n*sizeof(int));
	b[0]=a[0];
	for(int i=1;i<n;i++)
	{
		if(b[i-1]>0)
			b[i]=b[i-1]+a[i];
		else 
			b[i]=a[i];
	}
	for(int j=0;j<n;j++)
	{
		if(b[j]>sum)
			sum=b[j];
	}
	delete []b;
	return sum;
}
//主函数
int main()
{
	int num[MAX];
	int i;
	const int n=40;
	LARGE_INTEGER begin, end,frequency;
	QueryPerformanceFrequency(&frequency);

	cout<<"生成随机序列：";
	srand(time(0));
	for(i=0;i<n;i++)
	{
		if(rand()%2==0)
			num[i]=rand();
		else
			num[i]=(-1)*rand();
		if(n<100)
			cout<<num[i]<<" ";

	}
	cout<<endl;

	cout<<"\n蛮力法："<<endl;
	cout<<"最大字段和：";
	QueryPerformanceCounter(&begin);
	cout<<BF_Sum(num,n)<<endl;
	QueryPerformanceCounter(&end);
	cout<<"时间："<<(double)(end.QuadPart-begin.QuadPart)/frequency.QuadPart<<"s"<<endl;

	cout<<"\n分治法："<<endl;
	cout<<"最大字段和：";
	QueryPerformanceCounter(&begin);
	cout<<maxSum1(num,0,n)<<endl;
    QueryPerformanceCounter(&end);
	cout<<"时间："<<(double)(end.QuadPart-begin.QuadPart)/frequency.QuadPart<<"s"<<endl;

	cout<<"\n动态规划法："<<endl;
	cout<<"最大字段和：";
	QueryPerformanceCounter(&begin);
	cout<<DY_Sum(num,n)<<endl;
	QueryPerformanceCounter(&end);
	cout<<"时间："<<(double)(end.QuadPart-begin.QuadPart)/frequency.QuadPart<<"s"<<endl;

	system("pause");
	return 0;


}

 运行结果：