@CSP模拟2019.10.16 - T3@ 垃圾分类

Posted 2021-03-25 tiw-air-oao

目录

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

---

@description@

为了保护环境，p6pou建设了一个垃圾分类器。

垃圾分类器是一个树形结构，由 n 个垃圾桶和 n-1 条双向传送带组成。
垃圾处理器的编号为 1, 2, ..., n，每条传送带都可以花 1 秒钟将垃圾从一个垃圾桶输送到另一个垃圾桶。
垃圾投放点是编号为 r 的垃圾桶，垃圾总是投放在这里。

垃圾共有 n 种，编号也是 1, 2, ..., n。
编号为 i 的垃圾会被输送到编号为 i 的垃圾桶里面，垃圾总是自动沿着最短路线输送，到达编号为 i 的垃圾桶后需要 ai 秒才能被垃圾桶处理完成。

为了避免不同垃圾混在一起，p6pou将垃圾按照编号从小到大的顺序依次投入编号为 r 的垃圾桶，每投放一种垃圾之后，必须等到这种垃圾被输送到其他垃圾桶，或者被编号为 r 的垃圾桶处理完成，才能继续投放下一种垃圾。
传送带输送垃圾也一样，如果要将垃圾从编号为 x 的垃圾桶中的垃圾传输到编号为 y 的垃圾桶，如果此时编号为 y 的垃圾桶中有另一种垃圾，必须等到另一种垃圾被传输走或者被处理完成后才能传输。

现在p6pou想知道，开始投放垃圾到垃圾分类器处理完所有所有垃圾，总共需要花费多长时间。

输入格式
第一行两个整数 n, r，垃圾种类和垃圾桶数量都是 n，垃圾投放点是编号为 r 的垃圾桶。
第二行 n 个整数 a1, a2, ..., an，表示第 i 个垃圾桶处理第 i 种垃圾的时间。
接下来 n - 1 行每行两个数 x, y，表示有一条双向传送带连接编号为 x, y 的两个垃圾桶。

输出格式
输出一个整数，表示从开始投放垃圾到处理完所有垃圾的总时间。

输入输出样例1
样例输入
3 2
5 2 5
1 2
1 3
样例输出
14
样例说明
开始投放 2 秒后，1 号垃圾到达 1 号垃圾桶，2 号垃圾到达 2 号垃圾桶，3 号垃圾还没投放；
开始投放 4 秒后，2 号垃圾处理完成；
开始投放 5 秒后，3 号垃圾到达 2 号垃圾桶，此时 1 号垃圾桶仍在处理 1 号垃圾，所以 3 号垃圾无法传输， 在此等待；
开始投放 7 秒后，1 号垃圾处理完成；
开始投放 9 秒后，3 号垃圾到达 3 号垃圾桶；
开始投放 14 秒后，3 号垃圾处理完成。此时，所有垃圾都已经处理完。

输入输出样例2
样例输入
6 4
6 5 4 3 2 1
1 2
3 2
2 4
5 4
1 6
样例输出
18
样例说明
开始投放 9 秒后，1 号垃圾处理完；
开始投放 8 秒后，2 号垃圾处理完；
开始投放 14 秒后，3 号垃圾处理完；
开始投放 12 秒后，4 号垃圾处理完；
开始投放 16 秒后，5 号垃圾处理完；
开始投放 18 秒后，6 号垃圾处理完。

数据规模与约定
对于100%的数据， n <= 100000, 0 <= ai <= 10^9, 1 <= x, y <= n。

@solution@

首先转化一下问题，去除投放垃圾这一过程：
我们从 r 开始连出去 n 个点连成一条链，并把 1~n 号垃圾从前往后放置在这些点上面。即 n -> n-1 -> ... -> 1 -> r（前面的 1~n 是垃圾放置的对应结点）。
这样就只剩下垃圾在结点之间移动了。

考虑垃圾之间一般是不会互相影响的，垃圾 x 会堵塞垃圾 y，要么是因为垃圾 x 本身在处理，要么是垃圾 x 被前面某个垃圾间接堵塞了。

我们记标记 (x, t) 表示在时刻 t 之前无法通过 x，而从时刻 t 开始可以通过结点 x（通过包含到达的情况）。
注意这里的标记是一个下界，不一定时刻 t 一定就有垃圾通过结点 x。
那么标记的产生就会两种情况：某垃圾被处理了，某垃圾被间接堵塞了。

对于第 i 个垃圾，它到达的时间受它所在结点与目的地之间的路径上所有标记的影响。
它的终点为点 i，因为这些标记 (x, t) 对于 i 的影响为 t + dep[i] - dep[x]。
我们维护 max(t - dep[x])，就可以快速求出一个点到达目的地的时间。

然后考虑怎么维护标记：

先考虑间接堵塞，我们发现这个等价于所有标记上移到结点的父亲。
如果是在链上，这个操作可以用平衡树来维护（貌似也可以用线段树）。
如果是在树上，最常见的就是树链剖分转为序列问题。但是从重链顶端上移时，需要进行类区间拆分与区间合并的操作。于是就不得不用什么平衡树来做了。
貌似用 lct 要更自然一点。不过 splay 太难写了（

然后是自己被处理，会产生一个 (max(t - dep[x]) + dep[i] + a[i] +1, x) 的标记。平衡树上直接插入即可。这里的插入必须要在标记向上爬之后再插。

当然为了保证合法，我们还要加上标记 (1, 1)。
时间复杂度 O(nlog^2n)。

@accepted code@

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll INF = (1LL<<60);
const int MAXN = 200000;
struct node{
    ull pri;
    ll tg, mx, val;
    int dep;
    node *ch[2];
}pl[MAXN + 5], *ncnt, *NIL;
typedef pair<node*, node*> Droot;
struct treap{
    treap() {
        NIL = ncnt = &pl[0];
        NIL->mx = -INF;
        NIL->ch[0] = NIL->ch[1] = NIL;
    }
    ull get_rand() {
        ull p = rand(), q = (p << 16) | rand();
        ull u = rand(), v = (u << 16) | rand();
        return (q << 32) | v;
    }
    node *newnode(ll x, int d) {
        node *p = (++ncnt);
        p->dep = d, p->mx = p->val = x;
        p->pri = get_rand(), p->tg = 0;
        p->ch[0] = p->ch[1] = NIL;
        return p;
    }
    void maintain(node *x, ll k) {
        if( x == NIL ) return ;
        x->tg += k, x->mx += k, x->val += k, x->dep -= k;
    }
    void pushup(node *x) {
        x->mx = max(max(x->ch[0]->mx, x->ch[1]->mx), x->val);
    }
    void pushdown(node *x) {
        if( x->tg ) {
            maintain(x->ch[0], x->tg);
            maintain(x->ch[1], x->tg);
            x->tg = 0;
        }
    }
    node *merge(node *x, node *y) {
        if( x == NIL ) return y;
        if( y == NIL ) return x;
        pushdown(x), pushdown(y);
        if( x->pri < y->pri ) {
            x->ch[1] = merge(x->ch[1], y);
            pushup(x); return x;
        }
        else {
            y->ch[0] = merge(x, y->ch[0]);
            pushup(y); return y;
        }
    }
    Droot split(node *x, int k) {
        if( x == NIL ) return make_pair(NIL, NIL);
        pushdown(x);
        if( k < x->dep ) {
            Droot p = split(x->ch[0], k);
            x->ch[0] = p.second; pushup(x);
            return make_pair(p.first, x);
        }
        else {
            Droot p = split(x->ch[1], k);
            x->ch[1] = p.first; pushup(x);
            return make_pair(x, p.second);
        }
    }
    node *insert(node *x, node *y) {
        Droot p = split(x, y->dep);
        return merge(p.first, merge(y, p.second));
    }
}T;
struct edge{
    int to; edge *nxt;
}edges[2*MAXN + 5], *adj[MAXN + 5], *ecnt=&edges[0];
void addedge(int u, int v) {
    edge *p = (++ecnt);
    p->to = v, p->nxt = adj[u], adj[u] = p;
    p = (++ecnt);
    p->to = u, p->nxt = adj[v], adj[v] = p;
}
int hvy[MAXN + 5], siz[MAXN + 5], dep[MAXN + 5], fa[MAXN + 5];
void dfs1(int x, int f) {
    siz[x] = 1, dep[x] = dep[f] + 1, fa[x] = f, hvy[x] = 0;
    for(edge *p=adj[x];p;p=p->nxt) {
        if( p->to == f ) continue;
        dfs1(p->to, x);
        siz[x] += siz[p->to];
        if( siz[hvy[x]] < siz[p->to] )
            hvy[x] = p->to;
    }
}
node *rt[MAXN + 5];
int top[MAXN + 5], tid[MAXN + 5], dfn[MAXN + 5], dcnt = 0;
void dfs2(int x, int tp) {
    rt[x] = NIL;
    top[x] = tp, tid[x] = (++dcnt), dfn[dcnt] = x;
    if( !hvy[x] ) return ;
    dfs2(hvy[x], tp);
    for(edge *p=adj[x];p;p=p->nxt)
        if( p->to != fa[x] && p->to != hvy[x] )
            dfs2(p->to, p->to);
}
void insert(int x, ll k) {
    node *p = T.newnode(k - dep[x], dep[x]);
    rt[top[x]] = T.insert(rt[top[x]], p);
}
ll query(int x) {
    ll ret = -INF;
    while( x ) {
        Droot p = T.split(rt[top[x]], dep[x]);
        ret = max(ret, p.first->mx);
        rt[top[x]] = T.merge(p.first, p.second);
        x = fa[top[x]];
    }
    return ret;
}
void update(int x) {
    node *y = NIL;
    while( x ) {
        Droot p = T.split(rt[top[x]], dep[x]);
        T.maintain(p.first, 1);
        rt[top[x]] = T.merge(p.first, p.second);
        p = T.split(rt[top[x]], dep[top[x]] - 1);
        rt[top[x]] = T.insert(p.second, y), y = p.first;
        x = fa[top[x]];
    }
}
int a[MAXN + 5], n, r;
int main() {
    freopen("garbage.in", "r", stdin);
    freopen("garbage.out", "w", stdout);
    srand(0307); scanf("%d%d", &n, &r);
    for(int i=1;i<=n;i++)
        scanf("%d", &a[i]);
    for(int i=1;i<n;i++) {
        int u, v; scanf("%d%d", &u, &v);
        addedge(u, v);
    }
    addedge(r, n + 1);
    for(int i=2;i<=n;i++) addedge(n + i - 1, n + i);
    dfs1(2*n, 0), dfs2(2*n, 2*n), insert(r, 1);
    ll ans = 0;
    for(int i=1;i<=n;i++) {
        ll tmp = dep[i] + query(i) + a[i];
        update(i), insert(i, tmp + 1);
        ans = max(ans, tmp);
    }
    printf("%lld
", ans);
}

@details@

出题人在嘲讽选手是垃圾

话说树链剖分套平衡树是否超出了 CSP 的考纲范围内。
（也不一定，毕竟去年连 ddp 都考）