HDU 1024 Max Sum Plus Plus

最新推荐文章于 2020-04-07 10:12:03 发布

Low丶Coder

最新推荐文章于 2020-04-07 10:12:03 发布

阅读量136

点赞数

CC 4.0 BY-SA版权

分类专栏： DP

本文链接：https://blog.youkuaiyun.com/sinat_37158899/article/details/79550421

DP 专栏收录该内容

28 篇文章

订阅专栏

本文详细探讨了动态规划在解决最大子序列和问题中的应用，通过实例分析了状态转移方程的推导过程，介绍了如何优化空间复杂度以适应大规模数据，并强调了在处理此类问题时需要注意的输入效率问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Max Sum Plus Plus

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

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

正式开启DP之路！

没想到第一题就开了一道需要各种优化和压缩的dp....导致这一题看了两星期看遍了网上的题解。

一开始就理解最终的状态转移方程完全看不懂。看了详细的一步步地优化才勉强理解。

题意是给你一个序列，要你把这个序列分段，分出m段使得这m段的总和最大。

使用dp方程dp[i][j]记录将前j个数分成i段，并且以第j个数作为最后一个元素时的最大值。

一开始一直想不明白为什么要以第j个数作为结尾，后来想明白了。

这是一个无后效性符合dp转移方程的状态。

以下copy：

所要达到的状态 :dp[i][j].

需要的条件：1、前j-1个数，组成i段的最大和；2、前j-1个数，组成的i-1段的最大和。

解释：由dp[i-1][j-1]到dp[i][j]，指的是当前第j个数单独为一段，dp[i][j-1]->dp[i][j]，第j个数接在第i段后面。

继续深入：我们是要求dp[i-1][j-1],dp[i][j-1]的最大值。那么i段就是在当前这个循环更新i->n状态的，所以dp[i][j-1]时刻在更新，反之，当前dp[i-1][j-1]的状态没有得到更新，那么我们就要加入这个j号元素进入时的更新保证dp[i-1][j-1]是当前可满足状态中最大的。

完全的动态规划转移方程dp[i][j]=MAX(dp[i][j-1],dp[i-1][k]) 其中i<=k<=j。

用自己的话来说的话，就是：

先计算分成一段以每个元素作为结尾的最大值，再计算分成两段，每一次都有两种可能。

要不就是与前一个元素连接，要不就是单独成一段，那单独成一段就需要从上一次一段的状态中寻找再想相加。

依次类推下去。

给一副图作为示例

比如要将-1 4 -2 3 -2 3这6个数分为4段

可以从这里得到一些信息，首先j的循环是从段数i开始，因为将前j-1个数分为i段不可能做到（比如将3个数分为4段）

此外，j的上届也可以做一些优化以减少时间复杂度。可以画一条线

为了计算dp[m][n]在前i段j不必计算到第n个数

所以j的范围就是[ i , i + n - m ]

这样我们便可以写出第一版的代码了。

//#include <bits/stdc++.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <stack>
#include <algorithm>
#include <map>
#define __max(a,b)  (((a) > (b)) ? (a) : (b))
#define __min(a,b)  (((a) < (b)) ? (a) : (b))
using namespace std;
const int maxn = 500;
const int N = 1e6+10;
bool used[N][maxn];
bool Prime[maxn];
char maze[maxn][maxn];
typedef pair<int,int> P;
int dx[] = {-1,0,0,1,0,0};
int dy[] = {0,-1,1,0,0,0};
int dz[] = {0,0,0,0,-1,1};
typedef long long ll;
int a[maxn];
int dp[maxn][maxn];
int pre[maxn];
int n,m;
using namespace std;
int main()
{
    std::ios::sync_with_stdio(false);
    while(cin>>m>>n){
        int sum = -1;
        memset(dp,0,sizeof(dp));
        for(int i = 1; i <= n; i++)
            cin>>a[i];
        for(int i = 1; i <= m; i++)
            for(int j = i; j <= n-m+i; j++)
            {
                if(j == i)dp[i][j] = dp[i-1][j-1] + a[j];
                else{
                    dp[i][j] = max(dp[i][j],dp[i][j-1]+a[j]);//并在前一个元素组成一段
                    for(int k = i-1; k < j; k++)
                        dp[i][j] = max(dp[i][j],dp[i-1][k]+a[j]);//单独成段
                }
            }
        sum = *max_element(dp[m], dp[m]+n+1);//找到分成m段的最大值
        cout<<sum<<endl;
    }
    return 0;
}

回头再看：n的最大值为100W，二维数组出来就需要巨额的空间。但是想象，当前需要更新的状态是不是就与当前上一状态和上一层的状态有关。

最终解决办法：采用滚动数组（或者两个一维数组）。

滚动数组：

//#include <bits/stdc++.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <stack>
#include <algorithm>
#include <map>
#define __max(a,b)  (((a) > (b)) ? (a) : (b))
#define __min(a,b)  (((a) < (b)) ? (a) : (b))
using namespace std;
const int maxn = 500;
const int N = 1e6+10;
bool used[N][maxn];
bool Prime[maxn];
char maze[maxn][maxn];
typedef pair<int,int> P;
int dx[] = {-1,0,0,1,0,0};
int dy[] = {0,-1,1,0,0,0};
int dz[] = {0,0,0,0,-1,1};
typedef long long ll;
int a[maxn];
int dp[2][N];
int pre[maxn];
int n,m;
using namespace std;
int main()
{
    std::ios::sync_with_stdio(false);
    while(cin>>m>>n){
        int sum = -1;
        memset(dp,0,sizeof(dp));
        for(int i = 1; i <= n; i++)
            cin>>a[i];
        int flag = 0;//只记录当前状态和上一状态
        for(int i = 1; i <= m; i++){
            for(int j = i; j <= n-m+i; j++)
            {
                if(j == i)dp[flag][j] = dp[!flag][j-1] + a[j];
                else{
                    dp[flag][j] = max(dp[flag][j],dp[flag][j-1]+a[j]);
                    for(int k = i-1; k < j; k++)
                        dp[flag][j] = max(dp[flag][j],dp[!flag][k]+a[j]);
                }
            }
            flag = !flag;//滚动数组
        }
        sum = *max_element(dp[!flag], dp[!flag]+n+1);
        cout<<sum<<endl;
    }
    return 0;
}

优化了空间，时间复杂度还是太高这样仍会TLE

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

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

此外，不能用cin输入太大会超时只能用scanf

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <string>
#include <iostream>
#include <math.h>
#include <queue>
#include <vector>
int n,m;
const int maxn = 1e6+10;
using namespace std;
bool used[200][200];
char maze[50][50];
typedef pair<int,int> P;
int ans = -1;
int a[maxn];
int dx[] = {0,1,0,-1};
int dy[] = {1,0,-1,0};
int mmax[maxn];//记录前一组的最大值
int dp[maxn];
const int INF = 0xffffff;
int main()
{
   // std::ios::sync_with_stdio(false);
    int n,m,ans;
    while(~scanf("%d%d",&m,&n))
    {

        for(int i = 1; i <= n; i++)
            scanf("%d",&a[i]);
        memset(mmax,0,sizeof(mmax));
        memset(dp,0,sizeof(dp));
        for(int i = 1; i <= m; i++)
        {
            ans = -INF;
            for(int j = i; j <= n; j++)
            {
                dp[j] = max(dp[j-1],mmax[j-1]) + a[j];
                mmax[j-1] = ans;
                ans = max(ans,dp[j]);
            }
        }
        printf("%d\n",ans);
    }
}

dp可真难QAQ