Week12 作业 C - HDU 1024

题目描述：

给定一个具有N个数的序列，求M个不相交连续子序列的最大和，相当于是最大子段和的升级版。

思路：

首先定义状态：

• 考虑第j个元素如何选择呢？很显然，第j个元素可以和第j-1个元素并在同一个段上，也可以自己单独作为一个段的开头
• 定义f[i][j]表示考虑前j个元素,分成i段能取到的最大值,a[j]必选（第i段以a[j]为结尾）
• 状态转移:f[i][j]=max{ f[i][j-1]+a[j], max{ f[i-1][k]+a[j],k=i-1,i,i+1,...,j-1 } },前者是把a[j]直接并在a[j-1]所在段的后面,后者是把a[j]单独开一个段
• 边界条件:i<=0,返回0;j<=0,返回0
• 答案:max{ f[M][K],K=M,M+1,M+2,...,N }（因为分成M段至少要M个元素）

记忆化搜索+二维数组的直接实现（容易理解）

int dp(int i, int j)
{
    if (i <= 0 || j <= 0) return 0;
    if (vis[i][j]) return f[i][j];
    vis[i][j] = 1;
    f[i][j] = dp(i,j-1) + a[j];
    for (int k = i - 1; k <= j - 1; k++)
        f[i][j] = max(f[i][j], dp(i - 1, k) + a[j]);
    return f[i][j];
}
//输出结果
int ans = -INT_MAX;
for (int i = M; i <= N; i++)
    ans = max(ans, dp(M,i));
cout << ans << endl;

不难发现，上述的时间复杂度是O(M*N*N)，空间复杂度是O(M*N)，不满足题目要求，应该进一步探索

考虑状态转移中的后者，即f[i-1][k]是不受当前状态f[i][j]的影响的，即f[i-1][k]可以在f[i][j]之前计算，那么我们就可以把f[i-1][k]的最大值在计算的时候记录下来，等到f[i][j]用的时候直接拿来，不用再去搜索，但是这样就不能用递归了，因为计算顺序有了要求

定义新数组maxF[i][j]，表示考虑前j个元素，分成i段能得到的最大值，a[j]未必选（第i段未必以a[j]结尾）

则maxF[i][j]=max{ f[i][k]，k=i,i+1,i+2,...,j }，边界条件：i<=0或j<=0时，返回0，其他位置初始化为 -INF

新的F的状态转移：f[i][j]=max{ f[i][j-1]+a[j] , maxF[i-1][j-1]+a[j] }

但是随之而来的新问题是：当f[i][j]更新时，f[i][j]可以用来更新maxF[i][j],maxF[i][j+1],maxF[i][j+2].....,这样时间复杂度又变成了O(M*N*N)，因为我们不过是从原来的向前搜求最值变成了向后搜更新最大值

以下是代码，从下述代码中，其实我们可以分析优化maxF

递推+maxF+二维数组

for (int i = 1; i <= MAXN - 1; i++)
    for (int j = 1; j <= MAXN - 1; j++)
    maxF[i][j] = -INT_MAX;
for (int i = 0; i <= MAXN - 1; i++)
    maxF[i][0] = 0, maxF[0][i] = 0;
for (int i = 1; i <= M; i++)    //M段
    for (int j = i; j <= N; j++)
    {
        f[i][j] = max(f[i][j - 1] + a[j], maxF[i - 1][j - 1] + a[j]);
        for (int k = j; k <= N; k++)
            maxF[i][k] = max(maxF[i][k], f[i][j]);
    }
cout << maxF[M][N] << endl;

降维maxF

必须延时更新，否则会覆盖需要用到的结果，而且正序枚举j

 降维maxF代码

//初始化maxF[j]=0,因为把前j个元素分成0段,很显然最大值是0
memset(maxF, 0, sizeof(maxF));
for (int i = 1; i <= M; i++)    //M段
{
    int nowMax = -INT_MAX;
    for (int j = i; j <=N; j++)
    {
        f[i][j] = max(f[i][j - 1] + a[j], maxF[j - 1] + a[j]);
        maxF[j - 1] = nowMax;    //用上一轮的最大值更新上一轮应该更新的maxF[j]
        nowMax = max(maxF[j - 1], f[i][j]);
    }
    maxF[N] = nowMax;    //当前i,没有下一轮j了,不用延时更新,直接更新
}
cout << maxF[N] << endl;

降维f

考虑最初的状态转移方程中的前者，即f[i][j-1]，发现i就是当前的i，所以第i轮的f数组f[i]和第i-1轮的数组f[i-1]是没有直接更新的联系的，所以可以直接用一维的f

最终代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 1e6 + 5;
int f[MAXN], maxF[MAXN], a[MAXN];

int main()
{
    int N, M;
    while (scanf("%d %d", &M, &N) == 2)
    {
        memset(f, 0, sizeof(f));
        
        for (int i = 1; i <= N; i++)
            scanf("%d", a + i);
        //初始化maxF[j]=0,因为把前j个元素分成0段,很显然最大值是0
        memset(maxF, 0, sizeof(maxF));
        for (int i = 1; i <= M; i++)    //M段
        {
            int nowMax = -INT_MAX;
            for (int j = i; j <=N; j++)
            {
                f[j] = max(f[j - 1] + a[j], maxF[j - 1] + a[j]);
                maxF[j - 1] = nowMax;    //用上一轮的最大值更新上一轮应该更新的maxF[j]
                nowMax = max(maxF[j - 1],f[j]);
            }
            maxF[N] = nowMax;    //当前i,没有下一轮j了,不用延时更新,直接更新
        }
        cout << maxF[N] << endl;
    }
    return 0;
}

总结

• 感想：动态规划是真的难，这题想了快三天，不过最后貌似搞懂了，但是我感觉，还有更容易理解的思路过程，至少现在明白这题这样做的原理了，还要继续加油，真的太菜了
• 其他：递推其实很难写，可以定义好状态转移之后，先写记忆化搜索理解过程，再进一步变成递推；如果更新数组时，用到的以前的状态不多，可以考虑降维（滚动数组），有时候，题目的数据范围限定了必须使用一维数组