hdu1003

Max Sum

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 138410    Accepted Submission(s): 32144

Problem Description

Given a sequence a[1],a[2],a[3]......a[n], your job is to calculate the max sum of a sub-sequence. For example, given (6,-1,5,4,-7), the max sum in this sequence is 6 + (-1) + 5 + 4 = 14.

 

Input

The first line of the input contains an integer T(1<=T<=20) which means the number of test cases. Then T lines follow, each line starts with a number N(1<=N<=100000), then N integers followed(all the integers are between -1000 and 1000).

 

Output

For each test case, you should output two lines. The first line is "Case #:", # means the number of the test case. The second line contains three integers, the Max Sum in the sequence, the start position of the sub-sequence, the end position of the sub-sequence. If there are more than one result, output the first one. Output a blank line between two cases.

 

Sample Input

2 5 6 -1 5 4 -7 7 0 6 -1 1 -6 7 -5

 

Sample Output

Case 1: 14 1 4 Case 2: 7 1 6

 

Author

Ignatius.L

这题是一个经典dp问题，dp思想在于把问题分解成若干个子问题，在子问题最优的情况下得出最终最优结果，所以我们每一步都是建立在前一步是最优的基础之上的。所以解决dp问题，最基本的要在某种情景下，想到当前状态的最优情况是什么样的，最优后，接下来怎么办，不是最优的该怎么变成最优的。这就是我们的状态转移方程。

对于本问题，首先明确，连续的子段！ 和最大 ，一个数组给我们，第一个数肯定当前最大，毋庸置疑，那么遇到下一个数，怎么判断和是当前最大呢？我们遇到正数，那肯定直接加，因为加完肯定比不加大，如果是负数呢？加上去，原来的和肯定变小，但不加怎么办呢？

基于以上问题 可以得出状态方程 dp[i]=d[i-1]+a[i]>a[i]?dp[i-1]+a[i]:a[i]  (dp[i]表示当前i下最大的子段和，a[i]是需要处理的数字)什么意思呢，当前数字加到之前的和上面后，如果大于当前数字，那么就执行加的操作，如果小于当前数字，就把当前和最大值dp[i]设置为a[i]，可能有人问为什么要设置为a[i]。。记住，如果a[i]你不加上去，意味着你需要从新开始累加和了，我们要求是连续的子段和！！！

利用dp数组的代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
//#define LOCAL   
using namespace std;


int main()
{
#ifdef LOCAL
freopen("d:datain.txt","r",stdin);
freopen("d:dataout.txt","w",stdout);
#endif 
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int i,m;
        for(i =0 ; i< n;i++)
        {
            scanf("%d",&m);
            int dp[100000],a[100000];
            scanf("%d",&a[0]);
            dp[0] = a[0];  //当前最大
            for(int j = 1; j<m;j++)   //生成了dp状态数组了
            {
                scanf("%d",&a[j]);
                if(dp[j-1]+a[j]<a[j])      //状态转移方程
                    dp[j]=a[j];
                else
                    dp[j]=dp[j-1]+a[j];
            }
            int Max,End;
            Max = dp[0];
            End = 0;
            for(int j = 1 ;j<m;j++)           //寻找区间
                if(Max<dp[j])
                {
                    End = j;
                    Max = dp[j];
                }
            int Begin = End;
            int temp = 0;
            for(int j = End;j>=0;j--)
            {
                temp +=a[j];
                if(temp==dp[End])
                    Begin = j;
            }
            cout<<"Case "<<i+1<<":"<<endl<<Max<<" "<<Begin+1<<" "<<End+1<<endl;
            if(i<n-1)
                cout<<endl;
        }
    }
    return 0;
}

简化后不带dp数组的，因为这题在dp问题中是比较简单的。

//hdu 1003

#include<stdio.h>
int main()
{

    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i = 0;i<n;i++)
        {
            int a;
            int Max  = -9999;
            int sum  = 0,m;
            int Begin=0,End=0,flag=0;
            scanf("%d",&m);
            scanf("%d",&a);
            Max = sum = a;
            for(int j = 1 ;j<m ;j++)
            {
                scanf("%d",&a);
                if(sum<0)
                {
                    sum=a;
                    flag=j;
                }
                else
                {

                    sum=sum+a;
                }
                if(Max<sum)
                {
                    Max = sum ;
                    Begin =flag;
                    End = j;
                }
            }
            printf("Case %d:
%d %d %d
",i+1,Max,Begin+1,End+1);
            if(i<n-1)
                printf("
");
        }

    }
    return 0;
}