Max Sum（HDU1003）求最大子序列和（dp）题解

题目链接http://acm.hdu.edu.cn/showproblem.php?pid=1003

题目大意：一段给出的数列（有正有负） ，求使得和最大的子序列

原题英文版

输入：T（测试样例数目）N（单个测试样例的数据个数）

接下来N行为测试各个样例的输入

输出：

Case 1： 

输出最大子序列的和，最大子序列的开始位置，结束位置

Case 2：。。。。

 解题思路;直接暴力搜索，n^2当=100000必定超时，

方法1;决定采用动态规划，此处又名在线处理（O(N））

两个关键点：

假设在此时最大子序列的起始位置还是1时；

当前面n-1数和加上第n个数>max,则更新最长子序列的节点（首尾都换，实际上第一次sum没有小于0的情况只需要换尾部位置，建议结合第二个关键点一起看）

当前面n-1数和加上第n个数<0,则说明包含第n+1个数的子序列不需要前n个数（都小于0要你干什么，sum重置为0，将此时第n+1个数的位置记下来，后面发现更大的子序列时，这个为头位置，当后续sum又大于max，此时的最长子序列，应该从这里开始了）

如果觉得讲的太乱了，直接看代码吧。

#include <iostream>
using  namespace std;
int main()
{
	int t;
	cin >> t;
	int n, a[100005] = { 0 },first,end,sum,max,flag;
	for (int k = 1; k <= t; k++)
	{
		cin >> n;
		sum = 0;
		max = -99999999;
		first = 0,end=0,flag=0;//flag用来标识最长子序列的起始位置，初始化为0，
								//如果没有sum<0的情况，更新最长子序列的首尾位置时，对起始位置没有影响
		for (int j = 0; j < n; j++)
		{
			scanf("%d", &a[j]);
		}
		for (int i = 0; i < n; i++)
		{
			sum = sum + a[i];
			if (sum > max)     //如果找到了更大的子序列，需要更换记录的首尾位置
			{
				first = flag;
				end = i;
				max = sum;
				
			}
			if (sum < 0)       //出现sum<0的情况，子序列中断，下个位置开始的子序列有可能会成为最大子序列
								//所以要把这个位置用flag记下，以便下次更新使用
			{
				sum = 0;
				flag =i+1 ;
			}
		}
		printf("Case %d:\n", k);
		
		printf("%d %d %d", max, first + 1, end + 1);

		printf("\n\n");
	}
	return 0;
}

方法2：分而治之思想（mooc浙江大学数据结构第一节算法3分治思想），

课件代码：（只给了最大值，没给首尾位置）

int Max3( int A, int B, int C )
{ /* 返回3个整数中的最大值 */
    return A > B ? A > C ? A : C : B > C ? B : C;
}

int DivideAndConquer( int List[], int left, int right )
{ /* 分治法求List[left]到List[right]的最大子列和 */
    int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
    int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/

    int LeftBorderSum, RightBorderSum;
    int center, i;

    if( left == right )  { /* 递归的终止条件，子列只有1个数字 */
        if( List[left] > 0 )  return List[left];
        else return 0;
    }

    /* 下面是"分"的过程 */
    center = ( left + right ) / 2; /* 找到中分点 */
    /* 递归求得两边子列的最大和 */
    MaxLeftSum = DivideAndConquer( List, left, center );
    MaxRightSum = DivideAndConquer( List, center+1, right );

    /* 下面求跨分界线的最大子列和 */
    MaxLeftBorderSum = 0; LeftBorderSum = 0;
    for( i=center; i>=left; i-- ) { /* 从中线向左扫描 */
        LeftBorderSum += List[i];
        if( LeftBorderSum > MaxLeftBorderSum )
            MaxLeftBorderSum = LeftBorderSum;
    } /* 左边扫描结束 */

    MaxRightBorderSum = 0; RightBorderSum = 0;
    for( i=center+1; i<=right; i++ ) { /* 从中线向右扫描 */
        RightBorderSum += List[i];
        if( RightBorderSum > MaxRightBorderSum )
            MaxRightBorderSum = RightBorderSum;
    } /* 右边扫描结束 */

    /* 下面返回"治"的结果 */
    return Max3( MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum );
}

int MaxSubseqSum3( int List[], int N )
{ /* 保持与前2种算法相同的函数接口 */
    return DivideAndConquer( List, 0, N-1 );
}

我理解后的完整代码

解决递归输出位置问题我用了结构体pos同时存储·值和位置(太聪明了）

解决多个解时输出最早的解（在Max3时，是左边的最大值结构为temp，除非右边值和过中线比他大才会替换）

上代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
struct pos//引入结构体，存储最大值的同时记下位置
{
	int value = 0;
	int posl = 0;
	int posr = 0;
};

pos Max3(pos a, pos b, pos c)//求三数最大
{
	pos temp=a;
	if (c.value > temp.value)
		temp = c;
	if (temp.value < b.value)
		temp = b;
	return temp;
}
pos  findmax(int* a, int left,int right)//递归
{
	pos P;
	if (left == right)//不可二分时只有一个值，即为最大，结束递归
	{
		P.value = a[left];
		P.posl = left;
		P.posr = left;
		return P;
	 }
	 pos maxleft, maxright;
	 int mid = (left + right) / 2;
	 maxleft = findmax(a, left, mid);//二分递归
	 maxright = findmax(a, mid + 1, right);//二分递归
	 int maxmidleft=-99999999, midleft=0, maxmidright=-99999999, midright=0;
	 int mi=0, mj=0;
	 for (int i = mid; i >= left; i--)//从中线往左边找找最大和
	 {
		 midleft += a[i];
		 if (maxmidleft <= midleft)
		 {
			 maxmidleft = midleft;
			 mi = i;
		 }
	 }
	 for (int j = mid + 1; j <= right; j++)//从右边找
	 {
		 midright += a[j];
		 if (maxmidright < midright)
		 {
			 maxmidright = midright;
			 mj = j;
		 }
	 }
	 pos M;
	 M.value = (maxmidleft + maxmidright);
	 M.posl = mi;
	 M.posr = mj;
	 return Max3(maxleft, maxright, M);//返回右二分区的最大值，左二分区最大值，经过中线最大值的中的三数最大的结构体


}
int main()
{
	int k;
	scanf("%d", &k);
	int a[100005];
		for (int i = 0; i < k; i++)
		{
			scanf("%d", &a[i]);
		}
		pos ans= findmax(a, 0,k-1);
		cout << ans.value << " " << ans.posl << ' ' << ans.posr;
		return 0;

}

浙大的题对输出有点改动

//注意浙大的题改了，不是输出位置，而是输出该位置的值，而且对全队列都为负数只要输出sum=0队列的首尾值
		if (ans.value >= 0)
			cout << ans.value << " " << a[ans.posl] << ' ' << a[ans.posr];
		else
			cout <<0<<' '<< a[0] << " " << a[k - 1];
		return 0;