BZOJ3675[APIO2014] 序列分割

最新推荐文章于 2024-10-21 13:17:09 发布

原创最新推荐文章于 2024-10-21 13:17:09 发布 · 244 阅读

1 ·

CC 4.0 BY-SA版权

动态规划同时被 2 个专栏收录

100 篇文章

订阅专栏

斜率优化

8 篇文章

订阅专栏

本文介绍了一种通过动态规划解决序列分割问题的方法，旨在通过合理分割序列获得最大得分。文章详细解析了问题背景、输入输出格式及样例，并给出了具体的算法实现思路与代码。

原题链接：http://www.lydsy.com/JudgeOnline/problem.php?id=3675

序列分割

Description

小H最近迷上了一个分隔序列的游戏。在这个游戏里，小H需要将一个长度为n的非负整数序列分割成k+1个非空的子序列。为了得到k+1个子序列，小H需要重复k次以下的步骤：
1.小H首先选择一个长度超过1的序列（一开始小H只有一个长度为n的序列——也就是一开始得到的整个序列）；
2.选择一个位置，并通过这个位置将这个序列分割成连续的两个非空的新序列。
每次进行上述步骤之后，小H将会得到一定的分数。这个分数为两个新序列中元素和的乘积。小H希望选择一种最佳的分割方式，使得k轮之后，小H的总得分最大。

Input

输入第一行包含两个整数n，k（k+1≤n）。

第二行包含n个非负整数a1，a2，…，an（0≤ai≤10^4），表示一开始小H得到的序列。

Output

输出第一行包含一个整数，为小H可以得到的最大分数。

Sample Input

7 3
4 1 3 4 0 2 3

Sample Output

108

HINT

【样例说明】

在样例中，小H可以通过如下3轮操作得到108分：

1．-开始小H有一个序列(4，1，3，4，0，2，3)。小H选择在第1个数之后的位置

将序列分成两部分，并得到4×(1+3+4+0+2+3)=52分。

2．这一轮开始时小H有两个序列：(4)，(1，3，4，0，2，3)。小H选择在第3个数

字之后的位置将第二个序列分成两部分，并得到(1+3)×(4+0+2+

3)=36分。

3．这一轮开始时小H有三个序列：(4)，(1，3)，(4，0，2，3)。小H选择在第5个

数字之后的位置将第三个序列分成两部分，并得到(4+0)×(2+3)=

20分。

经过上述三轮操作，小H将会得到四个子序列：(4)，(1，3)，(4，0)，(2，3)并总共得到52+36+20=108分。

【数据规模与评分】

：数据满足2≤n≤100000,1≤k≤min(n -1，200)。

题解

首先，这个分割的先后顺序和最终结果没有任何关系，假设我们把这个序列分成3块，每个块内元素之和分别为 $x_1,x_2,x_3$ ，那么两种切割方案的结果分别为：

x1(x2+x3)+x2x3=x1x2+x1x3+x2x3 x 1 ( x 2 + x 3 ) + x 2 x 3 = x 1 x 2 + x 1 x 3 + x 2 x 3 $x_1(x_2+x_3)+x_2x_3=x_1x_2+x_1x_3+x_2x_3$

(x1+x2)x3+x1x2=x1x3+x2x3+x1x2 ( x 1 + x 2 ) x 3 + x 1 x 2 = x 1 x 3 + x 2 x 3 + x 1 x 2 $(x_1+x_2)x_3+x_1x_2=x_1x_3+x_2x_3+x_1x_2$

显然，这两个结果相等，我们再推广一下（推广过程略），可得分割的顺序和最终结果无关。

那么我们考虑用 $dp[i][j]$ 表示前 $i$ 个元素切 $j$ 刀的最优解，这样我们就有一个朴素的转移方程：

d p [i] [j] = m a x (d p [k] [j - 1] + s u m [k] \times (s u m [i] - s u m [k]))

$dp[i][j]=max(dp[k][j-1]+sum[k]\times (sum[i]-sum[k]))$
至于为什么贡献是这个，我们可以想成这一刀是第一刀，前面dp出来的是后面切的。

接着我们就可以发现上面的朴素转移时间和空间都炸了。。。

因为转移时第二维只用到了 $j-1$ ，我们就可以考虑用滚动数组滚掉第二维，再考虑斜率优化（为简化表达我们去掉第二维）：

dp[k]+sum[k](sum[i]−sum[k])>dp[j]+sum[j](sum[i]−sum[j]) d p [ k ] + s u m [ k ] ( s u m [ i ] − s u m [ k ] ) > d p [ j ] + s u m [ j ] ( s u m [ i ] − s u m [ j ] ) $dp[k]+sum[k] (sum[i]-sum[k])>dp[j]+sum[j] (sum[i]-sum[j])$

dp[k]−dp[j]>sum[j]sum[i]−sum2[j]−sum[k]sum[i]+sum2[k] d p [ k ] − d p [ j ] > s u m [ j ] s u m [ i ] − s u m 2 [ j ] − s u m [ k ] s u m [ i ] + s u m 2 [ k ] $dp[k]-dp[j]>sum[j]sum[i]-sum^2[j]-sum[k]sum[i]+sum^2[k]$

dp[k]−dp[j]+sum2[j]−sum2[k]sum[j]−sum[k]>sum[i] d p [ k ] − d p [ j ] + s u m 2 [ j ] − s u m 2 [ k ] s u m [ j ] − s u m [ k ] > s u m [ i ] $\frac{dp[k]-dp[j]+sum^2[j]-sum^2[k]}{sum[j]-sum[k]}>sum[i]$

我们发现 $sum[i]$ 单增，妙~~~

代码

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int M=1e5+5;
int n,k,p,que[M];
ll dp[2][M],sum[M];
void in()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;++i)
    scanf("%d",&sum[i]),sum[i]+=sum[i-1];
}
double slop(int a,int b)
{
    if(sum[a]==sum[b])return -1e18;
    return 1.0*(dp[!p][a]-dp[!p][b]+sum[b]*sum[b]-sum[a]*sum[a])/(sum[b]-sum[a]);
}
void ac()
{
    int le,ri,ss;
    for(int u=1;u<=k;++u)
    {
        le=ri=0;p=u&1;
        for(int i=1;i<=n;++i)
        {
            while(le<ri&&slop(que[le],que[le+1])<sum[i])le++;
            ss=que[le];
            dp[p][i]=dp[!p][ss]+sum[ss]*(sum[i]-sum[ss]);
            while(le<ri&&slop(que[ri],i)<slop(que[ri-1],que[ri]))ri--;
            que[++ri]=i;
        }
    }
    printf("%lld\n",dp[k&1][n]);
}
int main()
{
    in();ac();
    return 0;
}

洛谷上还要记路径：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int M=1e5+5;
int n,k,p,to[205][M],que[M];
ll dp[2][M],sum[M];
void in()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;++i)
    scanf("%d",&sum[i]),sum[i]+=sum[i-1];
}
double slop(int a,int b)
{
    if(sum[a]==sum[b])return -1e18;
    return 1.0*(dp[!p][a]-dp[!p][b]+sum[b]*sum[b]-sum[a]*sum[a])/(sum[b]-sum[a]);
}
void ac()
{
    int le,ri,ss;
    for(int u=1;u<=k;++u)
    {
        le=ri=0;p=u&1;
        for(int i=1;i<=n;++i)
        {
            while(le<ri&&slop(que[le],que[le+1])<sum[i])le++;
            ss=que[le];
            dp[p][i]=dp[!p][ss]+sum[ss]*(sum[i]-sum[ss]);
            to[u][i]=ss;
            while(le<ri&&slop(que[ri],i)<slop(que[ri-1],que[ri]))ri--;
            que[++ri]=i;
        }
    }
    printf("%lld\n",dp[k&1][n]);
    int u=n;
    for(int i=k;i>=1;--i)
    {
        u=to[i][u];
        printf("%d ",u);
    }
}
int main()
{
    in();ac();
    return 0;
}