CodeForces - 372C Watching Fireworks is Fun dp

最新推荐文章于 2023-02-14 19:48:19 发布

jerans

最新推荐文章于 2023-02-14 19:48:19 发布

阅读量434

点赞数

分类专栏： ----- D P ------ Codefoces

本文链接：https://blog.csdn.net/jerans/article/details/78207749

版权

Codefoces 同时被 2 个专栏收录

59 篇文章

订阅专栏

----- D P ------

37 篇文章

订阅专栏

本文解析 CodeForces 372C 题目，介绍如何利用动态规划和单调队列优化算法解决该问题。通过对题目背景的描述，给出了具体的动态规划状态定义、转移方程，并详细解释了使用单调队列进行优化的方法。

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

http://codeforces.com/problemset/problem/372/C

题意：在一条街道上（线段），有m个烟花，给出每个烟花的位置和燃放的时间，以及一个b【i】值，当烟花燃放时，你在街道的x（1=<x<=n)位置上获得的乐趣值为

b【i】-abs（a【i】-x），刚开始你可以在任意位置，之后可以移动你的位置，每秒可移动d个单位，求所有烟花燃放完之后的乐趣值最大值

dp【i】【j】表示看完前i个烟花且最后位置在j上的最大乐趣值

转移方程很简单：

dp【i】【j】=max（dp【i-1】【k】）+b【i】-abs（a【i】-x）（j - d * (t [i] - t [i-1]) =< k <= j + d * (t [i] - t [i-1]) )

朴素方法必然会T，需要单调队列优化，维护一个递减的单调队列，每次通过下标从队首维护使得队内元素的原序列下标满足区间左边界条件，接不断着把满足右边界条件的元素入队，且入队时维护单调递减的性质，这样队首元素保存的就是某个范围内的最大值了

#include<bits/stdc++.h>
using namespace std;
const int maxn=305;
long long a[maxn],b[maxn],t[maxn];
long long dp[2][155000];
const long long inf=0x3f3f3f3f3f3f3f3f;
struct node
{
    int index;
    long long x;
}que[255000];
inline long long abss(long long x)
{
    return x<0?-x:x;
}
long long f(int i,int j)
{
    return b[i]-abss(a[i]-j);
}
int main()
{
    int n,m,d,i,j;
    while(cin>>n>>m>>d)
    {
        for(i=1;i<=m;i++)
            scanf("%lld %lld %lld",&a[i],&b[i],&t[i]);
        memset(dp,-inf,sizeof(dp));
        int noww=1,pree=0;
        for(i=1;i<=n;i++)
            dp[1][i]=f(1,i);
        for(i=2;i<=m;i++)
        {
            swap(noww,pree);
            long long le,ri,now=(t[i]-t[i-1])*d;
            int index=1,head=1,tail=1;
            for(j=1;j<=n;j++)
            {
                le=max(1ll,j-now),ri=min(j+now,n*1ll);
                while(que[head].index<le&&head<tail)
                    head++;
                while(index<=ri)
                {
                    node temp;
                    temp.index=index;
                    temp.x=dp[pree][index];
                    while(que[tail-1].x<=temp.x&&tail>head)
                        tail--;
                    que[tail++]=temp;
                    index++;
                }
                dp[noww][j]=que[head].x+f(i,j);
            }
        }
        long long ans=-inf;
        for(i=0;i<=n;i++)
            ans=max(ans,dp[noww][i]);
        cout<<ans<<endl;
    }
    return 0;
}

b【i】-abs（a【i】-x）