@codeforces - 1209H@ Moving Walkways

Posted 2022-11-20 tiw-air-oao

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

机场中常常见到滑行道：假如一个滑行道的运行速度为 s，你的行走速度为 v，则你的真实速度为 s + v。

Limak 在数轴上走，想要从 0 走到 L。
数轴上有 n 个不相交的滑行道（但是可以端点重叠），第 i 个滑行道占用区间 [xi, yi]，且它的运行速度为 si。

Limak 想要恰当地分配他的能量：他的初始能量为 0，且在任意时刻必须为非负数。
每个时刻 Limak 都可以随意调整他的速度 v，但必须在 [0, 2] 中。
每单位时间内他将失去 v 的能量，但同时会恢复 1 的能量。即他将获得 (1-v) 的能量。

求到达 L 的最短时间。

Input
第一行两个整数 n, L (1≤n≤200000, 1≤L≤10^9)，含义如上。
接下来 n 行，每行包含整数 xi, yi 以及实数 si (0≤xi<yi≤L, 0.1≤si≤10.0)。
保证 y[i] <= x[i+1]，对于 1 <= i < n。
Output
输出一个实数，表示最短时间。

Examples
input
1 5
0 2 2.0
output
3.000000000000

input
1 5
2 4 0.91
output
3.808900523560

@solution@

一个敏锐的选手应该感觉得到，这个能量 e 的定义与位移 x 大同小异：
能量 e 定义每单位时间增加 (1-v)，位移 x 定义为每单位时间增加 v，则 e + x 每单位时间增加 1。
于是得到某段时间内 e + x = t，所以 v 这个量就没什么价值了。但是要保证 0 <= x <= 2*t（对应速度 v 的取值区间在 [0, 2] 中这一限制）。

将没有滑行道的地方看作运行速度为 0 的滑行道。
考虑某一个滑行道，其长度为 l，运行速度为 s。则令完全地通过这个滑行道耗费时间为 t，有 l = s*t + x = s*t + (t - e) = (s + 1)*t - e。
这样一来，对于某一个滑行道，实际上只有两个量是不确定的：时间 t 与对应时间内的能量变化量 e。

我们对于每个滑行道，建立以 e 为自变量，t 为因变量的函数关系，即：
\[t = \fracl + es + 1\]

尝试取出这个函数的定义域。根据 0 <= x <= 2*t 得到 0 <= t - e <= 2*t，再代入 t = (l + e) / (s + 1) 就可以得到 e 的范围（过程省略）：
\[-\fracls + 2\le e \le \fracls\]

需要注意 s 可以取 0，这时候 e 的上界为正无穷。

我们的问题转变为，求一个数列 e[1], e[2], ...，使得 ei 在一个给定的范围内，且这个数列的任意前缀和为非负整数（这个数列表示每一个滑行道的能量变化值），而 f1(e[1]) + f2(e[2]) + ... 最大。

观察上面我们的 e-t 函数，它是一次函数且单增，即 e 增大则 t 增大。
注意到这个问题其实很像括号匹配问题。假如 e[i] 减小，则必须要有一个 e[j]（j < i）要增大，且变化量相同。
如果 fi(e[i]) 的斜率 ≥ fj(e[j]) 的斜率，则这个方法是一定优秀的；否则是一定不优秀的。

于是我们就可以设计一个贪心算法：将所有函数按斜率从大到小排序，对于当前函数 fi，从 i 之前取走尽量多的能量贡献给 i。容易验证这个算法的正确性。
具体实现，可以先将 e[i] 设置为其上界，维护其前缀和。然后如果扫描到某个 e[x]，尝试将 e[x] 取到最小值，同时保证前缀和非负。
这个线段树随便搞搞。

因为 s = 0 时，e 无上界。代码实现时有些小 trick。
总时间复杂度为 O(nlogn)。

@accepted code@

#include<cstdio>
#include<algorithm>
using namespace std;
typedef double db;
const int MAXN = 200000;
const db EPS = 1E-7;
const db INF = 1E10;
struct segtree
    #define lch (x<<1)
    #define rch (x<<1|1)
    struct node
        int l, r;
        db tg, mn;
    t[8*MAXN + 5];
    void build(int x, int l, int r) 
        t[x].l = l, t[x].r = r, t[x].mn = 0;
        if( l == r ) return ;
        int mid = (l + r) >> 1;
        build(lch, l, mid), build(rch, mid + 1, r);
    
    void pushup(int x) 
        t[x].mn = min(t[lch].mn, t[rch].mn);
    
    void pushdown(int x) 
        if( t[x].tg ) 
            t[lch].tg += t[x].tg, t[rch].tg += t[x].tg;
            t[lch].mn += t[x].tg, t[rch].mn += t[x].tg;
            t[x].tg = 0;
        
    
    void modify(int x, int l, int r, db k) 
        if( l > t[x].r || r < t[x].l )
            return ;
        if( l <= t[x].l && t[x].r <= r ) 
            t[x].tg += k, t[x].mn += k;
            return ;
        
        pushdown(x);
        modify(lch, l, r, k);
        modify(rch, l, r, k);
        pushup(x);
    
    db query(int x, int l, int r) 
        if( l > t[x].r || r < t[x].l )
            return INF;
        if( l <= t[x].l && t[x].r <= r )
            return t[x].mn;
        pushdown(x);
        return min(query(lch, l, r), query(rch, l, r));
    
T;
struct node
    db v0, s; int id;
    friend bool operator < (node a, node b) 
        return a.v0 < b.v0;
    
a[2*MAXN + 5];
db e[2*MAXN + 5];
int n, L;
int main() 
    scanf("%d%d", &n, &L);
    int lst = 0, cnt = 0;
    for(int i=1;i<=n;i++) 
        int x, y; db s;
        scanf("%d%d%lf", &x, &y, &s);
        cnt++, a[cnt].id = cnt, a[cnt].v0 = 0, a[cnt].s = x - lst;
        lst = y;
        cnt++, a[cnt].id = cnt, a[cnt].v0 = s, a[cnt].s = y - x;
    
    cnt++, a[cnt].id = cnt, a[cnt].v0 = 0, a[cnt].s = L - lst;
    sort(a + 1, a + cnt + 1); T.build(1, 1, cnt);
    for(int i=1;i<=cnt;i++)
        if( a[i].v0 ) T.modify(1, a[i].id, cnt, e[i] = a[i].s/a[i].v0);
        else e[i] = 0;
    for(int i=1;i<=cnt;i++) 
//      printf("%lf %lf %lf\n", e[i], a[i].s, a[i].v0);
    
    for(int i=1;i<=cnt;i++) 
        db x = e[i] - (-a[i].s/(a[i].v0 + 2)), y = T.query(1, a[i].id, cnt), z = min(x, y);
//      printf("%d %lf %lf\n", i, x, y);
        T.modify(1, a[i].id, cnt, -z), e[i] -= z;
    
    db ans = 0;
    for(int i=1;i<=cnt;i++) 
        ans += (e[i] + a[i].s) / (a[i].v0 + 1);
//      printf("%d : %lf %lf %lf\n", a[i].id, e[i], a[i].s, a[i].v0);
    
    printf("%.10lf\n", ans);

@details@

虽然题目只给了 n 个滑行道，但滑行道之间那些“运行速度为 0 的滑行道”也有 n + 1 个，所以总共 2*n 个滑行道。因此线段树要开到 8*MAXN。
因为这种很 sb 的原因 RE 了一次。。。