LG3648 [APIO2014]序列分割

题意

你正在玩一个关于长度为 \(n\) 的非负整数序列的游戏。这个游戏中你需要把序列分成 \(k+1\) 个非空的块。为了得到 \(k+1\) 块，你需要重复下面的操作 \(k\) 次：

选择一个有超过一个元素的块（初始时你只有一块，即整个序列）

选择两个相邻元素把这个块从中间分开，得到两个非空的块。

每次操作后你将获得那两个新产生的块的元素和的乘积的分数。你想要最大化最后的总得分。

\(2≤n≤100000,1≤k≤\min\{n−1,200\}\)

分析

参照Tunix的题解。

首先我们根据这个分割的过程可以发现：总得分等于k+1段两两的乘积的和（乘法分配律），也就是说与分割顺序是无关的。

再对乘积进行重分组（还是乘法分配律）我们可以转化为：ans=∑第 i 段×前 i-1 段的和

所以我们就可以以分割次数为阶段进行DP啦～

令\(f[i][j]\)表示将前 \(j\) 个数分成 \(i\) 段的最大得分，那么就有
\[
f[i][j]=\max\{f[i−1][k]+s[k]×(s[j]−s[k])\}
\]
这里我前些时候一直规范要求的作用就体现出来了。

令\(x>y\)，且\(x\)比\(y\)优，则
\[
f[i-1][x]-s[x]^2+s[x]s[j]>f[i-1][y]-s[y]^2+s[y]s[j]
\]
这里就不能乱移项，必须保证除式中的\(\varphi(x)-\varphi(y)\)值是正的才谈得上平面中的点。必须把\(s[j]\)的系数调整成\(s[x]-s[y]\)。
\[
\frac{s[x]^2-f[i-1][x]-s[y]^2+f[i-1][y]}{s[x]-s[y]}<s[j]
\]
这才是正确的斜率式，跟前面的\(f[i-1][x]-s[x]^2\)是反的。

还是多次的斜率优化，洛谷上还要输出方案数，这也比较简单，每次转移的时候记一个\(g\)数组记录就行了。

时间复杂度\(O(kn)\)。

代码

首先是BZOJ同名题，卡空间需要滚动数组的。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<ctime>
#include<cstring>
#define rg register
#define il inline
#define co const
template<class T>il T read()
{
    rg T data=0;
    rg int w=1;
    rg char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        data=data*10+ch-'0';
        ch=getchar();
    }
    return data*w;
}
template<class T>T read(T&x)
{
    return x=read<T>();
}
using namespace std;
typedef long long ll;

co int K=201,N=1e5+1;
ll s[N];
ll f[2][N]; // edit 1: MLE

ll Up(int i,int x,int y)
{
    return s[x]*s[x]-f[i^1][x]-s[y]*s[y]+f[i^1][y];
}

ll Down(int x,int y)
{
    return s[x]-s[y];
}

ll Cal(int i,int j,int k)
{
    return f[i^1][k]+s[k]*(s[j]-s[k]);
}

int q[N];

int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
//  cerr<<"sizef="<<(sizeof(f)+sizeof(s)+sizeof(q))/1024.0/1024<<endl;
    int n=read<int>(),k=read<int>();
    for(int i=1;i<=n;++i)
        s[i]=s[i-1]+read<int>();
    for(int i=1;i<=k;++i)
    {
        int head=0,tail=0;
        q[tail++]=0;
        for(int j=1;j<=n;++j)
        {
            while(head+1<tail&&Up(i&1,q[head+1],q[head])<=s[j]*Down(q[head+1],q[head]))
                ++head;
            f[i&1][j]=Cal(i&1,j,q[head]);
            while(head+1<tail&&Up(i&1,j,q[tail-1])*Down(q[tail-1],q[tail-2])<=Up(i&1,q[tail-1],q[tail-2])*Down(j,q[tail-1]))
                --tail;
            q[tail++]=j;
        }
    }
    printf("%lld\n",f[k&1][n]);
    return 0;
}

然后是洛谷上需要输出方案，但不卡空间的。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<ctime>
#include<cstring>
#define rg register
#define il inline
#define co const
template<class T>il T read()
{
    rg T data=0;
    rg int w=1;
    rg char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        data=data*10+ch-'0';
        ch=getchar();
    }
    return data*w;
}
template<class T>T read(T&x)
{
    return x=read<T>();
}
using namespace std;
typedef long long ll;

co int K=201,N=1e5+1;
ll s[N];
ll f[K][N];
int g[K][N];

ll Up(int i,int x,int y)
{
    return s[x]*s[x]-f[i-1][x]-s[y]*s[y]+f[i-1][y];
}

ll Down(int x,int y)
{
    return s[x]-s[y];
}

ll Cal(int i,int j,int k)
{
    return f[i-1][k]+s[k]*(s[j]-s[k]);
}

int q[N];

int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
//  cerr<<"sizef="<<(sizeof(f)+sizeof(s)+sizeof(q))/1024.0/1024<<endl;
    int n=read<int>(),k=read<int>();
    for(int i=1;i<=n;++i)
        s[i]=s[i-1]+read<int>();
    for(int i=1;i<=k;++i)
    {
        int head=0,tail=0;
        q[tail++]=0;
        for(int j=1;j<=n;++j)
        {
            while(head+1<tail&&Up(i,q[head+1],q[head])<=s[j]*Down(q[head+1],q[head]))
                ++head;
            f[i][j]=Cal(i,j,q[head]);
            g[i][j]=q[head];
            while(head+1<tail&&Up(i,j,q[tail-1])*Down(q[tail-1],q[tail-2])<=Up(i,q[tail-1],q[tail-2])*Down(j,q[tail-1]))
                --tail;
            q[tail++]=j;
        }
    }
    printf("%lld\n",f[k][n]);
    stack<int>sol;
    for(int i=k,j=n;i>=1;--i)
    {
        j=g[i][j];
        sol.push(j);
    }
    while(sol.size())
    {
        printf("%d ",sol.top());
        sol.pop();
    }
    return 0;
}

个人比较喜欢洛谷上的题。卡空间算一种恶心的卡常，况且写起来还那么丑。