（最大m子段和） Max Sum Plus Plus （Hdu 1024）

http://acm.hdu.edu.cn/showproblem.php?pid=1024

 

 

Max Sum Plus Plus

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

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

 

 

 

/**

 

设 Num 为给定数组，n 为数组中的元素总数，Status[i][j]表示前 i 个数

在选取第 i 个数的前提下分成 j 段的最大值，其中 1<=j<=i<=n && j<=m，状态转移方程为：

Status[i][j]=Max(Status[i-1][j]+Num[i]，Max(Status[0][j-1]~Status[i-1][j-1])+Num[i])；

 

dp[i][j] 代表前 j 个数，组成 i 组的和的最大值

决策： 第 j 个数，是包含在第 i 组里面，还是自己独立成组

方程  dp[i][j] = max(dp[i][j-1]+a[j], max(dp[i-1][k]) + a[j]) 0<k<j

空间复杂度，m 未知，n<=1000000, 继续滚动数组

时间复杂度，n^3,  n<=1000000,显然会超时，继续优化

 

max(dp[i-1][k]) 就是上一组0...j-1的最大值。我们可以在每次计算dp[i][j]的时候记录

下前 j 个的最大值用数组保存下来，下次计算的时候可以用，这样时间复杂度为n^2

 

**/

 

 

这里的最小情况是只分成一段的时候，就退化为最大子段和问题了，这个是段数的最小情况了； 如果只有0个数的时候，结果肯定为零了，或者如果只有一个数的时候就是这个数了，那么数列只有0个或者1个的时候就是数组的最小情况了。

然后记录使用一个数组记录dp[MAX_N]，其中dp[i]的含义就是在一定选择i这个数的时候得到的最大和值。

这样如果分成i段，有j个数的时候dp[j] = max(dp[j-1]+arr[j], MAX[j-1]+arr[j])，其实如果使用二维数组，那么MAX[j-1] == dp[[i-1][j-1]这个状态格的数值，表示分成i-1段的时候，有j-1个数的值。取max就是表示arr[j]是直接和dp[j-1]即接在后面第i段，还是独立成为一段的值比较大，选择最优方案，取最大值。

 

 

#include <stdio.h>
#include <vector>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <limits.h>
#include <stack>
#include <queue>
#include <set>
#include <map>
using namespace std;

const int MAX_N = 1000001;
int dp[MAX_N], MAX[MAX_N], arr[MAX_N];

int main()
{
    int n, m, maxSum;
    while (~scanf("%d %d", &m, &n))
    {
        memset(MAX, 0, sizeof(int) * (n+1));
        memset(dp, 0, sizeof(int) * (n+1));
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", arr+i);
        }
        for (int i = 1; i <= m; i++)
        {
            maxSum = INT_MIN;
            for (int j = i; j <= n; j++)
            {
                dp[j] = max(dp[j-1]+arr[j], MAX[j-1]+arr[j]);
                MAX[j-1] = maxSum;   
                   maxSum = max(maxSum, dp[j]);
            }
        }
        printf("%d\n", maxSum);
    }
    return 0;
}