树上莫队算法

最新推荐文章于 2025-04-06 11:57:23 发布
原创 最新推荐文章于 2025-04-06 11:57:23 发布 · 1w 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

这篇博客介绍了树上莫队算法，通过将树分块并利用DFS时间戳，解决树上两点间路径上不同点权计数的问题。时间复杂度为O(nsqrt(n))。文章引用了SPOJ COT2题目，并提到在处理区间转移时的困难，提及了wyfcyx和vfk的博客作为参考。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

继续回来写博客……记录点有意思的题目什么的。

貌似写过这个的没多少人……所以我也记录一点。

首先序列上的莫队大家都应该很熟悉了……

那么树上的莫队要怎么搞呢？

先来看个题目……SPOJ COT2：求树上两点间路径上有多少个不同的点权。

序列上的莫队是把询问按照左端点分块了……可是树上没有左端点，怎么办呢？我们把树分块。

按照DFS时间戳顺序，将树分成O(sqrt(n))个大小为O(sqrt(n))的块，那么树上的莫队询问排序的第一关键字就是第一个节点所在的块了！

这样分块以后，任意两个块之间的距离也是O(sqrt(n))级别的，所以时间复杂度是有保证的。

第二个关键字自然就是节点的DFS时间戳了！

但是，还有一个问题。树上的区间要怎么转移呢？要怎么从一个区间变到另一个区间呢？

这就有些难了，因为树上有LCA，貌似不好处理。

Orz了wyfcyx后，找到了vfk的博客看了一下。


“

用S(v, u)代表 v到u的路径上的结点的集合。
用root来代表根结点，用lca(v, u)来代表v、u的最近公共祖先。
那么
S(v, u) = S(root, v) xor S(root, u) xor lca(v, u)
其中xor是集合的对称差。
简单来说就是节点出现两次消掉。
lca很讨厌，于是再定义
T(v, u) = S(root, v) xor S(root, u)
观察将curV移动到targetV前后T(curV, curU)变化：
T(curV, curU) = S(root, curV) xor S(root, curU)
T(targetV, curU) = S(root, targetV) xor S(root, curU)
取对称差：
T(curV, curU) xor T(targetV, curU)= (S(root, curV) xor S(root, curU)) xor (S(root, targetV) xor S(root, curU))
由于对称差的交换律、结合律：
T(curV, curU) xor T(targetV, curU)= S(root, curV) xorS(root, targetV)
两边同时xor T(curV, curU)：
T(targetV, curU)= T(curV, curU) xor S(root, curV) xor S(root, targetV)
发现最后两项很爽……哇哈哈
T(targetV, curU)= T(curV, curU) xor T(curV, targetV)
（有公式恐惧症的不要走啊 T_T）
也就是说，更新的时候，xor T(curV, targetV)就行了。
即，对curV到targetV路径(除开lca(curV, targetV))上的结点，将它们的存在性取反即可。
”
——vfk博客

这样就很好处理了，只要把LCA扔出去，考虑剩下的部分，转移一下就可以了。查答案的时候再把LCA那个点反过来，就能统计出答案了。

这样，类比序列上的莫队，我们对树上的询问也可以分块了，时间复杂度同样是O(nsqrt(n))。

BZOJ 3757貌似是同一个题，就贴这个代码吧……COT2没写……SPOJ上怕T……

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
#include<vector>
#include<cmath>
using namespace std;
inline int getint()
{
	char c=getchar();
	int con=0;
	while(c<'0'||c>'9') c=getchar();
	while(c>='0'&&c<='9') con=con*10+c-'0',c=getchar();
	return con;
}
const int MAXN=100010;
int n,m,K,lca,u,v,c[MAXN],dfn[MAXN],belongn[MAXN];
int tot,root,dfs_clock,remain;
int head[MAXN],to[MAXN],next[MAXN],cnt;
int anc[MAXN][21],dep[MAXN],Log[MAXN];
int Stack[MAXN],top;
int p[MAXN],ans,con[MAXN];
bool used[MAXN];
struct Query
{
	int u,v,a,b,sub;
	friend bool operator<(const Query &i,const Query &j)
	{
		if(belongn[i.u]==belongn[j.u]) return dfn[i.v]<dfn[j.v];
		else return belongn[i.u]<belongn[j.u];
	}
}Q[MAXN];
inline void adde(int f,int t)
{
	cnt++,to[cnt]=t,next[cnt]=head[f],head[f]=cnt;
	cnt++,to[cnt]=f,next[cnt]=head[t],head[t]=cnt;
}
int DFS(int x)
{
	int size=0;
	dfn[x]=++dfs_clock;
	for(int i=head[x];i;i=next[i])
		if(to[i]!=anc[x][0])
		{
			dep[to[i]]=dep[x]+1,anc[to[i]][0]=x;
			size+=DFS(to[i]);
			if(size>=K)
			{
				tot++;
				for(int i=1;i<=size;i++)
					belongn[Stack[top--]]=tot;
				size=0;
			}
		}
	Stack[++top]=x;
	return size+1;
}
int LCA(int p,int q)
{
	if(dep[p]<dep[q]) swap(p,q);
	int d=dep[p]-dep[q];
	for(int i=Log[d];i>=0;i--)
		if(d&(1<<i)) p=anc[p][i];
	for(int i=Log[n];i>=0;i--)
		if(anc[p][i]!=anc[q][i]) p=anc[p][i],q=anc[q][i];
	if(p!=q) return anc[p][0];
	else return p;
}
void work(int u,int v,int lca)
{
	while(u!=lca)
	{
		if(!used[u]) {p[c[u]]++,used[u]=true;if(p[c[u]]==1) ans++;}
		else {p[c[u]]--,used[u]=false;if(p[c[u]]==0) ans--;}
		u=anc[u][0];
	}
	while(v!=lca)
	{
		if(!used[v]) {p[c[v]]++,used[v]=true;if(p[c[v]]==1) ans++;}
		else {p[c[v]]--,used[v]=false;if(p[c[v]]==0) ans--;}
		v=anc[v][0];
	}
}
int main()
{
	//freopen("apple.in","r",stdin);
	//freopen("apple.out","w",stdout);
	n=getint(),m=getint();
	K=(int)sqrt(n);
	for(int i=1;i<=n;i++) c[i]=getint();
	for(int i=1;i<=n;i++)
	{
		u=getint(),v=getint();
		if(u==0) root=v;
		else if(v==0) root=u;
		else adde(u,v);
	}
	for(int i=1;i<=m;i++)
	{
		Q[i].u=getint(),Q[i].v=getint();
		Q[i].a=getint(),Q[i].b=getint();
		Q[i].sub=i;
	}
	remain=DFS(root);
	for(int i=1;i<=remain;i++) belongn[Stack[top--]]=tot;
	sort(Q+1,Q+m+1);
	Log[0]=-1;
	for(int i=1;i<=n;i++) Log[i]=Log[i>>1]+1;
	for(int i=1;i<=Log[n];i++)
		for(int j=1;j<=n;j++)
			anc[j][i]=anc[anc[j][i-1]][i-1];
	work(Q[1].u,Q[1].v,lca=LCA(Q[1].u,Q[1].v));
	if(!used[lca]) {p[c[lca]]++,used[lca]=true;if(p[c[lca]]==1) ans++;}
	else {p[c[lca]]--,used[lca]=false;if(p[c[lca]]==0) ans--;}
	con[Q[1].sub]=ans;
	if(p[Q[1].a]!=0&&p[Q[1].b]!=0) con[Q[1].sub]--;
	if(!used[lca]) {p[c[lca]]++,used[lca]=true;if(p[c[lca]]==1) ans++;}
	else {p[c[lca]]--,used[lca]=false;if(p[c[lca]]==0) ans--;}
	for(int i=2;i<=m;i++)
	{
		work(Q[i-1].u,Q[i].u,LCA(Q[i-1].u,Q[i].u));
		work(Q[i-1].v,Q[i].v,LCA(Q[i-1].v,Q[i].v));
		lca=LCA(Q[i].u,Q[i].v);
		if(!used[lca]) {p[c[lca]]++,used[lca]=true;if(p[c[lca]]==1) ans++;}
		else {p[c[lca]]--,used[lca]=false;if(p[c[lca]]==0) ans--;}
		con[Q[i].sub]=ans;
		if(p[Q[i].a]!=0&&p[Q[i].b]!=0&&Q[i].a!=Q[i].b) con[Q[i].sub]--;
		if(!used[lca]) {p[c[lca]]++,used[lca]=true;if(p[c[lca]]==1) ans++;}
		else {p[c[lca]]--,used[lca]=false;if(p[c[lca]]==0) ans--;}
	}
	for(int i=1;i<=m;i++) printf("%d\n",con[i]);
	return 0;
}
感觉好神啊……vfk的那个方法确实好用，这个算法也好有趣。

（未完待续……）

WC2013 糖果公园 待填坑

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
#include<vector>
#include<cmath>
using namespace std;
typedef long long LL;
const int MAXN=300010;
int n,m,u,v,Q,K,Type,C[MAXN],Ctmp[MAXN];
LL V[MAXN],W[MAXN],ans,con[MAXN];
int head[MAXN],to[MAXN],next[MAXN],cnt;
int belongn[MAXN],tot,remain;
int anc[MAXN][20],dep[MAXN],Log[MAXN];
int Stack[MAXN],top;
int Qtot,Ctot,Query_clock=1;
int p[MAXN],lca;
bool used[MAXN];
struct QQ
{
	int x,y,t,id;
	friend bool operator<(const QQ &i,const QQ &j)
	{
		if(belongn[i.x]<belongn[j.x]) return true;
		else if(belongn[i.x]==belongn[j.x]&&belongn[i.y]<belongn[j.y]) return true;
		else if(belongn[i.x]==belongn[j.x]&&belongn[i.y]==belongn[j.y]&&i.t<j.t) return true;
		return false;
	}
}Query[MAXN];
struct CC{int pos,x,y;}Change[MAXN];
inline void adde(int f,int t)
{
	cnt++,to[cnt]=t,next[cnt]=head[f],head[f]=cnt;
	cnt++,to[cnt]=f,next[cnt]=head[t],head[t]=cnt;
}
int DFS(int x)
{
	int size=0;
	for(int i=head[x];i;i=next[i])
		if(to[i]!=anc[x][0])
		{
			anc[to[i]][0]=x;
			dep[to[i]]=dep[x]+1;
			size+=DFS(to[i]);
			if(size>=K)
			{
				tot++;
				for(int i=1;i<=size;i++) belongn[Stack[top--]]=tot;
				size=0;
			}
		}
	Stack[++top]=x;
	return size+1;
}
int LCA(int p,int q)
{
	if(dep[p]<dep[q]) swap(p,q);
	int d=dep[p]-dep[q];
	for(int i=Log[d];i>=0;i--)
		if(d&(1<<i)) p=anc[p][i];
	for(int i=Log[n];i>=0;i--)
		if(anc[p][i]!=anc[q][i]) p=anc[p][i],q=anc[q][i];
	if(p!=q) return anc[p][0];
	return p;
}
void Reverse(int x)
{
	if(!used[x]) p[C[x]]++,ans+=V[C[x]]*W[p[C[x]]];
	else ans-=V[C[x]]*W[p[C[x]]],p[C[x]]--;
	used[x]^=1;
}
void ChangeVer(int x,int d)
{
	int pos=Change[x].pos;
	if(d==1)
	{
		if(used[pos]) Reverse(pos),C[pos]=Change[x].y,Reverse(pos);
		else C[pos]=Change[x].y;
	}
	else
	{
		if(used[pos]) Reverse(pos),C[pos]=Change[x].x,Reverse(pos);
		else C[pos]=Change[x].x;
	}
}
void work(int x,int y,int lca)
{
	while(x!=lca) Reverse(x),x=anc[x][0];
	while(y!=lca) Reverse(y),y=anc[y][0];
}
int main()
{
	scanf("%d%d%d",&n,&m,&Q);
	K=(int)pow((double)n,2.0/3);
	for(int i=1;i<=m;i++) scanf("%lld",&V[i]);
	for(int i=1;i<=n;i++) scanf("%lld",&W[i]);
	for(int i=1;i<n;i++) scanf("%d%d",&u,&v),adde(u,v);
	for(int i=1;i<=n;i++) scanf("%d",&C[i]),Ctmp[i]=C[i];
	for(int i=1;i<=Q;i++)
	{
		scanf("%d%d%d",&Type,&u,&v);
		if(Type==0)
		{
			Ctot++,Query_clock++;
			Change[Ctot].pos=u,Change[Ctot].x=Ctmp[u],Change[Ctot].y=v;
			Ctmp[u]=v;
		}
		else
		{
			Qtot++;
			Query[Qtot].x=u,Query[Qtot].y=v,Query[Qtot].t=Query_clock;
			Query[Qtot].id=Qtot;
		}
	}
	remain=DFS(1);
	for(int i=1;i<=remain;i++) belongn[Stack[top--]]=tot;
	sort(Query+1,Query+Qtot+1);
	Log[0]=-1;
	for(int i=1;i<=n;i++) Log[i]=Log[i>>1]+1;
	for(int i=1;i<=Log[n];i++)
		for(int j=1;j<=n;j++)
			anc[j][i]=anc[anc[j][i-1]][i-1];
	work(Query[1].x,Query[1].y,lca=LCA(Query[1].x,Query[1].y));
	for(int i=1;i<Query[1].t;i++) ChangeVer(i,1);
	Reverse(lca),con[Query[1].id]=ans,Reverse(lca);
	for(int i=2;i<=Qtot;i++)
	{
		work(Query[i-1].x,Query[i].x,LCA(Query[i-1].x,Query[i].x));
		work(Query[i-1].y,Query[i].y,LCA(Query[i-1].y,Query[i].y));
		for(int j=Query[i-1].t;j<Query[i].t;j++) ChangeVer(j,1);
		for(int j=Query[i-1].t-1;j>=Query[i].t;j--) ChangeVer(j,-1);
		lca=LCA(Query[i].x,Query[i].y);
		Reverse(lca),con[Query[i].id]=ans,Reverse(lca);
	}
	for(int i=1;i<=Qtot;i++) printf("%lld\n",con[i]);
	return 0;
}


莫队算法完整总结（普通莫队、带修莫队、树上莫队、回滚莫队）
lucius-liu.cn
09-05 3131
普通莫队、带修改莫队、树上带修改莫队、回滚莫队
莫队算法 （普通莫队、带修莫队、树上莫队）
Josh_Shu_的博客
11-15 850
莫队算法
树上 分块 莫队 题型小结 加 题集
Brassica_的菜园
09-26 772
前言最近接触到了树分块（大三才接触到了QAQ），然后打算总结下……普通莫队算法简单回顾一下普通的莫队算法，莫队算法是用来解决区间询问的算法，其把区间分成n√\sqrt n份，每份的大小是n√\sqrt n。把所有询问按其左端点所在区间为第一关键字，右端点按第二关键字排序，然后依次移动左右指针，处理相关询问。算法的时间复杂度在于当前区间的左右指针移动。左指针每次只会在块内移动，复杂度为O(q∗n√)O
树上莫队
weixin_30882895的博客
09-07 148
在之前我已经发过了普通莫队的博客了。 传送门 打了几道莫队的裸题后，我就学了一下树上莫队。 例题 这题的英文超好懂，我相信你的英语...
[学习笔记]树上莫队
weixin_34220963的博客
03-24 291
远古博客：莫队算法——暴力出奇迹 https://blog.youkuaiyun.com/u012061345/article/details/54093879 树上莫队也就一句话： 把树上路径用欧拉序（入栈出栈序）变成区间，区间莫队即可 思想就是利用遍历构造出路径，入栈出栈相互抵消处理多余的点。 多了细节和讨论： 1.某个点存在一次贡献为1，存在两次贡献为0， 2.莫队的l，r要通过是否...
【算法笔记】莫队算法（基础莫队，带修莫队，回滚莫队，树上莫队，二次离线莫队）
繁凡さん的博客
11-23 7173
来这里学习莫队以及神奇的证明：莫队算法 --算法竞赛专题解析（26） 我们首先考虑双指针的暴力法，发现很容易就会被卡成O(nm)O(nm)O(nm)，这时候我们的莫队出现了，莫队说，我可以像变魔术一样，把O(nm)O(nm)O(nm)的算法通过一个神奇的排序方式，使得我们最坏的情况下，时间复杂度也会非常优秀：O(nn)O(n\sqrt{n})O(nn​)。 莫队算法是一个离线的算法，我们先将所有的询问全部存下来，然后排序。我们的每一个询问都是一个左右区间，(l,r)(l ,r)(l,r) 我们的排序方法为双
小学生都可以听懂的——莫队算法
最新发布
2403_87858277的博客
04-06 1055
莫队算法的知识点讲解，快来看看吧qwq，看完之后记得点赞哦！
树上莫队算法学习
平凡人Kalzn的博客
11-08 229
题目链接 学习树上莫队算法，首先了解一下欧拉序。 欧拉序 对于一颗树，我们遍历的时候，我们第一次经过时，把该点加入序列，回溯时再加一遍，形成欧拉序。 例如： 这棵树的欧拉序就是：1,2,3,6,6,4,4,5,5,3,7,7,2,1 我们就在这个序列上进行莫队 对于一个区间：如果该点出现且仅出现一次。那我们计算时就要计算这个点。否则不计算。 对于每次查询（x，y），我们先有以下操作： scanf...
「日常训练&知识学习」莫队算法（二）：树上莫队（Count on a tree II，SPOJ COT2）...
weixin_30235225的博客
11-13 217
题意与分析 题意是这样的，给定一颗节点有权值的树，然后给若干个询问，每次询问让你找出一条链上有多少个不同权值。 写这题之前要参看我的三个blog：Codeforces Round #326 Div. 2 E（树上利用倍增求LCA）、Codeforces Round #340 Div. 2 E（朴素莫队）和BZOJ-1086（树的分块），然后再看这几个Blog—— 参考A：https://blog....
SPOJ COT2 树上的莫队算法，树上区间查询
写东西的地方
08-17 2200
题意：n个节点形成的一棵树。每个节点有一个值。m次查询，求出(u,v)路径上出现了多少个不同的数。 树上的莫队算法，同样将树分成siz=sqrt(n)块，然后离线操作。先对树dfs一遍，每当子树节点个数num>=siz，就将这num个分成一块。读取所有的查询按左端点所在块排序。 重点在于怎么进行区间转移，对路径的lca特殊处理，参考博客http://blog.youkuaiyun.com/kuribohg
莫队算法（普通，带修，回滚，树上）
zixiangzhan的博客
03-22 1753
这是用来复习的博客，不太建议想要初学普通莫队的人看这篇博客，不过要是想快速复习一遍，这个博客可能比较适合你。 莫队算法（普通，带修，回滚） 莫队算法是一种通过对询问多关键字排序来降低时间复杂度的算法，当一些可离线题目满足 一个询问[l,r]的答案可以由[l-1,r]/[l+1,r]/[l,r-1]/[l,r+1]更新得到 时，可以考虑莫队算法。普通莫队不支持修改，不过如果是简单的修改可以用带修莫队/回滚莫队解决，至于树上问题则需要引入树上莫队，这里不做介绍（因为我也不会……）。实现简洁，应用面大，非常值得一
莫队算法学习笔记（三）——树上莫队
weixin_30274627的博客
11-28 232
前言 树上莫队的核心思想，就是将一棵树转化成一个序列，然后用普通莫队来搞。 初始化 以一棵树为例： 要想对这棵树进行树上莫队，我们第一步就是用一个\(s\)数组把它的括号序存下来： \(id\) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 \(s\) 1 2 4 7 8 8 7 4 5 5 2 3 6 6 3 1​ 同时，我们用\(I\)数组...
树上莫队（随意看看）
Coco_T的博客
01-04 747
莫队的简单介绍 今天我们简单的来看一下长在树上的莫队 要说莫队是一个很暴力，很高效的算法 考场上的暴力乱搞佳品 网上有国际友人的blog，不过需要一点英语知识（或者是google翻译） 最简单的不修改线性莫队 莫队重点就在于分块（这可是精髓） 一般的，我们就分成sqrt(n)块 struct node{ int x,y,block; }; node Q[N]; in
【模版】莫队（带修改莫队、树上莫队）算法
LH_991215的博客
07-07 1861
莫队算法 莫队算法是 离线 解决 区间查询 问题的一种高效暴力算法。 前置知识点：①①①分块 ②②② sortsortsort关键字排序 ③③③ lcalcalca查询(树上莫队) 时间复杂度：O(n∗n)O(n*\sqrt{n})O(n∗n​) 空间复杂度：O(n∗n)O(n*\sqrt{n})O(n∗n​) 算法流程： 一、确定分块大小：每块大小为 n\sqrt{n}n​ 。确定每个元素属于哪一块。 二、用结构体存储询问并用 sortsortsort 排序： 对于每次询问的 左端点 lll，按照 .
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值