HDU 1024 Max Sum Plus Plus (动态规划 + 滚动数组)

题目链接 题意

求最大m字段和，给一个数组，把它分成m段，求分成m段的最大和

题解

1. 首先明确使用动态规划二维的动态数组肯定是不可以的，会超内存，或超时。
2. 不过为了方便理解，还是得先来看一下二维动态数组的解题思路:
   
   1. dp[i][j] : 表示数组a的前 j 项分成 i 段，且第 j 项包含在第 i 段时的最大和
   2. 那么对于a[j]，有两种分配方案
      
      1. 要么和前 j-1 项共同组成这 i 段
      2. 要么自己单独成段，此时的最大和应该是a[j]加上前 i-1 段的最大和
      3. 即dp[i][j] = max(dp[i][j-1] , dp[i-1][k]) + a[j]. (其中 i-1<=k<=j-1 )
      4. 具体程序也贴在最下面，仅用来理解整个抽象的问题
3. 在搞清楚二维动态数组的题解之后，我们再来看一维的
   
   1. dp[j] : 前分组中，一定选第 j 项的情况下取得的最大和值
   2. dp[j] = max(dp[j-1] , MAX[j-1]) + a[j]，只需要加一个for(i=1;i<=m;i++)分别计算分成1~m段时的最大值
   3. 当分成 i 段，有 j 个数，a[j]包含在第 i 段时，就可以把dp[i][j]简写成dp[j].
   4. MAX[j-1] 等价于 dp[i-1][j-1]的最大值
4. 可以这么理解
5. 第一个for(int i=1;i<=m;i++)//控制着1~m段时的计算，不过是这个 i 没有在dp数组中表现出来
6. 那么在i=1时，表示分成1段，可简单了呢，不就是把m段子和问题转换成Max Sum问题了吗
   
   1. j=1 ：dp[1] = max(dp[0],MAX[0]) + a[1]，副产品MAX[0] = INT_MIN
   2. j=2 ：dp[2] = max(dp[1] , MAX[1] )+a[2] ，副产品MAX[1] = max(MAX[0],dp[1])
   3. j=3 ：dp[3] = max(dp[2],MAX[2]) + a[3]，副产品MAX[2] = max(MAX[1],dp[2])
   4. ……….
   5. j=n ：dp[n] = max(dp[n-1],MAX[n-1])+a[n]，副产品MAX[n-1] = max(MAX[n-2],dp[n])
   6. 这样在第一轮循环结束之后，所有的副产品已经求出来，等第二轮循环可以直接使用
   7. 这个时候再来解释MAX[j] : 显而易见等于前 j 项分成1段和前 j-1 项分成 1 段的最大值，这可巧了（有没有闻到滚动的味道），这可不就是我们在二维动态数组中费了老大力气想要求得的max(dp[i-1][k]) (i-1<=k<=j-1)吗！！！！动态规划！牛逼！
7. 在i=2时，表示把数组a分成2段，这个2段的2在dp数组中省去(j=1已经唯一确定了，这轮循环不用求)
   
   1. j=2 ：d[2] = max(dp[1],MAX[1]) + a[2]，副产品MAX[1] = max(MAX[1],dp[2])，看吧，这个时候我们在上一轮求得的副产品MAX[1]派上用场了，这轮的循环还要更新MAX[1]
   2. j=3 ：dp[3] = max(dp[2],MAX[2])+a[3]，副产品MAX[2] = max(MAX[2],dp[3])
   3. ……..

大概就是这么个意思吧，理解了这个抽象的问题之后，心里就不纠结了，哈哈哈，终于可以笑出来了。。。。
参考博客：https://blog.csdn.net/kenden23/article/details/38583111

//题解代码
#include<iostream>
#include<cstring>
using namespace std;

const int N = 1000001;

int dp[N];
int MAX[N];
int a[N];

int main(){
    int n,m,max_m_sum;
    while(scanf("%d %d",&m,&n)!=EOF){
        memset(dp,0,sizeof(dp));
        memset(MAX,0,sizeof(MAX));
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);

        for(int i=1;i<=m;i++){
            max_m_sum = INT_MIN;//无穷小
            for(int j=i;j<=n;j++){
                dp[j] = max(dp[j-1] + a[j] , MAX[j-1] + a[j]);
                MAX[j-1] = max_m_sum;
                max_m_sum = max(max_m_sum,dp[j]);
            } 
        }
        printf("%d\n",max_m_sum);
    }
    return 0;
}

//二维动态数组，便于理解代码
#include<iostream>
#include<cstring>
using namespace std;

const int N = 10001;
const int M = 10001;

int a[N];

int dp[M][N];

int dp1[2][N]; 

int main(){
    int m,n;
    while(scanf("%d%d",&m,&n)!=EOF){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
        }
        int max_sum = 0;
        memset(dp,0,sizeof(dp)); 
        for(int i=1;i<=m;i++){
            for(int j=i;j<=n;j++){
                max_sum = 0;
                for(int k=j-1;k>=i-1;k--)
                    max_sum = max(dp[i-1][k],max_sum);
                dp[i][j] = max(dp[i][j-1]+a[j],max_sum+a[j]);
            }
        }
        max_sum = 0;
        for(int i=m;i<=n;i++) max_sum = max(max_sum,dp[m][i]);
        printf("%d\n",max_sum);
    }
    return 0;
}