bzoj 4530[BJOI2014]大融合 - LCT维护虚树大小

BZOJ4530 [Bjoi2014]大融合

Time Limit: 30 Sec  Memory Limit: 512 MB

Description

小强要在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)。

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

询问。

Input

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

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

A x y 表示在x和y之间连一条边。保证之前x和y是不联通的。

Q x y 表示询问(x,y)这条边上的负载。保证x和y之间有一条边。

1≤N,Q≤100000

Output

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

Sample Input

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

Sample Output

6

 

这道题是一道用LCT维护虚树大小的板子题

我们只需要单独用一个变量存储虚树大小，当一个节点的一条重链变成轻链时，它的虚树大小就加上断开的子树大小即可，反之减掉即可

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
#define lc t[x].ch[0]
#define rc t[x].ch[1] 

using namespace std;

const int MAXN = 1e5 + 10;

int N, Q;
char opr[10];

int s[MAXN];
struct node {
    int ch[2];
    int fa;
    int lazy;
    int size;
    int val; 
} t[MAXN];

inline LL read()
{
    LL x = 0, w = 1; char ch = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-') {
            w = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * w;
}

void pushdown(int x)
{
    if(t[x].lazy) {
        swap(lc, rc);
        t[lc].lazy ^= 1;
        t[rc].lazy ^= 1;
        t[x].lazy = 0;
    }
}

bool isroot(int x)
{
    return t[t[x].fa].ch[0] != x && t[t[x].fa].ch[1] != x;
}

void pushup(int x)
{
    t[x].val = t[x].size + t[lc].val + t[rc].val + 1;
}

void rotate(int x)
{
    int y = t[x].fa, z = t[y].fa;
    int l, r;
    if(!isroot(y)) {
        if(t[z].ch[0] == y) {
            t[z].ch[0] = x;
        } else {
            t[z].ch[1] = x;
        }
    }
    if(t[y].ch[0] == x) {
        l = 0;
    } else {
        l = 1;
    }
    r = l ^ 1;
    t[y].ch[l] = t[x].ch[r], t[t[x].ch[r]].fa = y;
    t[x].ch[r] = y, t[x].fa = z, t[y].fa = x;
    pushup(y);
    pushup(x);
}

void splay(int x)
{
    int y = x;
    int cnt = 0;
    while(!isroot(y)) {
        s[++cnt] = y;
        y = t[y].fa;
    }
    s[++cnt] = y;
    while(cnt) {
        pushdown(s[cnt--]);
    }
    while(!isroot(x)) {
        int y = t[x].fa, z = t[y].fa;
        if(!isroot(y)) {
            if((t[y].ch[0] == x) ^ (t[z].ch[0] == y)) {
                rotate(x);
            } else {
                rotate(y);
            }
        }
        rotate(x);
    }
}

void access(int x)
{
    for(int y = 0; x; y = x, x = t[x].fa) {
        splay(x);
        t[x].size += t[rc].val;
        rc = y;
        t[x].size -= t[rc].val;
        pushup(x);
    }
}

void makeroot(int x)                                                                 
{
    access(x);
    splay(x);
    t[x].lazy ^= 1;
}

void split(int x, int y)
{
    makeroot(x);
    access(y);
    splay(y);
}

void link(int x, int y)
{
    makeroot(x);
    //split(x, y);
    t[x].fa = y;
    t[y].size += t[x].val;
    pushup(y);
}

int findroot(int x)
{
    access(x), splay(x);
    pushdown(x);
    while(lc) {
        x = lc;
        pushdown(x);
    }
    return x;
}

int main()
{
    N = read(), Q = read(); 
    for(int i = 1; i <= N; i++) {
        t[i].val = 1;
    }
    for(int i = 1; i <= Q; i++) {
        scanf("%s", opr);
        int x = read(), y = read();
        if(opr[0] == 'A') {
            link(x, y);
        } else {
            split(x, y);
            LL ans = (t[x].size + 1) * (t[y].size + 1);
            printf("%lld\n", ans);
        }
    }
}