CodeForces - 372C Watching Fireworks is Fun 单调队列优化DP

---

题意

在${\color{red} n}$个点的街道上，将有${\color{red} m}$个烟花要放。每个烟花拥有三个参数${\color{red} {a,b,t}}$。${\color{red} t}$表示该烟花在t时刻放。
假设现在时间正好为${\color{red} t}$时刻，一个人站在${\color{red} x}$点位置则他获得的开心值为${\color{red} {b_{i}-\begin{vmatrix}a_{i}-x\end{vmatrix}}}$
$现在有一个人起始可以站在任意地方，他每单位时间可以移动{\color{red} d}。 询问最后他看完所有烟花最多能得到多少开心值。$
$n,m,d ( 1\leq n \leq 150000;1\leq m \leq 300;1\leq d \leq n)$
$a_{i},b_{i},t_{i} (1\leq a_{i}\leq n;1\leq b_{i}\leq 10^{9};1\leq t_{i}\leq 10^{9})$
$t_{i} \leq t_{i+1}$

---

题解

${\color{red} {Step 1}}$
$dp[i][j] 表示说前看了前i个烟花走到j位置时获得的最多快乐值 (1 \leq i \leq m;1 \leq j \leq n)$
$那么考虑上一个烟花在k位置的他获得的最大值，即dp[i-1][k]。于是状态可以如下转移$
$dp[i][j] = max(dp[i][j],dp[i-1][k] + b[i] - \begin{vmatrix}a[i]-x\end{vmatrix})$
$当然需要注意k的范围 j-d*(t_{i}-t_{i-1}) \leq k \leq j + d*(t_{i}-t_{i-1})$
可以写出这样的代码

ll dp[330][150010];
for(int i=1;i<=m;i++) {
    int t = fire[i].t - fire[i-1].t;
    for(int j=1;j<=n;j++) {
        dp[i][j] = -inf;
        for(int k=max(1,j-t*d);k<=min(n,j+t*d);k++) {
            dp[i][j] = max(dp[i][j],dp[i-1][k] + fire[i].b - abs(fire[i].a-j));
        }
    }
}

不幸的是内存超了。

${\color{red} {Step 2}}$
发现$dp[i][j] 只和dp[i-1][k] 有关系利用滚动数组优化即可$
写出如下代码

for(int i=1;i<=m;i++) {
    int t = fire[i].t - fire[i-1].t;
    for(int j=1;j<=n;j++) {
        dp[i&1][j] = -inf;
        for(int k=max(1,j-t*d);k<=min(n,j+t*d);k++) {
        dp[i&1][j] = max(dp[i&1][j],dp[!(i&1)][k] + fire[i].b - abs(fire[i].a-j));
        }
    }
}

内存是优化了不少，时间上却超时了。

${\color{red} {Step 3}}$
$dp[i][j] = max(dp[i][j],dp[i-1][k] + b[i] - \begin{vmatrix}a[i]-x\end{vmatrix})$
$j-d*(t_{i}-t_{i-1}) \leq k \leq j + d*(t_{i}-t_{i-1})$
我们注意到上式是一个区间最值问题，且满足划窗性，于是考虑单调队列优化。
$dp[i][j] = max(dp[i-1][k]) + b[i] - \begin{vmatrix}a[i]-x\end{vmatrix}$
单调队列维护$dp[i-1][k]$的最大值即可。

---

最终版本代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,ll> node;
const int maxn = 330;
const ll inf = 1LL<<62;
int n,m;
ll d;
struct Fire {
    int a;
    ll b,t;
    bool operator < (const Fire &a) const {
        return t < a.t;
    }
};
node qu[450010];
Fire fire[maxn];
ll dp[2][150010];
int main()
{
    while(~scanf("%d%d%lld",&n,&m,&d)) {
        fire[0].t = 0;
        for(int i=1;i<=m;i++) scanf("%d%lld%lld",&fire[i].a,&fire[i].b,&fire[i].t);
        sort(fire+1,fire+1+m);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=m;i++) {
            ll t = fire[i].t - fire[i-1].t;
            int l = 1,r = 0;
            for(int j=1;j<=n;j++) {
                dp[i&1][j] = -inf;
                /// 维护一个单调递减的队列
                while(l <= r && qu[r].second < dp[!(i&1)][j]) r--;
                qu[++r] = make_pair(j,dp[!(i&1)][j]);
                if(j > t*d) {
                    int pos = j - t*d;
                    /// 排除位置不满足的最大值
                    while(l <= r && qu[l].first + d*t < pos) l++;
                    if(l <= r) dp[i&1][pos] = max(dp[i&1][pos],qu[l].second + fire[i].b - abs(fire[i].a-pos));
                }
            }
            /// 有些位置还没有更新到
            for(int j=max(1ll*n-t*d+1,1ll);j<=n;j++) {
                while(l <= r && qu[l].first + d*t < j) l++;
                if(l <= r) dp[i&1][j] = max(dp[i&1][j],qu[l].second + fire[i].b - abs(fire[i].a-j));
            }
        }
        ll res = -inf;
        for(int i=1;i<=n;i++) res = max(res,dp[m&1][i]);
        printf("%lld\n",res);
    }
}