HDU 1024

题目很简单， 长度为 n 的数组，选取 m 个不重叠片段，使得所有和最大。。。

dp 解决

dp[ i ] [ j ] [ k ] ( 表示前 i 个数字内 分成 j 个片段，k 为 0 或 1 ，0代表不选当前数，1代表选择当前数）

那么 k = 0 时

dp[ i ] [ j ]  = max( dp[ i -1 ] [ j ] [ 0 ] , dp[ i - 1 ]  [ j ]  [ 1 ])

当 k = 1 时

dp[ i ] [ j ] = max ( dp [ i - 1 ] [ j - 1 ] [ 0 ] + a [ i ] , max( dp[ i ] [ j ] [ 1 ] , dp[ i - 1 ] [ j - 1 ] [ 0 ] ) + a[ i ] )

。。

因为 n m 到了 1e6 所以，滚动数组优化。。。。

 

 

 

 

以下是 AC 代码

 

 

 

 

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 1e6+5;
const int INF = 0x3f3f3f3f;
int dp[2][maxn][2];
int num[maxn];
int n,m;
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&num[i]);
        }
        for(int i=0;i<=m;i++)
        {
            dp[1][i][1] = -INF;
            dp[1][i][0] = -INF;
            dp[0][i][1] = -INF;
            dp[0][i][0] = -INF;
        }
        dp[0][0][0] = dp[0][0][1] = 0;
        for(int i=0,t=0;i<=n;i++,t=!t)
        {
            for(int j=0;j<=i&&j<=m;j++)
            {
                dp[t][j][0] = max(dp[!t][j][1], dp[!t][j][0]);
                if(j)
                {
                    dp[t][j][1] = max(dp[!t][j-1][0] + num[i], max(dp[!t][j][1], dp[!t][j-1][1]) + num[i]);
                }
            }
        }
        printf("%d\n",max(dp[n&1][m][1], dp[n&1][m][0]));
    }
    return 0;
}