问题定义：
给定n个整数（可能为负数）组成的序列a[1],a[2],a[3],…,a[n],求该序列如a[i]+a[i+1]+…+a[j]的子段和的最大值(0<i<j<n)。当所给的整均为负数时定义子段和为0，依此定义，比如{5,-3,4,2}的最大子序列就是 {5,-3,4,2}，它的和是8,达到最大；而 {5,-6,4,2}的最大子序列是{4,2}，它的和是6。
方法一：学过程序设计的都会，那就是枚举i和j，求i和a[i]到a[j]之间的和的最大值。
int maxsub(int *a,int n)
{
int i,j,k,maxn=0;
for(i = 0 ; i < n ; i++)
{
for(j = i+1 ; j < n ;j++)
{
int temp_max = 0 ;
for(k = i ; k <= j ;k++)
{
temp_max+=a[k];
}
if(temmax > maxn)
{
maxn = temp_max;
}
}
}
return maxn;
}
时间复杂度O（n^3）。这显然是不能接受滴。其实这其中进行了大量的重复计算。
方法二：
可以把字段和结果线计算出来啊，存储到s[]数组中，即预处理
int sum = 0.s[n];
for(i = 0 ; i < n ; i++)
{
sum+=a[i];
s[i]=sum;
}
这样在每次计算a[i]到a[j]之间的数和的时候就等于s[j]-s[i]。如此优化时间复杂度变为O（n^2）.好一些了，能不能优化呢？显然在优化就是O（n*logn）和O（n）了吧！
方法三：
考虑能不能有O（n*logn）的算法呢？当然有了……
如果将给定的序列a[1..n]分成长度相等的两段a[1..n/2]和a[n/2+1:n]，分别求出这两段的最大字段和。则该给定序列的最大字段和有三种情行：
1）和a[1..n/2]的最大字段和相同。
2）和a[n/2+1:n]的最大字段和相同。
3）最大字段和包含两部分，一部分在中，另一部分在a[n/2+1..n]中。
前两种情形我们可以用递归方法求出，第三种情形可以分别求出两部分的最大字段和值再相加（注：a[1..n/2]这部分求最大字段和要以a[n/2]结束，a[n/2+1..n] 这部分求最大字段和要以a[n/2+1]开始）。序列的最大字段和即为这三种情形的最大值。
int maxSubItem(int *a,int low,int high)
{
int s1,s2,s31,s32,i,j;
int sum;
int mid = ( low + high ) / 2;
if(low == high)
return a[low];
else
{
s1 = maxSubItem(a,low,mid);
s2 = maxSubItem(a,mid+1,high);
i = mid;
s31 = a[mid];
while ((s31 + a[i-1] > s31) && (i > low))
{
s31 += a[i-1];
i--;
}
j = mid + 1;
s32 = a[mid + 1];
while ((s32 + a[j + 1] > s32) && (j < high))
{
s32 += a[j + 1];
j++;
}
sum = s31 + s32;
if(sum < s1) sum = s1;
if(sum < s2) sum = s2;
}
}
这种情况下，显然时间复杂度为O(n*logn)。要是有O（n）的算法该多好呢？事实上还真有。这自然就是要想到动态规划了吧！！！
方法四：
int maxsub(int a,int n)
{
int temp = 0,maxn = -INF,k=1
int start,end;
for(i = 1 ; i <= n ;i++)
{
temp+=a[i];
if(temp > maxn)
{
maxn = temp;start = k ;end = i;
}
if(temp < 0)
{
temp = 0;k = i+1;
}
}
return maxn;
}
分析一下这个算法，借用了一个临时变量temp，其实有三种情况：
1. 若temp>maxn则更新maxn，并保存开始和结束位置；
2. 若temp<0则令temp = 0，因为temp<0则不可能继续用temp更新最大值了；
3. 若0<temp<maxn，则不作操作，这是temp被认为是有潜力的，可能会用来更新后面的值。这样的一次遍历搜索到了所有的最大值。
（temp的使用时关键，好好理解这种思想。理解不了也没关系，这是比较难想的方法。）
