UOJ187[UR#13]Ernd(斜率优化DP)_#187. 【ur #13】ernd-优快云博客

本文介绍了一种基于接水果游戏的算法挑战，该算法利用动态规划及优化技巧解决了一个有趣的游戏问题。文中详细阐述了从暴力DP到斜率优化的过程，并提供了完整的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#187. 【UR #13】Ernd

这里是跳蚤国中央广播电台，现在为您转播的是著名人类智慧大师 picks 博士与人工智能 betacome 之间的第二轮赛事。

这一场交锋的规则由网友 Po***QQ 提供，这位网友也将获得由不想跳的跳蚤不是好跳蚤——最强跳蚤跳跳跳公司提供的金牌跳蚤一只。

在刚刚结束的第一轮比赛中，因为 picks 博士在关键时刻出现了失误，他惜败给了 betacome。众所周知，A 先生在比赛前夕接受采访时，曾经说过相信 picks 博士可以以全胜的战绩战胜 betacome，请问 A 先生您现在怎么看？

“我仍然觉得 picks 博士的赢面要大一点，第一轮可能是因为他没有调整好心态，在比赛最后的水平堪比业余选手 m**o，这是非常反常的，如果他能够避免这样的失误的话，我觉得仍然觉得人类智慧可以取得最终的胜利。”

好，现在，我们可以看到，第二轮的比赛已经开始了，A 先生您能给我们简要介绍一下这一轮比赛的规则吗？

“好的，相信大家都玩过 osu 吧，这一场的规则来自 osu 的 ctb 模式。其实本来的规则是其他的模式，但是在 betacome 展示了它鬼畜的手速之后，经过比赛委员会的紧急讨论，决定把规则临时改成 ctb 模式。”

“简要来讲，你有一个盘子，时刻 $0$ 时你可以把盘子放到数轴上的任何一个整数坐标处，接着每一时刻你可以把盘子往左移动一个单位、往右移动一个单位或者不动。接着系统生成了 $n$ 个水果，第 $i$ 个水果会在第 $b_i$ 时刻出现在 $a_i$ 坐标处，保证 $b_i$ 单调递增。如果你的盘子在 $b_i$ 时刻恰好出现在 $a_i$ 处，那么就能接到这个水果。”

“最后一个水果落下后，游戏结束。分数用这个方式计算，定义变量 $K$ ，最开始 $K$ 是 $0$ ，按照顺序考虑每一个水果，如果你接到了当前水果，那么把 $K$ 加一，否则你的得分将加上 $K^2$ 并将 $K$ 清零，游戏结束后你的得分还会加上游戏结束时的 $K^2$ 。即你的得分是每一段连续接到水果的极长区间的长度平方和。”

好的，谢谢 A 先生，看来这场赛事的规则还是非常有趣的呀。现在我们节目组已经拿到了这场赛事中使用的水果信息（即数组 $a$ 与数组 $b$ ），A 先生您能帮我们计算双方可以拿到的最高分吗？

“当然，我们可以非常容易的算出来理论的最高分是****。” 出乎意料地，AcrossTheSky 居然一下子就说出了答案。

了解 AcrossTheSky 真实智力的你觉得这非常反常，你有理由怀疑 AcrossTheSky 是随便报了一个数字出来。所以你决定亲自计算一下答案，来检验一下 AcrossTheSky 是不是在瞎 BB。

输入格式

第一行一个正整数 $n$ ，表示水果的个数。

接下来 $n$ 行，第 $i$ 行包含两个空格分隔的正整数 $a_i,b_i$ ，表示第 $i$ 个水果会在第 $b_i$ 时刻出现在 $a_i$ 坐标处，保证 $b_i$ 单调递增。

输出格式

输出一行一个正整数，表示这场赛事中双方可以拿到的最高分。

样例一

input

output

explanation

接住第 $1,4,5$ 或者第 $2,4,5$ 个水果，得分为 $1^2+2^2=5$ 。

容易证明这是得分最高的方案。

样例二

input

output

explanation

一种得到最高分的方案是，接住第 $1,2,5,7,8,9$ 个果子，总得分为 $2^2+1^2+3^2=14$ 。

样例三

见样例数据下载。这个数据中 $n = 1000$ 。

限制与约定

由于一些原因，本题使用捆绑测试。每个子任务有若干个测试点，分为 $5$ 个子任务，你只有通过一个子任务的所有测试点才能得到这个子任务的分数。

子任务分值限制

n \leq 20

$n\leq20$

2	10	$n\leq1000$
3	20	$n\leq10^5$ ， $a_i\leq5$
4	20	$n\leq5\times10^5$ ，答案不超过 $10^4$
5	40	$n\leq5\times10^5$

对于所有数据， $1\leq n\leq5\times10^5$ ， $1\leq a_i,b_i\leq10^9$

时间限制： $2\texttt{s}$

空间限制： $128\texttt{MB}$

分析&&思路：

P.S. 这题看了看题解，发现其实挺巧妙的，只是自己想的时候没想到……（还是太菜了）
以下为UOJ原题题解：

算法二

对于subtask2， $n\leq1000$

我们定义“段”为满足对于其中任意相邻元素 $i$ 和 $i+1$ ，满足接到第 $i$ 个水果后可以接到第 $i+1$ 个水果的极长子区间。

考虑暴力dp，定义 $f_i$ 为以第 $i$ 个水果结尾的接水果序列的最大总得分，那么有：

$f_i=\max(f_i,f_j+1|\text{ 接到第 }j\text{ 个水果后可以接到第 }i\text{ 个水果})$

$f_i=\max(f_i,f_j-1+(i-j+1)^2|\text{ 第 }i\text{ 个水果和第 }j\text{ 个水果属于同一段})$

枚举 $j$ 进行转移，时间复杂度 $O(n^2)$ ，期望得分 $20$ 分。

算法三

我们考虑如何优化第一部分转移。

我们将水果都放在二维平面上，第 $i$ 个水果变成一个坐标为 $(a_i,b_i)$ 的点，那么容易发现，接到一个果子后，能接到的其他果子都在这个点的 $[45^\circ,135^\circ]$ 范围的方向上。

旋转坐标系，将每个点变为 $(b_i-a_i,b_i+a_i)$ ，那么接到一个果子后，能接到的其他果子都在这个点的右上方。

问题变成了一个二维偏序问题，用树状数组维护上升子序列即可。

观察subtask4， $n\leq5\times10^5$ ，答案不超过 $10^4$ ，这意味着任意一段的长度都不会超过 $\sqrt{10^4}=100$ 。

第一部分转移使用算法三，第二部分转移暴力，时间复杂度 $O(n\log n+100\times n)$ ，期望得分 $40$ 分。

算法四

现在开始考虑如何优化第二部分转移。

注意到一段内的元素在按照 $b_i-a_i$ 排序后可能不连续，但相对顺序不会改变，因此我们不用担心转移顺序的问题。

这部分转移每段之间彼此独立，因此我们考虑对于每段内部分别计算。

观察转移方程 $f_i=\max\{f_j-1+(i-j+1)^2\}$ ，设 $P=f_j-1+(i-j+1)^2$ ，那么有：

$(f_j+j^2-2j)=2i\times j+(P-i^2-2i)$

我们发现这个式子可以斜率优化，将每个决策点 $j$ 化为平面上的点 $(j,f_j+j^2-2j)$ ，维护一个上凸包即可。

注意到我们维护的是上凸包而查询斜率 $2i$ 随 $i$ 单调递增，因此我们需要用一个栈而不是队列来维护这个凸包。

当然你要二分斜率也是完全可以的。

时间复杂度 $O(n\log n)$ ，期望可以通过全部测试点拿到 $100$ 分。

当时想这题的时候已经想到了用DP来求解，但是一直没有想到怎么来进行优化..可能看到这种题的思路还是不够清晰吧..以后还要再多加练习。

Code

#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
bool Finish_read;
template<class T>inline void read(T &x){Finish_read=0;x=0;int f=1;char ch=getchar();while(!isdigit(ch)){if(ch=='-')f=-1;if(ch==EOF)return;ch=getchar();}while(isdigit(ch))x=x*10+ch-'0',ch=getchar();x*=f;Finish_read=1;}
template<class T>inline void print(T x){if(x/10!=0)print(x/10);putchar(x%10+'0');}
template<class T>inline void writeln(T x){if(x<0)putchar('-');x=abs(x);print(x);putchar('\n');}
template<class T>inline void write(T x){if(x<0)putchar('-');x=abs(x);print(x);}
/*================Header Template==============*/
const int maxn=500005;
int n,m,pre[maxn],y[maxn];
ll c[maxn],f[maxn],ans;
bool can[maxn];
struct node {
    int x,y,id;
    node(int _x=0,int _y=0,int _id=0):x(_x),y(_y),id(_id){}
    inline bool operator < (const node &rhs) const {
        return x==rhs.x?y<rhs.y:x<rhs.x;
    }
}p[maxn];
inline ll lb(ll x) {
    return x&-x;
}
inline void add(int pos,ll d) {
    for(;pos<=m;pos+=lb(pos))
        c[pos]=max(c[pos],d);
}
inline ll query(int pos) {
    ll res=0;
    for(;pos;pos-=lb(pos))
        res=max(res,c[pos]);
    return res;
}
int main() {
    read(n);
    for(int i=1,u,v;i<=n;i++) {
        read(u),read(v);
        p[i]=node(v-u,v+u,i);
        y[i]=p[i].y;
        if(i>1&&p[i].x>=p[i-1].x&&p[i].y>=p[i-1].y)
            can[i]=1;
    }
    sort(y+1,y+n+1);
    m=unique(y+1,y+n+1)-y-1;
    for(int i=1;i<=n;i++)
        p[i].y=lower_bound(y+1,y+m+1,p[i].y)-y;
    sort(p+1,p+n+1);
    for(int i=1;i<=n;i++) {
        ll now=p[i].id,res=query(p[i].y);
        f[now]=res+(now-1)*(now-1);
        res++;
        if(can[now]) {
            int j=now-1;
            while(pre[j]&&f[j]-f[pre[j]]<=2*now*(j-pre[j]))
                j=pre[j];
            res=max(res,f[j]-2*now*(j-1)+now*now);
            while(pre[j]&&(now-j)*(f[j]-f[pre[j]])<=(j-pre[j])*(f[now]-f[j]))
                j=pre[j];
            pre[now]=j;
        }
        add(p[i].y,res);
        ans=max(ans,res);
    }
    printf("%lld\n",ans);
    return 0;
}