P4219 [BJOI2014]大融合 LCT维护子树大小

\(\color{#0066ff}{ 题目描述 }\)

小强要在\(N\)个孤立的星球上建立起一套通信系统。这套通信系统就是连接\(N\)个点的一个树。 这个树的边是一条一条添加上去的。在某个时刻，一条边的负载就是它所在的当前能够 联通的树上路过它的简单路径的数量。

例如，在上图中，现在一共有了\(5\)条边。其中，\((3,8)\)这条边的负载是\(6\)，因 为有六条简单路径\(2-3-8\)，\(2-3-8-7\)，\(3-8\)，\(3-8-7\)，\(4-3-8\)，\(4-3-8-7\)路过了\((3,8)\)。

现在，你的任务就是随着边的添加，动态的回答小强对于某些边的负载的 询问。

\(\color{#0066ff}{输入格式}\)

第一行包含两个整数 \(N, Q\),表示星球的数量和操作的数量。星球从 \(1\) 开始编号。

接下来的 \(Q\) 行，每行是如下两种格式之一：

• A x y 表示在 \(x\)和 \(y\) 之间连一条边。保证之前 \(x\) 和 \(y\)是不联通的。
• Q x y表示询问 \((x,y)\) 这条边上的负载。保证 \(x\) 和 \(y\) 之间有一条边。

\(\color{#0066ff}{输出格式}\)

对每个查询操作，输出被查询的边的负载。

\(\color{#0066ff}{输入样例}\)

8 6
A 2 3
A 3 4
A 3 8
A 8 7
A 6 5
Q 3 8

\(\color{#0066ff}{输出样例}\)

6

\(\color{#0066ff}{数据范围与提示}\)

对于所有数据，\(1≤N,Q≤10^5\)

\(\color{#0066ff}{ 题解 }\)

众所周知，LCT是维护树链的强力数据结构

对于维护一个子树的信息，是不太好维护的

但是动态的连边删边又不得不用LCT

其实，LCT维护一个子树信息并没有那么难

显然本题要维护的是子树siz

我们记tot为子树大小，siz为虚子树大小之和（LCT虚实边）

我们考虑LCT的哪些函数会影响这些东西

首先，upd肯定是要改的，即

void upd() {
    tot = siz + 1;
    if(ch[0]) tot += ch[0]->tot;
    if(ch[1]) tot += ch[1]->tot;
}

注意，左右孩子实际上是splay维护的一条链上的两个点

tot初始为自己的虚子树的和+自己大小1

如果有实儿子，统计总共的大小

接下来rot和splay，显然不会改变边的虚实，所以直接维护即可

然后是access，它会改变很多边的虚实，所以会产生影响

也好维护，让x的siz减掉即将变成实边的虚边的贡献，加上即将变为虚边的实边的贡献即可

makeroot， findroot都没有影响qwq

link，有影响， 因为连了一条虚边，只需加一下贡献即可，加完后upd一下

注意link的不光要makeroot(x)，还要把y弄到根上去，这样y就没有祖先了，再加就不会影响了

#include<bits/stdc++.h>
#define LL long long
LL in() {
    char ch; LL x = 0, f = 1;
    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
    return x * f;
}
const int maxn = 1e5 + 100;
struct LCT {
protected:
    struct node {
        node *ch[2], *fa;
        int siz, rev, tot;
        node(int siz = 0, int rev = 0, int tot = 1): siz(siz), rev(rev), tot(tot) { ch[0] = ch[1] = fa = NULL; }
        void trn() { std::swap(ch[0], ch[1]), rev ^= 1; }
        void dwn() {
            if(!rev) return;
            if(ch[0]) ch[0]->trn();
            if(ch[1]) ch[1]->trn();
            rev = 0;
        }
        void upd() {
            tot = siz + 1;
            if(ch[0]) tot += ch[0]->tot;
            if(ch[1]) tot += ch[1]->tot;
        }
        bool isr() { return fa->ch[1] == this; }
        bool ntr() { return fa && (fa->ch[0] == this || fa->ch[1] == this); }
    }pool[maxn];
    void rot(node *x) {
        node *y = x->fa, *z = y->fa;
        bool k = x->isr(); node *w = x->ch[!k];
        if(y->ntr()) z->ch[y->isr()] = x;
        (x->ch[!k] = y)->ch[k] = w;
        (y->fa = x)->fa = z;
        if(w) w->fa = y;
        y->upd(), x->upd();
    }
    void splay(node *o) {
        static node *st[maxn];
        int top;
        st[top = 1] = o;
        while(st[top]->ntr()) st[top + 1] = st[top]->fa, top++;
        while(top) st[top--]->dwn();
        while(o->ntr()) {
            if(o->fa->ntr()) rot(o->isr() ^ o->fa->isr()? o : o->fa);
            rot(o);
        }
    }
    void access(node *x) {
        for(node *y = NULL; x; x = (y = x)->fa) {
            splay(x);
            if(x->ch[1]) x->siz += x->ch[1]->tot;
            x->ch[1] = y;
            if(y) x->siz -= y->tot;
            x->upd();
        }
    }
    void makeroot(node *o) { access(o), splay(o), o->trn(); }
public:
    void link(int l, int r) {
        node *x = pool + l, *y = pool + r;
        makeroot(x), access(y), splay(y);
        (x->fa = y)->siz += x->tot;
        y->upd();
    }
    int query(int l, int r) {
        node *x = pool + l, *y = pool + r;
        makeroot(x), access(y), splay(y);
        return (x->siz + 1) * (y->siz + 1);
    }
}s;
int n, m;
char getch() {
    char ch;
    while(!isalpha(ch = getchar()));
    return ch;
}
int main() {
    n = in(), m = in();
    for(int i = 1; i <= m; i++) {
        if(getch() == 'A') s.link(in(), in());
        else printf("%d\n", s.query(in(), in()));
    }
    return 0;
}

转载于:https://www.cnblogs.com/olinr/p/10394081.html