4831: [Lydsy2017年4月月赛]序列操作

4831: [Lydsy2017年4月月赛]序列操作

Time Limit: 1 Sec Memory Limit: 128 MB
Submit: 77 Solved: 33
[Submit][Status][Discuss]
Description

给定一个长度为 n 的非负整数序列 a_1,a_2,…a_n 。你可以使用一种操作：选择在序列中连续的两个正整数，
并使它们分别减一。当你不能继续操作时游戏结束，而你的得分等于你使用的操作次数。你的任务是计算可能的最小
得分和最大得分。
Input

第一行包含一个正整数 T ，表示有 T 组数据，满足 T ≤ 200 。
接下来依次给出每组测试数据。对于每组测试数据：
第一行包含一个正整数 n ，满足 1 ≤ n ≤ 10^5 。
第二行包含 n 个非负整数，表示 a_1,a_2,…a_n ，满足 Σa_i ≤ 10^6 。
约 5 组数据满足 n ≥ 10^3 或 Σa_i ≥ 10^4 。
Output

对于每组测试数据
输出一行两个非负整数，用一个空格隔开，前者表示可能的最小得分，后者表示可能的最大得分。
Sample Input

2

4

1 2 1 3

5

1 2 1 1 3
Sample Output

2 2

2 3
HINT

Source

鸣谢Tangjz提供试题

[Submit][Status][Discuss]

注意到题目中的限制，每次操作是选择相邻的两个数，最后一定要到无法操作
那么终止状态里，任意相邻的两个数字，一定至少要有一个是 0
再有，序列里各个位置上的数字的和并不大，于是可以考虑用一个跟数字有关的 dp
定义状态 f[i][j] ，为第 i 个位置上的数字被消成了 j ，这个数字不要求被删成 0 ，需要的最多操作数
定义状态 F[i][j] ，为第 i 个位置上的数字被消成了 j ，这个数字一定要被删成 0 ，需要的最多操作数
方程就显然了， f[i][j]=max(f[i−1][ai−j],F[i−1][ai−j])+ai−j
因为第 i 个位置不要求被消完，说明位置 i−1 一定要被消成 0
特别地， f[i][0] 这个东西，可以用上一位剩余数字不小于 ai 的所有状态转移
然后对于 F 的转移，等于上一位不一定要删完，那么维护一个关于 f 的后缀 max 就行了
类似地定义 g[i][j] 和 G[i][j] 表示代价最小的时候，转移类似

#include
#include
#include
#define min(a,b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a) : (b))
using namespace std;

const int INF = ~0U>>1;
const int maxn = 1E6 + 10;

int T,n,A[maxn],f[2][maxn],g[2][maxn],F[2][maxn],G[2][maxn];

inline int getint()
{
    char ch = getchar(); int ret = 0;
    while (ch < '0' || '9' < ch) ch = getchar();
    while ('0' <= ch && ch <= '9')
        ret = ret * 10 + ch - '0',ch = getchar();
    return ret;
}

void Solve()
{
    int Max = 0,Min,pre = 0,cur = 1; n = getint();
    for (int i = 1; i <= n; i++)
        A[i] = getint(),Max = max(Max,A[i]);
    for (int i = 0; i <= Max; i++)
    {
        f[pre][i] = f[cur][i] = F[pre][i] = F[cur][i] = -INF;
        g[pre][i] = g[cur][i] = G[pre][i] = G[cur][i] = INF;
    }
    if (n == 1) {puts("0 0"); return;}
    int tmp = min(A[1],A[2]);
    for (int i = 0; i < tmp; i++)
        F[pre][A[2] - i] = G[pre][A[2] - i] = i;
    f[pre][A[2] - tmp] = g[pre][A[2] - tmp] = tmp;
    for (int i = 3; i <= n; i++,pre ^= 1,cur ^= 1)
    {
        for (int j = 1; j <= A[i]; j++)
        {
            if (f[pre][A[i] - j] != -INF)
                f[cur][j] = f[pre][A[i] - j] + A[i] - j;
            if (F[pre][A[i] - j] != -INF)
                f[cur][j] = max(f[cur][j],F[pre][A[i] - j] + A[i] - j);
            if (g[pre][A[i] - j] != INF)
                g[cur][j] = g[pre][A[i] - j] + A[i] - j;
            if (G[pre][A[i] - j] != INF)
                g[cur][j] = min(g[cur][j],G[pre][A[i] - j] + A[i] - j);
        }
        Max = F[pre][A[i]]; Min = G[pre][A[i]];
        for (int j = A[i]; j <= A[i - 1]; j++)
        {
            Max = max(Max,f[pre][j]);
            Min = min(Min,g[pre][j]);
        }
        if (Max != -INF) f[cur][0] = Max + A[i];
        if (Min != INF) g[cur][0] = Min + A[i];
        for (int j = A[i - 1] - 1; j >= 0; j--)
        {
            f[pre][j] = max(f[pre][j],f[pre][j + 1]);
            g[pre][j] = min(g[pre][j],g[pre][j + 1]);
        }
        for (int j = 1; j <= A[i]; j++)
        {
            if (f[pre][A[i] - j] != -INF)
                F[cur][j] = f[pre][A[i] - j] + A[i] - j;
            if (F[pre][A[i] - j] != -INF)
                F[cur][j] = max(F[cur][j],F[pre][A[i] - j] + A[i] - j);
            if (g[pre][A[i] - j] != INF)
                G[cur][j] = g[pre][A[i] - j] + A[i] - j;
            if (G[pre][A[i] - j] != INF)
                G[cur][j] = min(G[cur][j],G[pre][A[i] - j] + A[i] - j);
        }
        for (int j = 0; j <= A[i - 1]; j++)
        {
            f[pre][j] = F[pre][j] = -INF;
            g[pre][j] = G[pre][j] = INF;
        }
    }
    Max = -INF; Min = INF;
    for (int i = 0; i <= A[n]; i++)
        Max = max(Max,f[pre][i]),Min = min(Min,g[pre][i]);
    printf("%d %d\n",Min,Max);
}

int main()
{
    #ifdef DMC
        freopen("DMC.txt","r",stdin);
    #endif

    T = getint();
    while (T--) Solve();
    return 0;
}