2018 ICPC North American Qualifier Contest Longest Life（斜率DP）

去年参加ACM北美赛区资格赛的时候遇到的题目，今天偶然翻来做一做。

题意

正常情况下每分钟你的生命就会流失一分钟，但是在一些时间点上你可以获得一些（$N\le 10^5$）改变生命流失速度的机会，但是如果你改变了生命流失速率，那么你就会瞬间流失 $C$ 分钟的生命，问你最晚的死亡时间是什么时候。

解题思路

如果用动态规划的方式去求解，那么可以很容易得到一个DP方程，如果我们设 $f_i=$ 以第$i$个药片作为最后使用的药片的最晚死亡时间。那么转移方程就应该是： f i = max ⁡ { g ( i , k ) }   ( 0 ≤ k &lt; i ) f_i = \max \{g(i, k)\} \ (0 \leq k &lt; i) fi​=max{g(i,k)} (0≤k<i)。

$g(i,k)$就表示之前使用了第$k$个药片，换成第$i$个药片以后所能存活的最长时间。如果我们把整个过程看做一个线性函数斜率不断改变的过程，那么$y$坐标就是不做改变应该存活的时间，而$x$轴就代表实际存活的时间。假设一开始死亡时间为$T$，药片出现时间为$t_i$，改变的斜率为$k_i$，那么 $g(i,k)=t_i+\frac{T-使用i时的高度}{k_i}$。合并到DP方程展开后就是：
$$f_i=\max (t_i+\frac{T-(k_j{t}_j+T-k_j{f}_j+k_j(t_i-t_j)+C)}{k_i})$$
化简一下
$$f_i=\max (t_i-\frac{C+k_j(t_i-f_j)}{k_i})$$
其中$1\le k<i$。

但是观察一下数据范围，$10^5$ 显然对于这个$O(N^2)$ 的DP来说太大了，但是我们观察到$t_i$是单调上升的，而且对于进来的不同$k_i$，有一部分斜率比之前最小值要大的显然不能构成最优解，也就是说，这里面$j$的选择是可以优化的。那么如果想让程序不超时，我们需要一个$O(1)$的最优解选择方法，那么就要想到斜率DP。

我们继续优化这个式子，假设现在有两个药片$s,j$且$s<j<i$。那么假设$j$是比$s$更优的选择，那么一定满足：
$$t_i-\frac{C+k_s(t_i-f_s)}{k_i}<t_i-\frac{C+k_j(t_i-f_j)}{k_i}$$
两边相同部分删去，由于本题保证斜率不为负数，所以符号不变
$$\begin{gathered} \frac{C+k_s(t_i-f_s)}{k_i}<-\frac{C+k_j(t_i-f_j)}{k_i} \\ {k}_s{t}_i-k_s{f}_s>k_j{t}_i-k_j{f}_j \end{gathered}$$
因为前面斜率一定比后面的大，所以
$$(k_s-k_j)t_i>k_s{f}_s-k_j{f}_j$$
最终我们得到了$t_i>\frac{k_s{f}_s-k_j{f}_j}{k_s-k_j}$，当这个条件满足的时候，我们知道选择第$j$个药片比第$s$个药片要优。
如果我们定义$slope(s,j)=\frac{k_s{f}_s-k_j{f}_j}{k_s-k_j}$也就是相当于点$s$到点$j$的斜率，那我们需要判断满足这个条件的点具有的特征。假设对于三个点$s<j<i$并且$slope(s,j)>slope(j,i)$，那么我们可以判断点$j$一定不会形成最优解。

证明也很简单，假设$t_i>slope(s,j)>slope(j,i)$，那么最优解一定会是$i$而不是$j$，根据我们之前的定义。反过来如果$t_i\le slope(s,j)$，那么$s$才是最优解，所以无论哪种情况上凸起的$j$都不会形成最优解，因此利用单调队列维护一个下凸包就可以了。

剩下的就是用单调队列维护下凸包的操作了，只要队首的元素$slope(l,l+1)$得出最优解不是$l$，那么$l$位置就可以出列了，否则队首就是最优解。计算完$f_i$以后插入队尾也是一样，$slope(r-1,r)$得出$r$不是最优解就要出列。注意一定要排除$i$号药片斜率比$i$之前的最小值要大的情况，因为这种情况会干扰单调性导致算法不正确。

时间复杂度

$O(N)$

代码

我用了一个优先队列来储存最小值，其实没必要

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>

typedef long long ll;
using namespace std;
const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const ll INF64 = 1e18;
const double INFD = 1e30;
const double EPS = 1e-6;
const double PI = 3.14159265;
const ll MOD = 1e9 + 7;

const int MAXN = 100005;

ll n, m, k;
int CASE = 1;

// 这里我用了long double来防止精度不够
typedef long double LD;

struct Pill {
    ll t;
    LD ks;
    Pill() {}
    Pill(ll t, ll x, ll y) : t(t), ks(y / (LD)x) {}
    bool operator<(const Pill& b) const { return t < b.t; }
};

vector<Pill> pills;
LD dp[MAXN];
// 模拟了一个队列
int QQ[MAXN * 2];

// 斜率计算
LD slope(int s, int j) {
    return (pills[j].ks * dp[j] - pills[s].ks * dp[s]) /
           (pills[j].ks - pills[s].ks);
}

int main() {
#ifdef LOCALLL
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif
    scanf("%lld%lld%lld", &n, &m, &k);
    for (int i = 0; i < m; i++) {
        ll t, x, y;
        scanf("%lld%lld%lld", &t, &x, &y);
        pills.emplace_back(t, x, y);
    }
    pills.emplace_back(0, 1, 1);
    sort(pills.begin(), pills.end());
    dp[0] = n;
    QQ[1] = 0;
    int l = 1, r = 1;
    priority_queue<LD, vector<LD>, greater<LD>> PQ;
    PQ.push(1);
    for (int i = 1; i <= m; i++) {
        if (pills[i].ks >= PQ.top()) continue;
        while (l < r && slope(QQ[l], QQ[l + 1]) <= pills[i].t) ++l;
        int opt = QQ[l];
        LD ki = pills[i].ks;
        LD kj = pills[opt].ks;

        // 根据公式从dp[j]计算dp[i]
        LD newx = (LD)pills[i].t - (k + kj * (pills[i].t - dp[opt])) / ki;
        dp[i] = max(dp[i], newx);
        while (l < r && slope(QQ[r - 1], QQ[r]) >= slope(QQ[r], i)) r--;
        QQ[++r] = i;
        PQ.push(pills[i].ks);
    }
    LD ans = 0;
    for (int i = 0; i <= m; i++) {
        ans = max(ans, dp[i]);
    }
    printf("%.7Lf", ans);
    return 0;
}