BZOJ3720 Gty的妹子树 【树分块】

题目

我曾在弦歌之中听过你，

檀板声碎，半出折子戏。

舞榭歌台被风吹去，

岁月深处尚有余音一缕……

Gty神(xian)犇(chong)从来不缺妹子……

他来到了一棵妹子树下，发现每个妹子有一个美丽度……

由于Gty很哲♂学，他只对美丽度大于某个值的妹子感兴趣。

他想知道某个子树中美丽度大于k的妹子个数。

某个妹子的美丽度可能发生变化……

树上可能会出现一只新的妹子……

维护一棵初始有n个节点的有根树(根节点为1)，树上节点编号为1-n，每个点有一个权值wi。

支持以下操作：

0 u x 询问以u为根的子树中，严格大于x的值的个数。(u^=lastans,x=lastans)

1 u x 把u节点的权值改成x。(u^=lastans,x=lastans)

2 u x 添加一个编号为"当前树中节点数+1"的节点，其父节点为u，其权值为x。(u^=lastans,x=lastans)

最开始时lastans=0。

输入格式

输入第一行包括一个正整数n(1<=n<=30000)，代表树上的初始节点数。

接下来n-1行，每行2个整数u,v，为树上的一条无向边。

任何时刻，树上的任何权值大于等于0，且两两不同。

接下来1行，包括n个整数wi，表示初始时每个节点的权值。

接下来1行，包括1个整数m(1<=m<=30000)，表示操作总数。

接下来m行，每行包括三个整数 op,u,v：

op,u,v的含义见题目描述。

保证题目涉及的所有数在int内。

输出格式

对每个op=0，输出一行，包括一个整数，意义见题目描述。

输入样例

2

1 2

10 20

1

0 1 5

输出样例

2

提示

2017.9.28新加数据一组by GXZlegend,未重测

题解

这就是传说中的树分块？ get到了

我们从1【根节点】开始加入块中，若当前节点u的父亲所在块容量没满，那么加入父亲的块中，否则新开一块

这样一来，块内元素数量的平衡，每对相邻节点之间，要么属于同一块，要么是各自块之间的唯一接口

对于块内，我们可以暴力维护排序，每次查询块内大于k的个数直接二分【事实证明暴力并非正解，在洛谷会被卡2个点】

对于每次查询，我们只需要从该节点出发往下，对于同一个块的直接暴力统计，不同块的直接查询，

对于原树我们再将所有块缩点建一棵新树，每次查询时到达新块时就直接换到新图上跑

总的复杂度\(O((n + m)\sqrt{n + m}log\sqrt{n + m})\)有点悬。。

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define LL long long int
#define REP(i,n) for (int i = 1; i <= (n); i++)
#define Redge(u) for (int k = h[u],to; k; k = ed[k].nxt)
#define BUG(s,n) for (int i = 1; i <= (n); i++) cout<<s[i]<<' '; puts("");
using namespace std;
const int maxn = 60005,maxm = 100005,INF = 1000000000;
inline int read(){
    int out = 0,flag = 1; char c = getchar();
    while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}
    while (c >= 48 && c <= 57) {out = (out << 3) + (out << 1) + c - '0'; c = getchar();}
    return out * flag;
}
int n,m,T;
struct BLOCK{
    int a[201],siz;
    BLOCK(){siz = 0;}
    void insert(int x){
        int i;
        for (i = ++siz; i > 1 && a[i - 1] > x; i--) a[i] = a[i - 1];
        a[i] = x;
    }
    int query(int x){
        int l = 1,r = siz,mid;
        while (l < r){
            mid = l + r >> 1;
            if (a[mid] > x) r = mid;
            else l = mid + 1;
        }
        return a[siz] > x ? siz - l + 1 : 0;
    }
    void modify(int x,int v){
        int l = 1,r = siz,mid;
        while (l < r){
            mid = l + r >> 1;
            if (a[mid] > x) r = mid - 1;
            else if (a[mid] < x) l = mid + 1;
			else {l = mid; break;}
        }
		int i = l;
        a[i] = v;
        while (i > 1 && a[i] < a[i - 1]) a[i] ^= a[i - 1] ^= a[i] ^= a[i - 1],i--;
        while (i < siz && a[i] > a[i + 1]) a[i] ^= a[i + 1] ^= a[i] ^= a[i + 1],i++;
    }
}block[maxn];
int fa[maxn],val[maxn],b[maxn],bi,ans;
int h[maxn],ne = 2,hb[maxn],nb = 1;
struct EDGE{int to,nxt;}ed[2 * maxn],e[2 * maxn];
void build(int u,int v){
    ed[ne] = (EDGE){v,h[u]}; h[u] = ne++;
    ed[ne] = (EDGE){u,h[v]}; h[v] = ne++;
}
void add(int u,int v){
    e[nb] = (EDGE){v,hb[u]}; hb[u] = nb++;
}
void dfs(int u){
    if (fa[u] && block[b[fa[u]]].siz < T)
        block[b[u] = b[fa[u]]].insert(val[u]);
    else {
        block[b[u] = ++bi].insert(val[u]);
        if (fa[u]) add(b[fa[u]],b[u]);
    }
    Redge(u) if ((to = ed[k].to) != fa[u]){
        fa[to] = u; dfs(to);
    }
}
void DFS2(int u,int v){
    ans += block[u].query(v);
    for (int k = hb[u]; k; k = e[k].nxt) DFS2(e[k].to,v);
}
void DFS(int u,int v){
    if (val[u] > v) ans++;
    Redge(u) if ((to = ed[k].to) != fa[u]){
        if (b[to] == b[u]) DFS(to,v);
        else DFS2(b[to],v);
    }
}
int main(){
    n = read();
    for (int i = 1; i < n; i++) build(read(),read());
    for (int i = 1; i <= n; i++) val[i] = read();
    m = read(); T = (int)sqrt(n);
    dfs(1);
    int opt,u,v;
    while (m--){
        opt = read(); u = read() ^ ans; v = read() ^ ans;
        if (!opt){
            ans = 0; DFS(u,v);
            printf("%d\n",ans);
        }
        else if (opt & 1) block[b[u]].modify(val[u],v),val[u] = v;
        else {
            int x = ++n; build(u,x); fa[x] = u; val[x] = v;
            if (block[b[u]].siz < T)
                block[b[x] = b[u]].insert(val[x]);
            else block[b[x] = ++bi].insert(val[x]),add(b[u],b[x]);
        }
    }
    return 0;
}