动态规划 hdu 1024

Max Sum Plus Plus

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

Problem Description

Now I think you have got an AC in Ignatius.L's "Max
Sum" problem. To be a brave ACMer, we always challenge ourselves to more
difficult problems. Now you are faced with a more difficult
problem.
Given a consecutive number sequence S₁,
S₂, S₃, S₄ ...
S_x, ... S_n (1 ≤ x ≤ n ≤ 1,000,000, -32768 ≤
S_x ≤ 32767). We define a function sum(i, j) =
S_i + ... + S_j (1 ≤ i ≤ j ≤ n).
Now
given an integer m (m > 0), your task is to find m pairs of i and j which
make sum(i₁, j₁) + sum(i₂,
j₂) + sum(i₃, j₃) + ... +
sum(i_m, j_m) maximal (i_x ≤
i_y ≤ j_x or i_x ≤
j_y ≤ j_x is not allowed).
But I`m
lazy, I don't want to write a special-judge module, so you don't have to output
m pairs of i and j, just output the maximal summation of
sum(i_x, j_x)(1 ≤ x ≤ m) instead.
^_^

Input

Each test case will begin with two integers m and n,
followed by n integers S₁, S₂,
S₃ ... S_n.
Process to the end of
file.

Output

Output the maximal summation described above in one
line.

Sample Input

1 3 1 2 3
2 6 -1 4 -2 3 -2 3

Sample Output

6
8

Hint

Huge input, scanf and dynamic programming is recommended；

Author

JGShining（极光炫影）

Recommend

We have carefully selected several similar problems for
you:  1074 1025 1081 1080 1160 

 

 

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

 

 

解题思路：

      用动态规划的思路，由部分推出整体，由1个数分成1组推出n个数分成m组,在每次的过程中找出最大值，就能推出整体的最大值;

首先是第一个数分成一组，再是二个数分成一组，再是三个数分成一组........。每次插入一个数有两种选择——1.将新的数插入之前的组中，2.新的数自成一组；

选哪种选择取决于谁的和最大；

1 . dp[ i ][ j ]=dp[ i ][ j-1 ]+num[ i ]; // i 表示要取的组数， j 表示数的数量；

2 . dp[ i ][ j ]=dp[ i-1 ][ k ]+num[ i ]; //   i-1<=k<j  k表示数的数量 ，i-1 表示要取的组数；

每次不断向dp里加数，因为每次都符合条件，所以最终的结果也符合条件；

dp[ i ][ j ]=max( dp[ i ][ j-1 ] ，max( dp[ i-1 ][ k ] ) )+num[ i ]; ( i-1<=k<j );

 

表：

         1       2       3       4      5       6      7

0      -2      11     -4      13     -5      6      -2

1      -2     11      7      20     15    21     19

2             9       7       24     19     26     24

3                      5        22     19    30     28

4                                18      17    28     28

5                                          13    24     26

6                                                   19    22

7                                                          17

 

如表，首先是1行1列满足，再是2行，三行，四行满足，这样下去所有都满足；

 如果用dp[ i ][ j ]去存数据会占用很多内存，可能会超内存；

可以发现，在运行时只有两行是处于运行的，其他的之后没用过，因此可以用两个数组去保存这两行，然后不断更新这两行；

用pre[ ]数组去保存前一行，用dp[ ]数组去保存后一行；

int dp[maxn],pre[maxn],arr[maxn];
int temp,n,m;

arr[ ]储存输入的数；

        for(int k=;k<=m;k++)
        {
            temp=-inf;
            for(int j=k;j<=n;j++)
            {
                dp[j]=max(dp[j-],pre[j-])+arr[j];
                pre[j-]=temp;
                temp=max(temp,dp[j]);
            }
        }

用temp来找出 j 个数取 k 组所得的组的最大和；同时把它记入在pre[ ]中，用于进行下次更新；

dp[j]=max(dp[j-1],pre[j-1])+arr[j];此时dp[j]和dp[j-1]有同样的组数，

dp[j]=dp[j-1]+arr[j]; // 表示把第j个数加入dp[j-1]的其中一组，能保持组数不变；

dp[j]=pre[j-1]+arr[j]; // 表示让第j个数独成一组，再加上比dp[j]少一组的组集中的最大的；

两者中选择大的组合方式；

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int maxn=+;
const int inf=0x3f3f3f3f;

int dp[maxn],pre[maxn],arr[maxn];
int temp,n,m;

int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        for(int i=;i<=n;i++)
        {
            scanf("%d",&arr[i]);
        }
        memset(dp,,sizeof(dp));
        memset(pre,,sizeof(pre));
        for(int k=;k<=m;k++)
        {
            temp=-inf;
            for(int j=k;j<=n;j++)
            {
                dp[j]=max(dp[j-],pre[j-])+arr[j];
                pre[j-]=temp;
                temp=max(temp,dp[j]);
            }
        }
        printf("%d\n",temp);
    }
    return ;
}