LCT 进阶指南

最新推荐文章于 2022-10-24 14:43:35 发布
最新推荐文章于 2022-10-24 14:43:35 发布
阅读量410 收藏 1
点赞数
分类专栏： LCT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sslz_fsy/article/details/89425194
版权

这里总结了LCT的进阶应用, 以及几道比较难的例题

强烈推荐 : https://www.cnblogs.com/flashhu/p/9498517.html

目录

LCT 维护双强连通分量

LCT 维护子树信息

例题 : 

P2542 [AHOI2005]航线规划

U19464 山村游历(Wander)

P4299 首都

BZOJ4998星球联盟

BZOJ2959长跑

P3613 睡觉困难综合征

LCT 维护双强连通分量

可以说是LCT 套一个并查集, 但是只支持插入不能删除

我们没插入一条边(x, y), 有以下 3 种情况

1.本身在一个强联通分量, 直接跳过

2.不在一个强联通分量, 但连通, 这时我们将 x makeroot, y access , y splay, 然后将路径上的点全部用并查集合并到 x 上

3. 不连通, 相当于Link

注意一旦要用某个点x, 我们不能直接用, 要用 x 的在并查集中的祖先

也就是说一个强联通分量里的所有操作都用祖先那个点的编号代替了

LCT 维护子树信息

核心操作就是统一维护虚子树的信息, Access更新, 维护子树的代码如下

// siz 为虚子树, t[x].siz 维护整个子树的siz
void Pushup(int x){
	t[x].siz = t[ls].siz + t[rs].siz + siz[x] + 1;
}
void Access(int x){
	for(int y = 0; x; y = x, x = t[x].fa){
		Splay(x);
		siz[x] += t[rs].siz;
		rs = y;
		siz[x] -= t[rs].siz;
		Pushup(x);
	}
}

另外, link 操作将x置为y的序儿子, 要将x的siz 加到y的虚子树siz上

bool Link(int x, int y){
	Makeroot(x); 
	t[x].fa = y; siz[y] += t[x].siz;
	Pushup(y); 
}

P2542 [AHOI2005]航线规划

我们将所有双强联通分量缩成一个点过后, x 到 y 路径点的个数 - 1 就是答案

#include<bits/stdc++.h>
#define N 100050
using namespace std;
int read(){
	int cnt = 0, f = 1; char ch = 0;
	while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;} 
	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
	return cnt * f;
}
int n, m, T;
struct Qu{int op, x, y;}q[N];
#define ls t[x].ch[0]
#define rs t[x].ch[1]
struct Node{
	int ch[2], fa, siz, rev;
}t[N];
struct Edge{ int x, y;} E[N];
map<pair<int, int> , int> vis;
int fa[N];
int find(int x){ return x == fa[x] ? x : fa[x] = find(fa[x]);}
int ans[N], res;

bool isRoot(int x){
	int fa = t[x].fa;
	return t[fa].ch[0] != x && t[fa].ch[1] != x;
}
void Pushup(int x){ t[x].siz = t[ls].siz + t[rs].siz + 1;}
void Pushrev(int x){
	if(!x) return; swap(ls, rs); t[x].rev ^= 1;
}
void Pushdown(int x){
	if(t[x].rev){ Pushrev(ls); Pushrev(rs); t[x].rev = 0;}
} 
void Pushpath(int x){
	if(!isRoot(x)) Pushpath(t[x].fa);
	Pushdown(x);
}
void rotate(int x){
	int y = t[x].fa, z = t[y].fa;
	int k = t[y].ch[1] == x;
	if(!isRoot(y)) t[z].ch[t[z].ch[1] == y] = x;
	t[x].fa = z;
	t[y].ch[k] = t[x].ch[k^1];
	t[t[x].ch[k^1]].fa = y;
	t[x].ch[k^1] = y; t[y].fa = x;
	Pushup(y); Pushup(x);
}
void Splay(int x){
	Pushpath(x);
	while(!isRoot(x)){
		int y = t[x].fa, z = t[y].fa;
		if(!isRoot(y))
			(t[y].ch[0] == x) ^ (t[z].ch[0] == y) ? rotate(x) : rotate(y);
		rotate(x);
	} 
}
void Access(int x){
	for(int y = 0; x; y = x, x = t[x].fa = find(t[x].fa))
		Splay(x), rs = y, Pushup(x);
}
void Makeroot(int x){ 
	Access(x); Splay(x); Pushrev(x);
}
int Findroot(int x){
	Access(x); Splay(x);
	Pushdown(x); while(ls) x = ls, Pushdown(x);
	Splay(x); return x;
}
int Quary(int x, int y){
	Makeroot(x); Access(y); Splay(y);
	return t[y].siz - 1;
}
void Del(int x,int goal){
	if(x) fa[x] = goal, Del(ls, goal), Del(rs, goal);
}
void Merge(int x, int y){
	if(x == y) return;
	Makeroot(x);
	if(Findroot(y) != x){ t[x].fa = y; return;}
	Del(rs, x); rs = 0; Pushup(x);
}
int main(){
	n = read(), m = read();
	for(int i=1; i<=n; i++) fa[i] = i;
	for(int i=1; i<=m; i++){
		E[i].x = read(), E[i].y = read();
		if(E[i].x > E[i].y) swap(E[i].x, E[i].y);
	}
	for(T=1; ; T++){
		int op = read(); if(op == -1) break;
		int x = read(), y = read(); if(x > y) swap(x, y);
		if(op == 0) vis[make_pair(x,y)] = 1;
		q[T] = (Qu){op, x, y};
	}
	for(int i=1; i<=m; i++){
		if(vis[make_pair(E[i].x, E[i].y)]) continue;
		Merge(find(E[i].x), find(E[i].y));
	}
	for(int i=T; i>=1; i--){
		int op = q[i].op, x = q[i].x, y = q[i].y;
		x = find(x), y = find(y);
		if(op == 0) Merge(x, y);
		if(op == 1) ans[++res] = Quary(x, y);
	} 
	for(int i=res; i>=1; i--) printf("%d\n",ans[i]);
	return 0;
}

U19464 山村游历(Wander)

对于 x -- y 路径上的每一个点, 如果它的儿子能走到y, 我们称之为走对了, 否则为走偏了

显然如果走偏了就要把那个子树走完, 贡献为siz * 2

于是每一个子树的贡献都是  siz * 2 * P(在走对之前走偏)

注意这是随机的排列。对于每个排列，有且仅有另一个排列与其顺序相反。

如果有一个排列，某一子树排在了路径边的前面（需要计算size）

那么必定有且仅有另一个对应的排列使得该子树排在路径边的后面（不需要计算size）。

由于这种等概率的对应关系，p=1/2

于是就维护子树siz, split(x,y) 然后 siz(x) - siz(y) - 1 (y的大小) 就是答案

#include<bits/stdc++.h>
#define N 100050
#define ls t[x].ch[0]
#define rs t[x].ch[1]
using namespace std;
int read(){
	int cnt = 0, f = 1; char ch = 0;
	while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;} 
	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
	return cnt * f;
}
struct Node{int ch[2], fa, rev, siz;}t[N];
int siz[N], n, m;
bool isRoot(int x){
	int fa = t[x].fa;
	return t[fa].ch[0] != x && t[fa].ch[1] != x; 
}
void Pushup(int x){
	t[x].siz = t[ls].siz + t[rs].siz + siz[x] + 1;
}
void Pushrev(int x){
	if(!x) return; swap(ls, rs); t[x].rev ^= 1;
} 
void Pushdown(int x){
	if(t[x].rev) Pushrev(ls), Pushrev(rs), t[x].rev = 0;
}
void rotate(int x){
	int y = t[x].fa, z = t[y].fa;
	int k = t[y].ch[1] == x;
	if(!isRoot(y)) t[z].ch[t[z].ch[1] == y] = x;
	t[x].fa = z;
	t[y].ch[k] = t[x].ch[k^1];
	t[t[x].ch[k^1]].fa = y;
	t[x].ch[k^1] = y; t[y].fa = x;
	Pushup(y); Pushup(x);
}
void Pushpath(int x){
	if(!isRoot(x)) Pushpath(t[x].fa);
	Pushdown(x); 
}
void Splay(int x){
	Pushpath(x);
	while(!isRoot(x)){
		int y = t[x].fa, z = t[y].fa;
		if(!isRoot(y))
			(t[y].ch[0] == x) ^ (t[z].ch[0] == y) ? rotate(x) : rotate(y);
		rotate(x); 
	}
}
void Access(int x){
	for(int y = 0; x; y = x, x = t[x].fa){
		Splay(x);
		siz[x] += t[rs].siz;
		rs = y;
		siz[x] -= t[rs].siz;
		Pushup(x);
	}
}
int Findroot(int x){
	Access(x); Splay(x); Pushdown(x);
	while(ls) x = ls, Pushdown(x);
	return x;
}
void Makeroot(int x){
	Access(x); Splay(x); Pushrev(x);
}
bool Link(int x, int y){
	Makeroot(x); 
	if(Findroot(y) == x) return false;
	t[x].fa = y; siz[y] += t[x].siz;
	Pushup(y); return true;
}
bool Cut(int x, int y){
	Makeroot(x);
	if(Findroot(y) != x) return false;
	Access(y); Splay(y); 
	if(t[x].ch[1] || t[x].fa != y) return false;
	t[y].ch[0] = t[x].fa = 0; Pushup(y);
	return true;
}
int main(){
	n = read(), m = read();
	while(m--){
		int op = read(), u = read(), v = read();
		if(op == 0){
			if(Link(u, v)) printf("OK\n"); 
			else printf("ILLEGAL\n");
		}
		if(op == 1){
			if(Cut(u, v)) printf("OK\n");
			else printf("ILLEGAL\n");
		}
		if(op == 2){ 
			Makeroot(u);
			if(Findroot(v) != u) printf("ILLEGAL\n");
			else{
				Access(v); Splay(v);
				printf("%d.0000\n", t[v].siz - siz[v] - 1);
			}
		}
	} return 0;
}

P4299 首都

相当于LCT动态维护重心

我们考虑两个分别求出重心的联通快, 发现新的重心一定在两个重心的连线上

我们将这两个点Split, 然后在Splay上二分查找新的重心, 然后用并查集维护每个点的重心

#include<bits/stdc++.h>
#define N 100050
#define ls t[x].ch[0]
#define rs t[x].ch[1]
using namespace std;
int read(){
	int cnt = 0, f = 1; char ch = 0;
	while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;} 
	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
	return cnt * f;
}
struct Node{int ch[2], fa, siz, rev;} t[N];
int fa[N], siz[N];
int find(int x){ return x == fa[x] ? x : fa[x] = find(fa[x]);}
int n, m, Xor;
bool isRoot(int x){
	int fa = t[x].fa;
	return t[fa].ch[0] != x && t[fa].ch[1] != x; 
}
void Pushup(int x){
	t[x].siz = t[ls].siz + t[rs].siz + siz[x] + 1;
}
void Pushrev(int x){
	if(!x) return; swap(ls, rs); t[x].rev ^= 1;
} 
void Pushdown(int x){
	if(t[x].rev) Pushrev(ls), Pushrev(rs), t[x].rev = 0;
}
void rotate(int x){
	int y = t[x].fa, z = t[y].fa;
	int k = t[y].ch[1] == x;
	if(!isRoot(y)) t[z].ch[ t[z].ch[1] == y ] = x;
	t[x].fa = z;
	t[y].ch[k] = t[x].ch[k^1];
	t[t[x].ch[k^1]].fa = y;
	t[x].ch[k^1] = y; t[y].fa = x;
	Pushup(y); Pushup(x);
}
void Pushpath(int x){
	if(!isRoot(x)) Pushpath(t[x].fa);
	Pushdown(x); 
}
void Splay(int x){
	Pushpath(x);
	while(!isRoot(x)){
		int y = t[x].fa, z = t[y].fa;
		if(!isRoot(y))
			(t[y].ch[0] == x) ^ (t[z].ch[0] == y) ? rotate(x) : rotate(y);
		rotate(x);
	}
}
void Access(int x){
	for(int y = 0; x; y = x, x = t[x].fa){
		Splay(x);
		siz[x] += t[rs].siz;
		rs = y;
		siz[x] -= t[rs].siz;
		Pushup(x);
	}
} 
void Makeroot(int x){
	Access(x); Splay(x); Pushrev(x);
}
void Link(int x, int y){
	Makeroot(x); Makeroot(y);
	t[x].fa = y; siz[y] += t[x].siz; Pushup(y);
	x = find(x); y = find(y);
	Makeroot(x); Access(y); Splay(y);
	int pos = n+1, now = y, lsiz = 0, rsiz = 0, goal = t[y].siz>>1;
	while(now){
		Pushdown(now);
		int lc = t[now].ch[0], rc = t[now].ch[1];
		int tmpl = lsiz + t[lc].siz, tmpr = rsiz + t[rc].siz;
		if(tmpl <= goal && tmpr <= goal) pos = min(pos, now); 
		if(tmpl > tmpr) rsiz += t[rc].siz + siz[now] + 1, now = lc;
		else lsiz += t[lc].siz + siz[now] + 1, now = rc;
	} Splay(pos);
	fa[pos] = fa[x] = fa[y] = pos; Xor ^= x ^ y ^ pos;
}
int main(){
	n = read(), m = read();
	for(int i=1; i<=n; i++) fa[i] = i, Xor ^= i;
	while(m--){
		char s[5]; scanf("%s", s);
		if(s[0] == 'X') printf("%d\n", Xor); 
		if(s[0] == 'A'){
			int x = read(), y = read();
			Link(x, y);
		}
		if(s[0] == 'Q'){
			int x = read(); 
			printf("%d\n", find(x));
		}
	} return 0; 
}

BZOJ4998星球联盟

LCT维护双强联通分量, 然后并查集在维护一个siz就可以了

#include<bits/stdc++.h>
#define N 200050
#define ls t[x].ch[0]
#define rs t[x].ch[1]
using namespace std;
int read(){
	int cnt = 0, f = 1; char ch = 0;
	while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;} 
	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
	return cnt * f;
}
struct Node{int ch[2], fa, rev;}t[N];
int fa[N], siz[N];
int find(int x){ return x == fa[x] ? x : fa[x] = find(fa[x]);}
int n, m, p;
bool isRoot(int x){
	int fa = t[x].fa; 
	return t[fa].ch[0] != x && t[fa].ch[1] != x;
}
void Pushrev(int x){
	if(!x) return; swap(ls, rs); t[x].rev ^= 1;
}
void Pushdown(int x){
	if(t[x].rev){ Pushrev(ls); Pushrev(rs); t[x].rev = 0;}
}
void Pushpath(int x){
	if(!isRoot(x)) Pushpath(t[x].fa);
	Pushdown(x);
}
void rotate(int x){
	int y = t[x].fa, z = t[y].fa;
	int k = t[y].ch[1] == x;
	if(!isRoot(y)) t[z].ch[t[z].ch[1] == y] = x;
	t[x].fa = z;
	t[y].ch[k] = t[x].ch[k^1]; 
	t[t[x].ch[k^1]].fa = y;
	t[x].ch[k^1] = y; t[y].fa = x; 
}
void Splay(int x){
	Pushpath(x);
	while(!isRoot(x)){
		int y = t[x].fa, z = t[y].fa;
		if(!isRoot(y)) 
			(t[y].ch[0] == x) ^ (t[z].ch[0] == y) ? rotate(x) : rotate(y);
		rotate(x);
	}
}
void Access(int x){
	for(int y = 0; x; y = x, x = t[x].fa = find(t[x].fa))
		Splay(x), rs = y;
}
void Makeroot(int x){
	Access(x); Splay(x); Pushrev(x);
}
int Findroot(int x){
	Access(x); Splay(x);
	Pushdown(x); while(ls) x = ls, Pushdown(x);
	Splay(x); return x;
}
void Del(int x, int goal){
	if(x) fa[x] = goal, siz[goal] += siz[x], Del(ls, goal), Del(rs, goal);
}
void Merge(int x, int y){
	if(x == y) return;
	Makeroot(x);
	if(Findroot(y) != x){ t[x].fa = y; return;}
	Del(rs, x); rs = 0;
} 
int main(){
	n = read(), m = read(), p = read();
	for(int i=1; i<=n; i++) fa[i] = i, siz[i] = 1;
	for(int i=1; i<=m; i++){
		int x = read(), y = read();
		Merge(find(x), find(y));
	}
	for(int i=1; i<=p; i++){
		int x = read(), y = read();
		Merge(find(x), find(y));
		x = find(x), y = find(y);
		if(x == y) printf("%d\n", siz[x]);
		else printf("No\n");
	} return 0;
}

BZOJ2959长跑

刷卡的最多次数就是将路径上所有的环走完的点数

我们将这些环缩成一个点, 查询时Split(x,y)就可以了

#include<bits/stdc++.h>
#define N 200050
#define ls t[x].ch[0]
#define rs t[x].ch[1]
using namespace std;
int read(){
	int cnt = 0, f = 1; char ch = 0;
	while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;} 
	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
	return cnt * f;
}
struct Node{int ch[2], fa, rev, val;}t[N];
int fa[N], a[N], val[N];
int find(int x){ return x == fa[x] ? x : fa[x] = find(fa[x]);}
int n, m;
bool isRoot(int x){
	int fa = t[x].fa; 
	return t[fa].ch[0] != x && t[fa].ch[1] != x;
}
void Pushup(int x){ t[x].val = val[x] + t[ls].val + t[rs].val;}
void Pushrev(int x){
	if(!x) return; swap(ls, rs); t[x].rev ^= 1;
}
void Pushdown(int x){
	if(t[x].rev){ Pushrev(ls); Pushrev(rs); t[x].rev = 0;}
}
void Pushpath(int x){
	if(!isRoot(x)) Pushpath(t[x].fa);
	Pushdown(x);
}
void rotate(int x){
	int y = t[x].fa, z = t[y].fa;
	int k = t[y].ch[1] == x;
	if(!isRoot(y)) t[z].ch[t[z].ch[1] == y] = x;
	t[x].fa = z;
	t[y].ch[k] = t[x].ch[k^1]; 
	t[t[x].ch[k^1]].fa = y;
	t[x].ch[k^1] = y; t[y].fa = x; 
	Pushup(y); Pushup(x);
}
void Splay(int x){
	Pushpath(x);
	while(!isRoot(x)){
		int y = t[x].fa, z = t[y].fa;
		if(!isRoot(y)) 
			(t[y].ch[0] == x) ^ (t[z].ch[0] == y) ? rotate(x) : rotate(y);
		rotate(x);
	}
}
void Access(int x){
	for(int y = 0; x; y = x, x = t[x].fa = find(t[x].fa))
		Splay(x), rs = y, Pushup(x);
}
void Makeroot(int x){
	Access(x); Splay(x); Pushrev(x);
}
int Findroot(int x){
	Access(x); Splay(x);
	Pushdown(x); while(ls) x = ls, Pushdown(x);
	Splay(x); return x;
}
void Del(int x, int goal){
	if(x) fa[x] = goal, val[goal] += val[x], Del(ls, goal), Del(rs, goal);
}
void Merge(int x, int y){
	if(x == y) return;
	Makeroot(x);
	if(Findroot(y) != x){ t[x].fa = y; return;}
	Del(rs, x); rs = 0;
} 
int main(){
	n = read(), m = read();
	for(int i=1; i<=n; i++) scanf("%d", &val[i]), a[i] = val[i];
	for(int i=1; i<=n; i++) fa[i] = i;
	while(m--){
		int op = read(), x = read(), y = read();
		if(op == 1) Merge(find(x), find(y));
		if(op == 2){ 
			val[find(x)] -= a[x]; 
			a[x] = y;
			val[find(x)] += a[x];
			x = find(x);
			Access(x); Splay(x); Pushup(x);
		}
		if(op == 3){ 
			x = find(x), y = find(y);
			Makeroot(x); 
			if(Findroot(y) != x) printf("-1\n"); 
			else{
				Access(y); Splay(y); 
				printf("%d\n", t[y].val);
			}
		}
	} return 0;
}

P3613 睡觉困难综合征

按位处理是显然的, 我们用树剖或者LCT维护都可以, 主要是区间如何合并

我们用 L.f0[i] 表示 对于第i位, 左区间进去是0, 出来是什么, R表示右区间, X表示合并后的区间

X.f0[i] = (L.f0[i] & R.f1[i]) | ( ! L.f0[i] & R.f0[i] )

但如果一位一位考虑是要超时的, 我们能不能压到一个long long 里来一起位运算呢

于是有  X.f0 = (L.f0 & R.f1) | (~L.f0 & R.f0) , f1 同理

我用的LCT维护, 因为这样可以忽略树剖转向的问题, 但LCT 区间翻转时记得把左右信息交换

最后查询答案时, 我们按位贪心, 如果当前位0走进1走出, 就可以直接选上

如果1走进1走出, 且当前位的值 <= z的限制, 也可以选上

#include<bits/stdc++.h>
#define N 200050
#define LL unsigned long long
#define ls t[x].ch[0]
#define rs t[x].ch[1]
using namespace std;
LL read(){
	LL cnt = 0, f = 1; char ch = 0;
	while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;} 
	while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
	return cnt * f;
}
struct Node{
	LL f0, f1; 
	friend Node operator + (const Node &a, const Node &b){
		Node c;
		c.f0 = (~a.f0 & b.f0) | (a.f0 & b.f1);
		c.f1 = (a.f1 & b.f1) | (~a.f1 & b.f0);
		return c;
	}
}a[N]; 
struct Tree{
	int ch[2], fa, rev; Node lv, rv;
}t[N];
int n, m, k;
bool isRoot(int x){
	int fa = t[x].fa;
	return t[fa].ch[0] != x && t[fa].ch[1] != x; 
}
void Pushup(int x){
	t[x].lv = t[x].rv = a[x];
	if(ls) t[x].lv = t[ls].lv + t[x].lv, t[x].rv = t[x].rv + t[ls].rv;
	if(rs) t[x].lv = t[x].lv + t[rs].lv, t[x].rv = t[rs].rv + t[x].rv;
}
void Pushrev(int x){
	if(!x) return; swap(ls, rs); swap(t[x].lv, t[x].rv); t[x].rev ^= 1;
} 
void Pushdown(int x){
	if(t[x].rev) Pushrev(ls), Pushrev(rs), t[x].rev = 0;
}
void rotate(int x){
	int y = t[x].fa, z = t[y].fa;
	int k = t[y].ch[1] == x;
	if(!isRoot(y)) t[z].ch[t[z].ch[1] == y] = x;
	t[x].fa = z;
	t[y].ch[k] = t[x].ch[k^1];
	t[t[x].ch[k^1]].fa = y;
	t[x].ch[k^1] = y; t[y].fa = x;
	Pushup(y); Pushup(x);
}
void Pushpath(int x){
	if(!isRoot(x)) Pushpath(t[x].fa);
	Pushdown(x); 
}
void Splay(int x){
	Pushpath(x);
	while(!isRoot(x)){
		int y = t[x].fa, z = t[y].fa;
		if(!isRoot(y))
			(t[y].ch[0] == x) ^ (t[z].ch[0] == y) ? rotate(x) : rotate(y);
		rotate(x); 
	}
}
void Access(int x){
	for(int y = 0; x; y = x, x = t[x].fa)
		Splay(x), rs = y, Pushup(x);
}
void Makeroot(int x){
	Access(x); Splay(x); Pushrev(x);
}
void Link(int x, int y){
	Makeroot(x); t[x].fa = y;
}
int main(){
	n = read(), m = read(), k = read();
	for(int i=1; i<=n; i++){
		int op = read(); LL val = read();
		if(op == 1){ a[i] = (Node){0, val};}
		if(op == 2){ a[i] = (Node){val, ~0};}
		if(op == 3){ a[i] = (Node){val, ~val};}
	}
	for(int i=1; i<n; i++){
		int x = read(), y = read();
		Link(x, y);
	}
	for(int i=1; i<=m; i++){
		int op = read(), x = read(), y = read(); LL z = read(); 
		if(op == 1){
			Makeroot(x); Access(y); Splay(y);
			LL ans = 0, e = 1;
			for(int i=k-1; i>=0; i--){
				if(t[y].lv.f0 & (e<<i)) ans |= (e<<i);
				else if(( t[y].lv.f1 & (e<<i) ) && z >= (e<<i)) ans |= (e<<i), z -= (e<<i);
			} cout << ans << "\n";
		}
		if(op == 2){
			Splay(x);
			if(y == 1){ a[x] = (Node){0, z};}
			if(y == 2){ a[x] = (Node){z, ~0};}
			if(y == 3){ a[x] = (Node){z, ~z};}
			Pushup(x);
		}
	} return 0;
}

 

FSYo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LCT 详解
m0_57344422的博客
08-18 1294
关于 LCT
U2000 Web LCT 用户指南-(V100R005C00_01).
05-23
U2000 Web LCT 用户指南-(V100R005C00_01).
【LeetCode】一文吃透并查集（附例题）
像我这样的人
10-24 981
其中的每个元素表示当前变量所在的连通分量的父节点信息，如果父节点是自身，说明该变量为所在连通分量的根节点。，秩没有明确的定义，一般可以指以节点为根节点的子树的深度，也可以表示以根节点的子树的节点个数，考虑按秩合并之后可以让查找的效率更高。表示每个每个节点最开始都是自己一个集合，也就是节点的父节点都是自己。查找时，沿着当前分量的父节点一路向上查找，直到找到根节点，这个过程也叫。合并时，将属于同一类的节点合并到一个树中，设计。将 x 的根节点指向 y 的根节点。并查集主要用于解决一些。，具体来说有两种方法。
史上最详尽的LCT讲解
薇小薇
11-23 6809
终于填完了这个天坑！
LA3644(并查集，维护连通分量的集合)
kevin_liu11的专栏
07-14 356
题目的大致意思就是要拒绝会使图中出现环的边，用一个并查集来进行维护，如果是同一个连通分量中的就拒绝。      #include "stdio.h" #include "string.h" #include "math.h" #include #include #include #include #include #include #include using namespace
LeetCode 803. 打砖块 ( 并查集对连通分量的维护、 逆向思维)
SongyangJi
01-16 93
803 打砖块 并查集很容易处理连通分量的合并，却不适合处理分裂。 所以逆向操作。 const int N = 4e4+10; const int dx[4] = {1,0,-1,0}; const int dy[4] = {0,1,0,-1}; struct UF{ int f[N]; int sz[N] = {0}; UF(){ for(int i=0;i<N;i++) f[i] = i; } int find(int x){
lct_LCT_
09-29
标题中的“lct_LCT_”很可能代表“Link-Cut Tree”，这是一项在计算机科学领域，特别是算法设计中广泛使用的数据结构。Link-Cut Tree（链接切割树）是一种自顶向下的动态树数据结构，主要用于解决与树相关的操作，如...
lct.zip_LCT
09-19
【标题】"lct.zip_LCT" 涉及到的是一个名为 "lct.zip" 的压缩文件，其中包含了与"LCT"相关的资料。LCT通常代表“逻辑控制技术”（Logical Control Technology）或者“线性电流变换器”（Linear Current Transformer...
lct.zip_lct文件
09-24
"流程图"文件则为使用者提供了直观的操作指南，帮助他们更好地理解和利用“lct”库。为了充分利用这个库，开发者需要了解其API，参考流程图来正确地导入和使用库中的功能，从而提升开发效率和代码质量。在实际应用中...
动态树LCT BySemiWaker
03-05
动态树LCT
[学习笔记]LCT进阶操作
weixin_33681778的博客
12-18 173
LCT总结——应用篇（附题单）（LCT） 一般都是维护链的操作。split即可搞定。 进阶操作的话，处理好辅助树和原树的关系即可搞定。 其实，最大的区别就是，splay随便转，辅助树形态变了，但是原树形态不变，makert会让原树形态变化 LCT维护子树信息 真儿子会splay的时候各种变化，但是虚儿子只会在access和link的时候发生变化，其他的时候可以理解为跟着转。 以处...
LCT
attack666的博客
06-29 4529
前置知识 必须要理解splay 最好学过树链剖分 博客设置基础定义 LCT是一种解决动态树问题的方法，由tarjan~~(为什么又是他)~~在1982年提出，最原始的论文在这里,在论文中，tarjan除了介绍了均摊复杂度为O(log2n)O(log2n)O(log^2n)的LCT之外，还介绍了一种严格O(log2n)O(log2n)O(log^2n)的算法，不过本人太弱了，看不懂ta...
bzoj 4998: 星球联盟
OZY的博客
03-07 372
题意 在遥远的S星系中一共有N个星球，编号为1…N。其中的一些星球决定组成联盟，以方便相互间的交流。但是，组成联盟的首要条件就是交通条件。初始时，在这N个星球间有M条太空隧道。每条太空隧道连接两个星球，使得它们能够相互到达。若两个星球属于同一个联盟，则必须存在一条环形线路经过这两个星球，即两个星球间存在两条没有 公共隧道的路径。为了壮大联盟的队伍，这些星球将建设P条新的太空隧道。这P条新隧道将...
LCT学习总结
gankinghand的博客
08-11 318
并不打算详细讲，别人的博客已经讲得非常好了。 FlashHu的blog 正题 实链剖分与树剖类似，将某一儿子的连边设为实边，其余的设为虚边，关键在于虚实是可以改变的，因此要用splay来搞。注意LCT维护对象是森林。 access access之后记得update，而且access之后x不一定是splay的根 rotate 因为这是lct所以我们的splay变得有些不一样了。 void rotat...
LCT介绍
WJSZMRX
07-07 1192
偶然看到了LCT,发现好多东西都忘了，今天就来写写LCT总结吧。 LCT=link-cut-tree 在树链剖分里我们把树按dfs序换成连续序列，再来解决树上两点间路径操作的问题。很明显，假如树的结构变了，那么原来的树链剖分就GG了。为了解决可以增边的问题我们引进LCT。 LCT的基本思想就是把树链剖分里的重块都存到一颗splay里，以splay的灵活性来解决删边加边的问题（无论原图怎么删都得
Problem C: 星球联盟（并查集+lca）
clover_hxy的博客
11-17 731
Problem C: 星球联盟 Time Limit: 4 Sec  Memory Limit: 256 MB Submit: 58  Solved: 16 [Submit][Status][Web Board] Description 在遥远的S星系中一共有N个星球，编号为1…N。其中的一些星球决定组成联盟，以方便相互间的交流。但是，组成 联盟的首要条件就是交通条件。初始
LCT应用
生活不易，多才多艺
06-12 369
LCT，就是一个拥有link、cut……诸多操作的高级数据结构了吧 这么高级的数据结构，应用有很多啦 维护链的信息 这个就是最基本的操作了，就和平横数一样该维护什么维护什么就好啦 bzoj2002: [Hnoi2010]Bounce 弹飞绵羊 维护下个数吧 ...
NOI级别的超强数据结构——Link-cut-tree（动态树）学习小记
热门推荐
qq_36551189的博客
01-24 1万+
前言 　　其实LCT这种东西，我去年就接触过并且打过，只不过一直没调出来。最近优化了我那又丑又长的splay打法，并且用LCT切了道题。在此做一个小结。 简介 　　如果有一道题，让我们维护一棵树，支持以下操作： 　　1.链上求和； 　　2.链上求最值； 　　3.链上修改； 　　4.子树修改； 　　5.子树求和； 　　6.换根。 　　这道题用树链剖分就可以切掉了。 　　但如...
计算机的术语中lcT,技术|模拟 Altair 8800 计算机
weixin_42497828的博客
07-08 677
Altair 8800 是 1975 年发布的自建家用电脑套件。Altair 基本上是第一台个人电脑(PC)，虽然 PC 这个名词好几年前就出现了。对 Dell、HP 或者 Macbook 而言它是亚当(或者夏娃)。有些人认为为 Z80(与 Altair 的 Intel 8080 密切相关的处理器)编写仿真器真是太棒了，并认为它需要一个模拟 Altair 的控制面板。所以如果你想知道 1975 年...
lct动态维护最小生成树
最新发布
08-05
要动态维护最小生成树，可以使用以下算法： 1. 初始化：开始时，将最小生成树设置为一个空集合。 2. 添加边：当有新的边添加到图中时，检查该边是否会形成环路。如果形成环路，则舍弃该边；否则，将该边加入最小生成树。 3. 删除边：当一条边被删除时，检查最小生成树是否仍然连通。如果不连通，则需要找到一条新的边来连接两个不连通的部分，使得最小生成树仍然有效。 4. 更新权重：当一条边的权重发生变化时，需要重新计算最小生成树。可以使用Kruskal或Prim算法来重新构建最小生成树。 这些步骤可以在实际应用中进行优化，例如使用并查集来判断是否形成环路，使用堆来快速找到新的边等。通过动态维护最小生成树，可以在图的结构发生变化时快速更新最小生成树，以保持其有效性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FSYo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值