牛客练习赛 58 ： F XOR TREE（LCT | 树链剖分）

最新推荐文章于 2021-08-09 10:52:36 发布

ACM败犬

最新推荐文章于 2021-08-09 10:52:36 发布

阅读量171

点赞数

文章标签： LCT 树剖

本文链接：https://blog.csdn.net/qq_41997978/article/details/104565961

版权

在这里插入图片描述

很水的题，这个题和南昌邀请赛的网络赛有点像，只不过放到了树上，把路径拉直，在数组上打表找规律可以发现路径长度（节点个数）为偶数时，每个点都有贡献，否则只有距离起点（x 或 y 任意一个）为偶数的点有贡献。

放到树上可以直接树剖，维护一下链上深度为奇数和深度为偶数的区间异或值，这题也可以拿来练 LCT（~~然后就练了两个小时~~）

在 LCT 上同样可以用类似树剖的方法，用 LCT 维护有根树，在有根树做，每次把路径分成三段，分别异或上三段的贡献即可，特判一下 lca，略为麻烦。

考虑正经的 LCT 做法，不求 LCA，支持换根，这样对于路径 $x, y$ 可以很方便的提出来而不用求 LCA。

考虑每个节点维护这条链以顶端为起点， $o d d [x]$ 表示奇数位置的异或和， $e v e n [x]$ 表示偶数位置的异或和，每个节点再维护一个 $s z$ 表示节点个数，这样路径的长度就是 $s z [x]$ ，很方便。

考虑pushup，由于是一定要这条链的顶端为起点，对左子树的 $s z$ 分类讨论一下即可：
如果 sz[ls] 是奇数，则表明 $x$ 在偶数位置，even[x] = even[ls] ^ val[x] ^ even[rs]，odd[x] = odd[ls] ^ odd[rs]
如果 sz[ls] 是偶数，则表明 $x$ 在奇数位置，even[x] = even[ls] ^ odd[rs]，odd[x] = odd[ls] ^ val[x] ^ even[rs]

	inline void pushup(int x) {
		if (x) {
			sz[x] = sz[ls] + sz[rs] + 1;
			even[x] = 0, odd[x] = val[x];
			if (sz[ls] % 2 == 0) {		//x在奇数位置 
				even[x] = even[ls] ^ odd[rs];
				odd[x] = odd[ls] ^ val[x] ^ even[rs];
			} else {					//x在偶数位置 
				even[x] = even[ls] ^ val[x] ^ even[rs];
				odd[x] = odd[ls] ^ odd[rs];
			}	
		}
	}

由于要支持换根，肯定要用到 move_to_root 操作，那么交换左右子树后 $e v e n [x]$ 和 $o d d [x]$ 该如何维护？

move_to_root 的过程就是把 $x$ 到根的链打通并旋到根，然后交换 $x$ 的儿子，在原图的树上本来以 $r t$ （换根前的树根）为起点维护的 $e v e n [x], o d d [x]$ 现在变成了以 $x$ 为起点，也就是倒过来，稍微思考一下会发现只有当一条链的长度为偶数时，以两端为起点维护的 $e v e n [x], o d d [x]$ 正好相反，而一条链的长度为奇数时，维护的 $e v e n [x] ， o d d [x]$ 贡献的位置是不变的。

于是就可以在换根和 pushdown 时特判一下，当 $s z [x]$ 为偶数时交换 $e v e n [x], o d d [x]$ 。

	void pushdown(int x) {
		if (tag[x]) {
			if (ls) {
				tag[ls] ^= 1;
				swap(ch[ls][0],ch[ls][1]);
				if (sz[ls] % 2 == 0)
					swap(even[ls],odd[ls]);
			}
			if (rs) {
				tag[rs] ^= 1;
				swap(ch[rs][0],ch[rs][1]);
				if (sz[rs] % 2 == 0)
					swap(odd[rs],even[rs]);
			}
			tag[x] = 0;
		}
	}
	inline void move_to_root(int x) {
		access(x); splay(x); 
		tag[x] ^= 1; 
		swap(ch[x][0],ch[x][1]);
		if (sz[x] % 2 == 0) swap(even[x],odd[x]);
	}

考虑查询，将两个点打通到一条链上，根据 $s z [x]$ 的奇偶返回不同的信息，当 $s z [x]$ 为偶数时，返回 even[x]^odd[x]，否则只返回 even[x]

具体代码：

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define I inline void
const int maxn = 1e6 + 10;
typedef long long ll;
int n,m,q,cnt;
inline int read(){
    int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}
struct Graph {
	int head[maxn],nxt[maxn << 1],to[maxn << 1],cnt;
	void init() {
		memset(head,-1,sizeof head);
		cnt = 0;
	}
	void add(int u,int v) {
		to[cnt] = v;
		nxt[cnt] = head[u];
		head[u] = cnt++;
		to[cnt] = u;
		nxt[cnt] = head[v];
		head[v] = cnt++;
	}
}G;
int dep[maxn],p[maxn][20];
struct LCT {						//用splay维护原森林的连通，用到了splay的操作以及数组 
	#define ls ch[x][0]
	#define rs ch[x][1]
	#define inf 0x3f3f3f3f
	int ch[maxn][2];				//ch[u][0] 表示 左二子，ch[u][1] 表示右儿子
	int f[maxn];					//当前节点的父节点 
	int tag[maxn];					//翻转标记，乘标记，加标记 
	int top,sta[maxn],sz[maxn];
	int odd[maxn],even[maxn],val[maxn];
	inline bool get(int x) {
    	return ch[f[x]][1] == x;
	}
	inline void pushup(int x) {
		if (x) {
			sz[x] = sz[ls] + sz[rs] + 1;
			even[x] = 0, odd[x] = val[x];
			if (sz[ls] % 2 == 0) {		//x在奇数位置 
				even[x] = even[ls] ^ odd[rs];
				odd[x] = odd[ls] ^ val[x] ^ even[rs];
			} else {					//x在偶数位置 
				even[x] = even[ls] ^ val[x] ^ even[rs];
				odd[x] = odd[ls] ^ odd[rs];
			}	
		}
	}
	void pushdown(int x) {
		if (tag[x]) {
			if (ls) {
				tag[ls] ^= 1;
				swap(ch[ls][0],ch[ls][1]);
				if (sz[ls] % 2 == 0)
					swap(even[ls],odd[ls]);
			}
			if (rs) {
				tag[rs] ^= 1;
				swap(ch[rs][0],ch[rs][1]);
				if (sz[rs] % 2 == 0)
					swap(odd[rs],even[rs]);
			}
			tag[x] = 0;
		}
	}
	inline bool isroot(int x) {
		return (ch[f[x]][0] != x) && (ch[f[x]][1] != x);
	}
 	inline void rotate(int x) {							//旋转操作，根据 x 在 f[x] 的哪一侧进行左旋和右旋 
	    int old = f[x], oldf = f[old];
		int whichx = get(x);
		if(!isroot(old)) ch[oldf][ch[oldf][1] == old] = x;		//如果 old 不是根节点，就要修改 oldf 的子节点信息
	    ch[old][whichx] = ch[x][whichx ^ 1];
	    ch[x][whichx ^ 1] = old;
	    f[ch[old][whichx]] = old;
	    f[old] = x; f[x] = oldf;
		pushup(old); pushup(x); 
	}
	inline void splay(int x) {								//将 x 旋到所在 splay 的根
		top = 0; sta[++top] = x;
		for (int i = x; !isroot(i); i = f[i]) sta[++top] = f[i];
		for (int i = top; i >= 1; i--) pushdown(sta[i]);
    	for(int fa = f[x]; !isroot(x); rotate(x), fa = f[x]) {	//再把x翻上来
        	if(!isroot(fa))										//如果fa非根，且x 和 fa是同一侧，那么先翻转fa，否则先翻转x 
            	rotate((get(x) == get(fa)) ? fa : x);
        }
	}
	inline void access(int x) {					//access操作将x 到 根路径上的边修改为重边 
		int lst = 0;
		while(x > 0) {
			splay(x);
			rs = lst;
			pushup(x);
			lst = x; x = f[x];
		}
	}
	inline int findroot(int x) {
		access(x); 
		splay(x); 
		int rt = x;
		while(ch[rt][0]) rt = ch[rt][0];
		return rt;
	}
	inline void move_to_root(int x) {
		access(x); splay(x); 
		tag[x] ^= 1; 
		swap(ch[x][0],ch[x][1]);
		if (sz[x] % 2 == 0) swap(even[x],odd[x]);
	}
	inline void split(int x,int y) {
		move_to_root(x); access(y); splay(y);
	}
	inline void link(int x,int y) {
		move_to_root(x); splay(y);
		f[x] = y; splay(x);						
	}
	inline int qry(int x,int y) {
		split(x,y);
		if (sz[y] & 1) return even[y];
		else return even[y] ^ odd[y];
	}
}tree;
int op,id,x,y,u,v,w;
int main() {
	n = read(); q = read();
	for (int i = 1; i <= n; i++) {
		tree.odd[i] = tree.val[i] = read();
		tree.sz[i] = 1;
	}
	for (int i = 1; i < n; i++) {
		u = read(); v = read();
		tree.link(u,v);
	} 	
	while (q--) {
		op = read(); x = read(); y = read();
		if (op == 1) {
			tree.access(x);
			tree.splay(x);
			tree.val[x] = y;
			tree.pushup(x);
		} else {
			tree.split(x,y);
			printf("%d\n",tree.qry(x,y));
		}
	}
	return 0;
}

ACM败犬

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
牛客练习赛 58 ： F XOR TREE（LCT | 树链剖分）

很水的题，这个题和南昌邀请赛的网络赛有点像，只不过放到了树上，把路径拉直，在数组上打表找规律可以发现路径长度（节点个数）为偶数时，每个点都有贡献，否则只有距离起点（x 或 y 任意一个）为偶数的点有贡献。放到树上可以直接树剖，维护一下链上深度为奇数和深度为偶数的区间异或值，这题也可以拿来练 LCT（然后就练了两个小时）在 LCT 上同样可以用类似树剖的方法，用 LCT 维护有根树，在...
复制链接

扫一扫