@codeforces - 414E@ Mashmokh's Designed Problem

Posted 2022-06-28 tiw-air-oao

目录

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

---

@description@

给定一棵 n 个点的树，每个点的儿子是有序的。
现给定 m 次操作，每次操作是下列三种中的一种：

（1）给定 u, v，询问 u, v 之间的距离。
（2）给定 v, h，断开 v 到父亲的边，将 v 这棵子树加入到它的第 h 个祖先的最后一个儿子。
（3）给定 k，询问在当前这棵树上 dfs 后得到 dfs 序中，最后一个深度为 k 的点的编号。

Input
第一行包含两个整数 n,?m (2?≤?n?≤?10^5; 1?≤?m?≤?10^5)，表示点数与询问数。
接下来 n 行每行一个 li，表示 i 号结点的儿子个数。紧接着输入 li 个整数，第 j 个整数表示 i 的第 j 个儿子编号（再次强调儿子是有序的）。
接下来 m 行每行形如 "1 v u", "2 v h", 或 "3 k"。第一个数描述操作种类，接下来描述了这个操作的参数。
保证操作合法。

Output
对于 1, 3 询问，输出其对应的答案。

Examples
Input1
4 9
1 2
1 3
1 4
0
1 1 4
2 4 2
1 3 4
3 1
3 2
2 3 2
1 1 2
3 1
3 2
Output1
3
2
2
4
1
3
4

Input2
2 2
1 2
0
1 2 1
3 1
Output2
1
2

@solution@

看到连边删边很自然地想到 lct，然而 lct 并没有办法很好地维护询问 3。。。
考虑对于连边删边的另一种处理方法：使用平衡树维护括号序，剪切某棵子树对应的序列与拼接某棵子树对应的序列即可。

然而它要求两点距离？那我们类比一下括号序，使用平衡树维护一下欧拉序即可（就是可以把 lca 问题转为 rmq 问题的那个东东）。

对于询问 1，我们提取出 u, v 之间的区间，查询里面 dep 的最小值 x，用 dep[u] + dep[v] - 2*x 即可。
对于询问 3，我们可以发现欧拉序相邻位置的深度是连续的。所以我们可以存储 dep 的最小值与 dep 的最大值来判断一棵子树内是否含有某个特定 dep 的值。
对于操作 2，我们首先要定位 x 的第 h 个祖先。可以提取出以 x 为结尾的序列前缀，在这个前缀上找最后一个深度为 dep[x]-h 的点——其实就是询问 3。然后剪切，拼接，把 x 的子树内所有点的深度减去一个量（打 tag 就好了）。

总复杂度就是 splay 的复杂度 O(nlogn)。

@accepted code@

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXN = 200000;
struct Splay
    struct node
        node *fa, *ch[2];
        int num, key, mx, mn, tg;
    pl[2*MAXN + 5], *root, *NIL;
    Splay() 
        root = NIL = &pl[0];
        NIL->ch[0] = NIL->ch[1] = NIL->fa = NIL;
        NIL->mx = -MAXN, NIL->mn = MAXN, NIL->tg = 0;
    
    void set_child(node *x, node *y, int d) 
        if( x != NIL ) x->ch[d] = y;
        if( y != NIL ) y->fa = x;
    
    void pushdown(node *x) 
        if( x->tg ) 
            if( x->ch[0] != NIL )
                x->ch[0]->key += x->tg, x->ch[0]->mx += x->tg, x->ch[0]->mn += x->tg, x->ch[0]->tg += x->tg;
            if( x->ch[1] != NIL )
                x->ch[1]->key += x->tg, x->ch[1]->mx += x->tg, x->ch[1]->mn += x->tg, x->ch[1]->tg += x->tg;
            x->tg = 0;
        
    
    void pushup(node *x) 
        x->mn = min(x->key, min(x->ch[0]->mn, x->ch[1]->mn));
        x->mx = max(x->key, max(x->ch[0]->mx, x->ch[1]->mx));
    
    void rotate(node *x) 
        node *y = x->fa; int d = (y->ch[1] == x);
        pushdown(y), pushdown(x);
        if( y->fa != NIL ) set_child(y->fa, x, y->fa->ch[1] == y);
        else x->fa = y->fa;
        set_child(y, x->ch[!d], d);
        set_child(x, y, !d);
        if( y == root ) root = x;
        pushup(y);
    
    void splay(node *x, node *rt) 
        pushdown(x);
        while( x->fa != rt ) 
            node *y = x->fa;
            if( y->fa == rt )
                rotate(x);
            else 
                if( (y->fa->ch[1] == y) == (y->ch[1] == x) )
                    rotate(y);
                else rotate(x);
                rotate(x);
            
        
        pushup(x);
    
    void debug(node *x) 
        if( x == NIL ) return ;
        pushdown(x);
        debug(x->ch[0]);
        printf("%d : %d %d %d | %d %d\n", x-pl, x->ch[0]-pl, x->ch[1]-pl, x->fa-pl, x->num, x->key);
        debug(x->ch[1]);
    
    int dist(node *x, node *y) 
        if( x == y ) return 0;
        splay(x, NIL), splay(y, root);
        if( x->ch[0] == y ) 
            int d = min(min(x->key, y->key), x->ch[0]->ch[1]->mn);
            return x->key + y->key - 2*d;
        
        else 
            int d = min(min(x->key, y->key), x->ch[1]->ch[0]->mn);
            return x->key + y->key - 2*d;
        
    
    node *query(node *x, int d) 
        pushdown(x);
        if( x->ch[1]->mn <= d && d <= x->ch[1]->mx )
            return query(x->ch[1], d);
        else if( x->key == d ) 
            splay(x, NIL);
            return x;
        
        else return query(x->ch[0], d);
    
    node *prev(node *x, node *rt) 
        splay(x, rt);
        node *ret = x->ch[0];
        while( ret->ch[1] != NIL )
            ret = ret->ch[1];
        splay(ret, rt);
        return ret;
    
    node *next(node *x, node *rt) 
        splay(x, rt);
        node *ret = x->ch[1];
        while( ret->ch[0] != NIL )
            ret = ret->ch[0];
        splay(ret, rt);
        return ret;
    
T;
Splay::node *fir[MAXN + 5], *bac[MAXN + 5];
int n, m, root;
vector<int>G[MAXN + 5];
void addedge(int u, int v) 
    G[u].push_back(v);

int dep[MAXN + 5], dfn[2*MAXN + 5], dcnt;
void newnode(Splay::node *nw, int x, int k) 
    nw->ch[0] = nw->ch[1] = nw->fa = T.NIL;
    nw->num = x, nw->key = nw->mn = nw->mx = k, nw->tg = 0;

void dfs(int x) 
    dfn[++dcnt] = x, fir[x] = bac[x] = &T.pl[dcnt], newnode(&T.pl[dcnt], x, dep[x]);
    for(int i=0;i<G[x].size();i++) 
        int p = G[x][i];
        dep[p] = dep[x] + 1, dfs(p);
        dfn[++dcnt] = x, bac[x] = &T.pl[dcnt], newnode(&T.pl[dcnt], x, dep[x]);
    

Splay::node *build(int l, int r) 
    if( l > r ) return T.NIL;
    int mid = (l + r) >> 1;
    Splay::node *p = &T.pl[mid];
    p->ch[0] = build(l, mid - 1);
    if( p->ch[0] != T.NIL ) p->ch[0]->fa = p;
    p->ch[1] = build(mid + 1, r);
    if( p->ch[1] != T.NIL ) p->ch[1]->fa = p;
    T.pushup(p);
    return p;

bool tag[MAXN + 5];
int main() 
    scanf("%d%d", &n, &m);
    for(int i=1;i<=n;i++) 
        int l; scanf("%d", &l);
        for(int j=1;j<=l;j++) 
            int x; scanf("%d", &x);
            addedge(i, x); tag[x] = true;
        
    
    for(int i=1;i<=n;i++)
        if( !tag[i] ) root = i;
    newnode(&T.pl[++dcnt], 0, -1), dfs(root), newnode(&T.pl[++dcnt], 0, -1);
    T.root = build(1, dcnt);
    for(int i=1;i<=m;i++) 
        int op; scanf("%d", &op);
        if( op == 1 ) 
            int v, u; scanf("%d%d", &v, &u);
            printf("%d\n", T.dist(fir[v], fir[u]));
        
        else if( op == 2 ) 
            int v, h; scanf("%d%d", &v, &h);
            T.splay(fir[v], T.NIL); Splay::node *u = T.query(fir[v]->ch[0], fir[v]->key-h);
            Splay::node *l = T.prev(fir[v], T.NIL), *r = T.next(bac[v], T.root);
            if( bac[l->num] == r ) bac[l->num] = l;
            T.set_child(l, r->ch[1], 1);
            Splay::node *p = r->ch[0];
            newnode(r, u->num, u->key), r->ch[0] = p;
            r->tg += 1-h, T.pushdown(r), T.pushup(r);
            T.next(bac[u->num], T.NIL), T.splay(bac[u->num], T.root);
            bac[u->num] = r;
            T.set_child(T.root->ch[0], r, 1);
        
        else if( op == 3 ) 
            int k; scanf("%d", &k);
            printf("%d\n", T.query(T.root, k)->num);
        
    

@details@

一开始建树的时候没有 pushup，陷入了奇怪的 RE。。。
之后发现，用指针邻接表的形式存储会改变儿子之间的顺序，于是改成了 vector。。。

然后就是注意 splay 查找的复杂度是均摊在 splay 操作里的，所以查找到某一个值就赶紧把它 splay 上去，不然可能会 T。