【校内模拟】Growing（树哈希）（SBT）（LCT维护轻重链剖分）

最新推荐文章于 2023-03-28 17:08:28 发布
最新推荐文章于 2023-03-28 17:08:28 发布
阅读量343 收藏
点赞数
分类专栏： LCT 平衡树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxyoi_dreamer/article/details/102710565
版权

简要题意：

给一棵有根树，强制在线，支持动态加叶子，询问一个子树的自同构变换个数。

题解：

一句话题解：SBT+封装双哈希+原根倒base+LCT维护三个标记

顺便说一下，博主并不清楚有没有什么离线处理方式

以前确实没有见过LCT拿来维护轻重链剖分这种东西的。。。（LCT维护的东西一般称为虚实链剖分）

首先考虑一个显然的暴力，维护树哈希，然后每次加叶子暴力跳所有父亲并修改哈希值，就可以直接维护答案了。

我们发现并不能暴力维护，复杂度显然假完了。

考虑一下答案的表示式，设 c n t [ p ] cnt[p] cnt[p]表示子树中哈希值为 p p p的有多少个， t r [ p ] tr[p] tr[p]表示以 p p p为根的子树内部的自同构变换个数，则 u u u的计算式就是 ∏ c n t [ p ] ! ∏ v ∈ s o n ( u ) t r [ v ] \prod cnt[p]!\prod_{v\in son(u)}tr[v] ∏cnt[p]!∏v∈son(u)​tr[v]

感觉还是没法做啊。。。。

定义重儿子为 s i z [ v ] ∗ 2 ≥ s i z [ u ] siz[v]*2\geq siz[u] siz[v]∗2≥siz[u]的孩子 v v v。

显然每个点要么没有重儿子，要么只有一个重儿子，并且重儿子一定不和任何一个其他子树同构。

用LCT维护一条重链，显然如果我们在链中间某个点改了答案，显然只会一路改上去，并且由于出现次数都是1次，改的就只有 t r [ u ] tr[u] tr[u]部分，相当于整条链点的答案乘上一个值。

注意到我们从任何一片叶子开始跳父亲，最多只会跳 O ( log ⁡ n ) O(\log n) O(logn)条轻边。

在这些地方暴力修改即可。

那么问题就只剩下如何维护树哈希值。

由于我们能够保证重儿子只出现了一次，那么直接考虑普通的排序+模质数的进制哈希。

由于要维护排序，所以用一个支持单点插入，单点删除，计数的平衡树即可，直接用SBT即可。

然后把重儿子放到序列的开头算哈希值即可。

为了降低冲突概率，双哈希+base使用原根即可。

进一步降低冲突概率，每一层用不同的原根即可。

当然这些就是细节了。不清楚有没有卡，不写这些应该6K内能写完。

下面的代码不到7.5K 其实是7.49K

代码：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define cs const

namespace IO{
	inline char gc(){
		static cs int Rlen=1<<22|1;
		static char buf[Rlen],*p1,*p2;
		return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,Rlen,stdin),p1==p2)?EOF:*p1++;
	}
	
	template<typename T>
	inline T get(){
		char c;T num;
		while(!isdigit(c=gc()));num=c^48;
		while(isdigit(c=gc()))num=(num+(num<<2)<<1)+(c^48);
		return num;
	}
	inline int gi(){return get<int>();}
}
using namespace IO;

using std::cerr;
using std::cout;
#define fi first
#define se second

static cs int M1=1e9+7,M2=1e9+9;
static std::mt19937 R(0);
static int get_gr(cs int M){
	int phi=M-1;std::vector<int> p;
	for(int re i=2;i*i<=phi;++i)
	if(phi%i==0){
		p.push_back(i);
		while(phi%i==0)phi/=i;
	}
	if(phi>1)p.push_back(phi);phi=M-1;
	auto power=[&](int a,int b)->int{
		int r=1;for(;b;b>>=1,a=(ll)a*a%M)
		(b&1)&&(r=(ll)r*a%M);return r;
	};
	for(int re gr=2;;++gr){
		bool flag=true;
		for(int t:p)if(power(gr,phi/t)==1)
		{flag=false;break;}if(flag)return gr;
	}
}
static cs int g1=get_gr(M1),g2=get_gr(M2);
static int gen(int M,int g){
	auto power=[&](int a,int b)->int{
		int r=1;for(;b;b>>=1,a=(ll)a*a%M)
		(b&1)&&(r=(ll)r*a%M);return r;
	};
	while(true){int c=R()%(M-2)+1;
		if(std::__gcd(c,M-1)==1)
		return power(g,c);
	}
}
class Key{
	private:
		int x,y;
	public:
		Key(){}Key(int _x,int _y):x(_x),y(_y){}
		friend Key operator+(cs Key &a,cs Key &b){return Key((a.x+b.x)%M1,(a.y+b.y)%M2);}
		friend Key operator-(cs Key &a,cs Key &b){return Key((a.x-b.x+M1)%M1,(a.y-b.y+M2)%M2);}
		friend Key operator*(cs Key &a,cs Key &b){return Key((ll)a.x*b.x%M1,(ll)a.y*b.y%M2);}
		friend Key &operator+=(Key &a,cs Key &b){return a=a+b;}
		friend Key &operator-=(Key &a,cs Key &b){return a=a-b;}
		friend Key &operator*=(Key &a,cs Key &b){return a=a*b;}
		friend bool operator<(cs Key &a,cs Key &b){return a.x<b.x||(a.x==b.x&&a.y<b.y);}
		friend bool operator<=(cs Key &a,cs Key &b){return a.x<b.x||(a.x<=b.x&&a.y<=b.y);}
		friend bool operator==(cs Key &a,cs Key &b){return a.x==b.x&&a.y==b.y;}
		friend bool operator!=(cs Key &a,cs Key &b){return a.x!=b.x||a.y!=b.y;}
};
Key Random(){return Key(gen(M1,g1),gen(M2,g2));} 
cs Key key0(0,0),key1(1,1),keyt(233,233); 

cs int N=3e5+7;

namespace SBT{
	int lc[N],rc[N],siz[N];
	cs double alpha=0.55;
	Key prod[N],base[N],h[N];
	std::pair<Key,int> vl[N];
	inline void pushup(int u){
		siz[u]=siz[lc[u]]+siz[rc[u]]+1;
		prod[u]=key1;h[u]=key0;
		if(lc[u]){
			h[u]+=h[lc[u]];
			prod[u]*=prod[lc[u]];
		}
		h[u]+=vl[u].fi*prod[u];
		prod[u]*=base[u];
		if(rc[u]){
			h[u]+=h[rc[u]]*prod[u];
			prod[u]*=prod[rc[u]];
		}
	}
	inline void Zig(int &u){
		int v=lc[u];lc[u]=rc[v],rc[v]=u;
		pushup(u),pushup(v),u=v;
	}
	inline void Zag(int &u){
		int v=rc[u];rc[u]=lc[v],lc[v]=u;
		pushup(u),pushup(v),u=v;
	}
	
	inline void ins(int &u,int v){
		if(!u)return pushup(u=v);
		if(vl[v]<vl[u]){
			ins(lc[u],v);pushup(u);
			if(siz[lc[u]]>siz[u]*alpha)Zig(u);
		}else {
			ins(rc[u],v);pushup(u);
			if(siz[rc[u]]>siz[u]*alpha)Zag(u);
		}
	}
	
	inline void del(int &u,int v){
		if(!u)return ;
		if(u==v){
			if(!lc[u]||!rc[u]){
				u=lc[u]|rc[u];
				lc[v]=rc[v]=0;
				siz[v]=1;
			}
			else if(siz[rc[u]]>siz[lc[u]]){
				Zag(u),del(lc[u],v);
			}
			else {
				Zig(u),del(rc[u],v);
			}
			if(u)pushup(u);
			return ;
		}
		(vl[v]<vl[u])?del(lc[u],v):del(rc[u],v);pushup(u);
	}
	
	inline int count(int u,cs Key &val,int t=0){
		if(!u)return 0;
		if(vl[u].fi==val){
			return 1+(t==1?siz[lc[u]]:count(lc[u],val,2))
				+(t==2?siz[rc[u]]:count(rc[u],val,1)); 
		}
		if(val<vl[u].fi)return count(lc[u],val,t);
		else return count(rc[u],val,t);
	}
}

cs int mod=998244353;
inline int mul(int a,int b){ll r=(ll)a*b;return r>=mod?r%mod:r;} 
inline void Mul(int &a,int b){a=mul(a,b);}
inline int power(int a,int b){
	int r=1;for(;b;b>>=1,a=mul(a,a))
	(b&1)&&(r=mul(r,a));return r;
}

int d[N],son[N],inv[N],rt[N],mxd;
Key Base[N],dBase[N],rec[N];

inline int Ins(int u,int v,cs Key &h){
	SBT::base[v]=Base[u];
	SBT::vl[v]=std::make_pair(h,v);
	SBT::pushup(v);rec[v]=h;
	int cnt=SBT::count(rt[u],h);
	SBT::ins(rt[u],v);return cnt+1;
}
inline int Del(int u,int v){
	int cnt=SBT::count(rt[u],rec[v]);
	SBT::del(rt[u],v);return inv[cnt];
}
inline int modify(int u,int v,cs Key &newh){
	int res=Del(u,v);return mul(res,Ins(u,v,newh));
}

namespace LCT{
	int son[N][2],fa[N];
	Key h[N],htag[N];
	Key coef[N],prod[N];
	int siz[N],stag[N];
	int ans[N],atag[N];
	inline void init(int u){
		htag[u]=key0;h[u]=keyt;
		stag[u]=0;atag[u]=1;
		siz[u]=ans[u]=1;
		coef[u]=prod[u]=key1;
	}
	inline int &lc(int u){return son[u][0];}
	inline int &rc(int u){return son[u][1];}
	inline void pushup(int u){
		prod[u]=coef[u];
		if(lc(u))prod[u]*=prod[lc(u)];
		if(rc(u))prod[u]*=prod[rc(u)];
	} 
	inline bool isrt(int u){return son[fa[u]][0]!=u&&son[fa[u]][1]!=u;}
	inline bool which(int u){return son[fa[u]][1]==u;}
	inline void Rotate(int u){
		int p=fa[u],pp=fa[p],d=which(u);
		if(!isrt(p))son[pp][which(p)]=u;
		son[p][d]=son[u][!d],fa[son[p][d]]=p;
		son[u][!d]=p,fa[p]=u,fa[u]=pp;
		pushup(p),pushup(u); 
	}
	inline void taghash(int u,Key delta){
		htag[u]+=delta;
		if(rc(u))delta*=prod[rc(u)];
		h[u]+=delta;
	}
	inline void tagans(int u,int delta){
		Mul(atag[u],delta);
		Mul(ans[u],delta);
	}
	inline void tagsiz(int u,int delta){
		siz[u]+=delta;
		stag[u]+=delta;
	}
	inline void pushdown(int u){
		if(htag[u]!=key0){
			if(rc(u))taghash(rc(u),htag[u]),htag[u]*=prod[rc(u)];
			htag[u]*=coef[u];if(lc(u))taghash(lc(u),htag[u]);htag[u]=key0;
		}
		if(stag[u]!=0){
			if(lc(u))tagsiz(lc(u),stag[u]);
			if(rc(u))tagsiz(rc(u),stag[u]);
			stag[u]=0;
		}
		if(atag[u]!=1){
			if(lc(u))tagans(lc(u),atag[u]);
			if(rc(u))tagans(rc(u),atag[u]);
			atag[u]=1;
		}
	}
	int q[N],qn;
	inline void Splay(int u){
		q[qn=1]=u;for(int re p=u;!isrt(p);p=fa[p])q[++qn]=fa[p];
		while(qn)pushdown(q[qn--]);for(int re p;!isrt(u);Rotate(u))
		if(!isrt(p=fa[u]))Rotate(which(u)==which(p)?p:u);
	}
}
using LCT::h;
using LCT::siz;
using LCT::lc;
using LCT::rc;
using LCT::Splay;
using LCT::pushdown;
using LCT::pushup;
using LCT::taghash;
using LCT::tagsiz;
using LCT::tagans; 

int Q,op,ans,pc,n;

inline void updateson(int u,int v,int &ansfac){// v may be the new hson of u 
	pushdown(u);rc(u)=0;pushup(u);tagsiz(u,1);
	int delta=modify(u,v,h[v]);
	if(son[u]){
		int w=son[u];Splay(w);
		if(siz[w]*2<siz[u]){
			Mul(delta,Ins(u,w,h[w]));
			son[u]=0;
		}
	}
	if(siz[v]*2>=siz[u]){
		son[u]=v;Mul(delta,Del(u,v));
	}
	Mul(ansfac,delta);
	tagans(u,ansfac);
	Key newh=key0;
	if(rt[u])newh=SBT::h[rt[u]]*Base[u]*Base[u];
	if(son[u]){
		int w=son[u];Splay(w);
		newh+=h[w]*Base[u];
	}
	Key deltah=newh-h[u];
	taghash(u,deltah);pushdown(u);
	if(son[u]){
		int w=son[u];Splay(w);
		LCT::coef[w]=Base[u];
		pushup(w);pushdown(u);
		rc(u)=w;pushup(u);
	}
}

inline void update(int u,int ansfac){
	int p=u;while(Splay(u),p=LCT::fa[u]){
		while(lc(u))u=lc(u);
		Splay(u),Splay(p);
		updateson(p,u,ansfac);
		u=p;
	}
}

inline void Addnode(){
	int p=gi();if(op)p=(p+ans)%n+1;
	LCT::init(++n);d[n]=d[p]+1;
	if(d[n]>mxd)mxd=d[n],dBase[mxd]=Random();
	Base[n]=dBase[d[n]];LCT::fa[n]=p;
	int ansfac=Ins(p,n,LCT::h[n]);
	update(n,ansfac);
}

inline void Query(){
	int u=gi();if(op)u=(u+ans)%n+1;
	Splay(u);cout<<(ans=LCT::ans[u])<<"\n";
	pc=0;for(int re tmp=ans;tmp;tmp&=tmp-1)++pc;
}

signed main(){
#ifdef zxyoi
	freopen("growing.in","r",stdin);
#endif
	Q=gi(),op=gi();
	inv[0]=inv[1]=1;for(int re i=2;i<=Q;++i)inv[i]=mul(inv[mod%i],mod-mod/i);
	n=1,LCT::init(1);Base[1]=dBase[0]=Random();
	while(Q--){
		int tp=gi();if(op)tp=(tp+pc)&1;
		switch(tp){
			case 0:Addnode();break;
			case 1:Query();break;
		}
	}
	return 0;
}
zxyoi_dreamer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS模拟实现哈希表及应用详解
10-18
在JavaScript中，我们可以通过模拟实现哈希表来优化数据处理效率，尤其是在处理大量数据时。以下是对JS模拟实现哈希表及其应用的详细说明。 首先，了解一些与哈希表相关的基础知识点： 1. **属性的枚举**：在...
哈希查找树
05-29
在计算机科学中，哈希表是通过哈希函数将键映射到数组索引的数据结构，而哈希查找树则是为了解决哈希冲突而设计的，通常采用平衡树（如AVL树、红黑树）来存储哈希后的键值对。 哈希函数是哈希查找树的核心，它的...
哈希树简介
最新发布
Dablelv 的博客专栏。
03-28 2948
哈希树（Hash Tree），在密码学及计算机科学中是一种树形数据结构，每个叶节点均以数据块的哈希作为标签，而除了叶节点以外的节点则以其子节点标签的加密哈希作为标签。哈希树能够高效、安全地验证大型数据结构的内容，是哈希链的推广形式。哈希树的概念由瑞夫·墨克于 1979 年申请专利，故亦称墨克树（Merkle tree）。
哈希树 (HashTree)
gcs的博客
08-26 6354
在讲hash树之前首先我们来理解一下质数分辨定理。 什么是质数分辨定理？ 什么是质数 ： 即只能被 1 和 本身 整除的数。 为什么用质数：因为N个不同的质数可以 ”辨别“ 的连续整数的数量，与这些质数的乘积相同。 百度文库解答：https://wenku.baidu.com/view/16b2c7abd1f34693daef3e58.html 也就是说如果有21亿个数字的话，我们查找的哪怕是最底...
$LCT$维护子树信息学习笔记
weixin_30483495的博客
01-31 133
\(LCT\)维护子树信息学习笔记 昨天\(FDF\)好题分享投了 \([ZJOI2018]\)历史 这题。 然后我顺势学学这个姿势。 结果调了一年。。。于是写个笔记记录一下。 基本原理 比较显然地，虽然父子关系在不断变化，但是重链与重链之间的连接是不变的。换句话说，一个点的某个虚儿子也许并不是他在原树中的某个儿子，但是这个点总和上来的信息是这整棵子树的。 所以我们定义这个点总和的信息（记为\(...
HDU 3966 Aragorn's Story（树链剖分）题解
weixin_30412577的博客
07-18 71
题意：给一棵树，要求你对一个路径上的值进行加减，查询某个点的值 思路：重链剖分。 由于分了轻重儿子，我每次到重儿子的top只要O(1)，经过的轻儿子最多logn条，那么我每次往上跳最多跳logn次。 所以总的路径可以分为：dfn[top[u]]到dfn[u]组成的完整路径，每次更新完走向fa[top[u]]防止重复操作。 参考：某大哥博客 代码： #include<...
[FZOJ195] 「2019冬令营提高组」树（树哈希+DP计数）
lunch__的博客
02-26 285
题意 给你一个n\rm nn个点的树A，一个m\rm mm个点的树B，求A树有多少个不同的生成子图与B同构。（n≤2000,m≤12\rm n \le 2000,m\le12n≤2000,m≤12） 我们首先可以枚举B树是哪个点作为根，B树同构的情况只能算一次，有一个DP就是设f(i,j)f(i,j)f(i,j)表示A树上点iii与B树上点jjj匹配的方案数。我们每次遍历A树的时候多记一个g(...
人名查询哈希表设计（链地址法）
07-03
哈希函数用除留余数法构造，用线性探测再散列法或链地址法处理冲突。 测试数据 取读者周围较熟悉的30个人名。 选作内容 （1） 从教科书上介绍的集中哈希函数构造方法中选出适用者并设计几个不同的哈希函数，比较...
hash_tree_linux.rar_Hash lin_b+tree_hash tree_哈希树
09-22
在IT领域，哈希树（Hash Tree）是一种数据结构，常用于存储和验证大量数据的完整性，尤其是在分布式系统和区块链技术中。哈希树结合了哈希函数和树状结构的特点，提供了一种高效且安全的数据校验方式。标题中的"Hash...
P2486 [SDOI2011]染色（LCT维护树链信息，LCT维护树链染色）
qq_41997978的博客
02-16 414
这题树形没有改变，实际上用不着LCT，用树剖就行。 考虑树剖轻重链剖分的做法：将树按轻重链剖分后，建线段树，线段树的每个节点维护对应区间的左端点颜色，右端点颜色，以及答案。 两个区间合并时，更新区间的左端点颜色和右端点颜色，大区间的答案等于两个子区间的答案相加，若两个区间的交接处颜色相同，则答案需要减一。 查询时，由于会在树上跳 log 次，每一次查询的结果要和上一次查询的结果进行合并。 LC...
LCT 动态树（实链剖分）
qq_42852687的博客
03-15 1090
动态树（LCT）
【校内模拟】树（树哈希）（状压DP）
zxyoi_dreamer的博客（不定期诈尸）
08-29 142
题解： 和ZJOI2018线图里面的处理方式一样。 找到重心，以重心为根。然后对于每一个子树哈希一下。 接下来就很简单了，我们直接枚举A树里面的每一个点和B树的根匹配，然后状压DP算一下孩子的匹配方案数。 复杂度有一个显然的上界是O(nm32m2)O(nm^32^{\frac{m}{2}})O(nm322m​)，但是里面有两个mmm和2m22^{\frac{m}{2}}22m​是远远到不了的，目前...
[树哈希] 树哈希学习笔记
Antimonysbguy的博客
08-06 639
一千个读者，就有一千个哈姆雷特 一千个OIer，就有几千种哈希方法 哈希当然都是不完美的，很容易被Hack 多哈希几次呢？（比如质数不同，哈希方式不同） 树哈希 树哈希的毒瘤方法 显然我们需要让儿子有序 否则子树就被加上了有序性 HHH表示哈希值 rkrkrk表示节点在父亲子树中的排名 sss是一个种子 ppp是质数 法一 Hu=sizu×∑v∈sonuHv×srkv H_u=siz_u\times \sum_{v\in son_u}H_{v}\times s^{rk_v} Hu​=sizu​×v∈sonu
【BJOI2015】【BZOJ4337】树的同构
CreationAugust is 14 years old forever
01-22 1340
Description树是一种很常见的数据结构。 我们把N个点，N-1条边的连通无向图称为树。 若将某个点作为根，从根开始遍历，则其它的点都有一个前驱，这个树就成为有根树。 对于两个树T1和T2，如果能够把树T1的所有点重新标号，使得树T1和树T2完全相 同，那么这两个树是同构的。也就是说，它们具有相同的形态。 现在，给你M个有根树，请你把它们按同构关系分成若干个等价类。 Input第一
哈希树
majiakun1的专栏
08-30 482
我们选择质数分辨算法来建立一棵哈希树。 选择从2开始的连续质数来建立一个十层的哈希树。第一层结点为根结点，根结点下有2个结点；第二层的每个结点下有3个结点；依此类推，即每层结点的子节点数目为连续的质数。到第十层，每个结点下有29个结点。如下图所示： 同一结点中的子结点，从左到右代表不同的余数结果。 例如：第二层结点下有三个子节点。那么从左到右分别代表：除3余0，除3余1，除3
LCT动态树学习小记
ZLTJohn的博客
03-03 976
总起之前一直不怎么会LCT，然后THUWC的时候····看着知道怎么写就是不会打····所以就学一发，顺便搞了搞其他的数据结构。介绍Link-cut Tree即动态树，能够解决很多动态树问题，而且树的结构变化多端。 LCT跟树链剖分有很像的地方，它也要维护重链，也有类似的轻边。用splay，要分清splay和原图的边。 具体的，splay的关键字是点的深度，左边深度小。如何记录这条重链顶端的父亲
LCT动态树学习笔记--基本操作（带详细注释）
caoyang1123的博客
07-15 593
一些LCT最基本也是最核心的操作，其他一些维护树链信息的可以直接参照树链剖分。 #include<bits/stdc++.h> using namespace std; namespace LCT{ struct gg{ int ch[2],fa; bool rev; }node[10010]; void init() {for(int i=0;i<=1000...
啊哈 树链剖分——重链剖分（之后学完splay就搞虚实链剖分）
permi_yaxileni的博客
08-17 186
阿巴阿巴阿巴。。。。后续会加splay+虚实链剖分 学习博客：https://blog.csdn.net/qq_43326267/article/details/89791152 讲挺好的（我还自信的考） 其实不难的就是把之前学的东西糅合一下 其实就是把一个树通过重链放成一排，然后线段树维护，对于一条重链（对应线段树部分为连续区间），可以直接区间修改（查询）,不同重链可以通过跳链头来到同一条链 性质：每个点都在某条重链上，且不会出现某个点在两条重链上 定义： 重儿子：子树节点最多的儿子 重链
Aragorn's Story HDU - 3966 轻重链剖分
asdjibaidjas的博客
04-22 121
Aragorn’s Story HDU - 3966 题解：老套路了，轻重链剖分线段树维护 #include <iostream> #include <cstdio> #include <algorithm> #include <memory.h> #define mid ((l+r)>>1) using namespace std; c...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值