线段树合并部分总结

最新推荐文章于 2024-09-19 15:50:58 发布
最新推荐文章于 2024-09-19 15:50:58 发布
阅读量1.9k 收藏 3
点赞数 1
分类专栏： 个人反思
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keydou/article/details/83691189
版权

昨天看了半天动态开点，写了主席树复习笔记，今天来搞搞线段树合并，也回应一下昨天的话

线段树合并总结与题目处理

注释：按照惯例，本篇为复习笔记，对于对动态开点，甚至是merge的中文意思都不知道的dalao，请自动回溯，我帮你（return）；

首先吧，作用类分析QAQ

  1. 线段树合并一般用于对子树的统计,一般的套路就是对树的每一个节点都开上一颗动态开点线段树,然后统计子树信息时,合并所有儿子信息,统计答案,然后继续向上走;

其实本质上就是把两棵线段树合起来，所以合并合并，怎么合是个问题QWQQWQ；
如果是原型的线段树，对于合并后的树操作会。。发现之前的状态全没了。。而线段树合并问题一般都为状态持久化问题。。或者就是在树上处理左右子树，然后在合并左右子树的一个过程，比如刷线段树合并必刷的这题T1后面会给题解，如果后期有时间会写思路

然后吧，建树过程QWQ

  1. 昨天好像说过了吧。。和主席树一模一样，具体可以参考我的主席树博客。。主席树
    首先在这里不再推荐build操作，当然如果你想，我不会拦你（大佬自动忽略）
int build(int l,int r){
   int now=++cnt; sum[now]=0;
   if (l<r) {
   	L[now]=build(l,mid);
   	R[now]=build(mid+1,r);
   }
   return now;
}

这里如果用build的话，，怎么说呢，，，没问题，，，总之，，，，我就是不喜欢用QWQQWQ
然后继续套树

int change(int l,int r,int las,int t){
	int now=++cnt; sum[now]=sum[las]+1;
	L[now]=L[las]; R[now]=R[las]; 
	if (l<r){
		if (t<=mid) L[now]=change(l,mid,L[las],t);
		else R[now]=change(mid+1,r,R[las],t);
	}
	return now;
}

这里的放数，基本模板依然相同。。不对，，，要改改,就是这里一般是初始化操作，，，
一般在代码中是这样修改数据就是直接__++__操作。 就OK了。。

下面我在放放我最常用的数组型线段树建立
贴下代码

void update(int &now,int l,int r,int pla){
    if (!now) now=++cnt; tree[now].num++;
    if (l==r) return;
    if (pla<=mid) update(tree[now].lc,l,mid,pla);else update(tree[now].rc,mid+1,r,pla);
}

其实和主席树里的，，一模一样。。我是真没话说了。。

下面呢，才是最重要的，，MERGE，，中文线段树合并QJQ

首先这是一般模板

int rebuild(int x,int y){
	if(x==y) return x;
	if (x==0) return y;
	if (y==0) return x;
	sum[x]+=sum[y]; l[x]=rebuild(l[x],l[y]); r[x]=rebuild(r[x],r[y]);
	if (!r[x]) fa[x]=fa[l[x]]; else fa[x]=fa[r[x]];
	return x;
}

可以简化一下就是将函数的int类型改为void类型

void rebuild(int &x,int y){
	if(x==y) return;
	if (!x||!y) {x+=y; return; } 
	sum[x]+=sum[y]; rebuild(l[x],l[y]); rebuild(r[x],r[y]);
	if (!r[x]) fa[x]=fa[l[x]]; else fa[x]=fa[r[x]];
}

这里主要思路就是把右子树全部并到左子树上并返回合并后树的编号。。就这样。。
当然模板终究是模板，这里就有特例
是T1就是上面提到的，，，

void merge(int &lc,int rc){
    if (!lc||!rc) {lc+=rc; return;}
    tree[lc].num+=tree[rc].num;
    ans1+=1ll*tree[tree[lc].rc].num*tree[tree[rc].lc].num;
    ans2+=1ll*tree[tree[lc].lc].num*tree[tree[rc].rc].num;
    merge(tree[lc].lc,tree[rc].lc); merge(tree[lc].rc,tree[rc].rc);}

可以看到。。中间多了一些东西，那是应题目需要搞得东西，，所以不能只背模板哎哎哎。
但是总体上都是相同的，八九不离十。。恩恩就这样

当然只有少数题目会想这题可以一边合并一边统计答案并输出，，，

所以

搜树 ？QUQ

int search(int x,int y){
	if (sum[x]<y) return -1; 
	if (sum[x]==y) return fa[x];
	if (sum[l[x]]<y) return search(r[x],y-sum[l[x]]);
	else return search(l[x],y);  
}

熟悉不，熟悉不，
不熟悉？请出门左转不送，我帮你 return（order） <order==go out then turn left>
这就是正常的主席树查询。。。正常到不想讲，，，，

书写答案，请把你的答案工工整整的用cout/printf/write()/io.write 输出来吧！！QYQ

下面是题目时间，有时间来补坑，，，

  1. 永无乡
    总体思路为爆搜，爆搜，，，你说可能吗。。。。

是冰茶几+线段树合并。了啦

#include<bits/stdc++.h>
using namespace std;
int n,m,cnt,w[2000000],sum[2000000],l[5000000],r[2000000],fa[2300000],fid[2000000];
void add(int xxx,int ll,int rr,int xx,int yy){
	if (ll==rr) {
		sum[xxx]++; 
		fa[xxx]=yy;
		return; 
	}
	int mid=(ll+rr)>>1; 
	if (xx<=mid) {
	if (!l[xxx])l[xxx]=++cnt;
		add(l[xxx],ll,mid,xx,yy);
	}
	else {
	if (!r[xxx]) r[xxx]=++cnt;
		add(r[xxx],mid+1,rr,xx,yy);}
	sum[xxx]=sum[l[xxx]]+sum[r[xxx]]; 
	if (!r[xxx]) fa[xxx]=fa[l[xxx]]; else fa[xxx]=fa[r[xxx]];
}
int find(int x){
	return (x==fid[x])?x:fid[x]=find(fid[x]);}
int rebuild(int x,int y){
	if(x==y) return x;
	if (x==0) return y;
	if (y==0) return x;
	sum[x]+=sum[y]; l[x]=rebuild(l[x],l[y]); r[x]=rebuild(r[x],r[y]);
	if (!r[x]) fa[x]=fa[l[x]]; else fa[x]=fa[r[x]];
	return x;
}
int search(int x,int y){
	if (sum[x]<y) return -1; 
	if (sum[x]==y) return fa[x];
	if (sum[l[x]]<y) return search(r[x],y-sum[l[x]]);
	else return search(l[x],y);  
}
int main(){
	cin>>n>>m; cnt=n;
	for(int i=1; i<=n; ++i) cin>>w[i],add(i,1,n,w[i],i),fid[i]=i; 	
	for(int i=1; i<=m; ++i) {
		int x,y;  cin>>x>>y; x=find(x); y=find(y); fid[x]=fid[y]=rebuild(x,y);}
	int T;cin>>T;
	while (T--) {
		char c; cin>>c; if (c=='Q') {
			int x,y; cin>>x>>y;x=find(x); cout<<search(x,y)<<endl;}
		else {
			int x,y; cin>>x>>y; x=find(x); y=find(y); fid[x]=fid[y]=rebuild(x,y); 
		}
	}
}
  1. P3521 [POI2011]ROT-Tree Rotations
    这题就是就是逆序对思想，有点巧妙。。还有线段树合并
#include<bits/stdc++.h>
#define REP(i,a,b) for(int i(a);i<=(b);++i)
#define mid ((l+r)>>1)
using namespace std;
long long smin(long long  x,long long y){return (x>y)?y:x;}
int n,cnt; long long ans1,ans2,ans;
struct node{int num,lc,rc;}tree[15000010];
void read(int &x){
	x=0; char c=getchar(); int f=1; for(;!isdigit(c);c=getchar()) if (c=='-') f=-f;
	for(;isdigit(c);c=getchar()) x=x*10+c-'0'; x*=f;}
void pushup(int now){
    tree[now].num=tree[tree[now].lc].num+tree[tree[now].rc].num;}
void update(int &now,int l,int r,int pla){
    if (!now) now=++cnt; tree[now].num++;
    if (l==r) return;
    if (pla<=mid) update(tree[now].lc,l,mid,pla);else update(tree[now].rc,mid+1,r,pla);
}
void merge(int &lc,int rc){
    if (!lc||!rc) {lc+=rc; return;}
    tree[lc].num+=tree[rc].num;
    ans1+=1ll*tree[tree[lc].rc].num*tree[tree[rc].lc].num;
    ans2+=1ll*tree[tree[lc].lc].num*tree[tree[rc].rc].num;
    merge(tree[lc].lc,tree[rc].lc); merge(tree[lc].rc,tree[rc].rc);}
void dfs(int &x){ 
    int now; x=0; read(now); int lc=0,rc=0;
    if (!now){
        dfs(lc); dfs(rc);  ans1=0,ans2=0; 
        x=lc,merge(x,rc); ans+=smin(ans1,ans2);}
    else update(x,1,n,now); }
void solve(){ int hehe=0;
    read(n);dfs(hehe); printf("%lld",ans);}
int main(){
    solve();}

P3605 [USACO17JAN]Promotion Counting晋升者计数

#include<bits/stdc++.h>
#define REP(i,a,b) for(register int i(a);i<=(b);++i)
#define mid ((l+r)>>1)
#define ll(a) (a<<1)
#define rr(a) (a<<1|1)
using namespace std;
int n,m,b[1000000],Ans[2000000],cnt,head[1000000],tre[4000000];
struct node{int num,pla;}a[4000000];
bool cmp(node a,node b) {return a.num<b.num;}
struct mode{int head;int next;}tree[5000000];
void addeag(int x,int y){++cnt;tree[cnt].head=head[x]; tree[cnt].next=y;head[x]=cnt;}
void rebuild(int xx,int l,int r,int now){
	if (l>xx||r<xx) return; if (l==xx&&r==xx) {tre[now]++; return; }
	rebuild(xx,l,mid,(now<<1));rebuild(xx,mid+1,r,(now<<1|1)); 
	tre[now]=tre[(now<<1)]+tre[(now<<1|1)];}
int search(int xx,int yy,int l,int r,int now){
	if (l>yy||r<xx) return 0; 
	if (l>=xx&&r<=yy) return tre[now]; int ans=0;  //cout<<now<<endl;
	ans+=search(xx,yy,l,mid,(now<<1)); ans+=search(xx,yy,mid+1,r,(now<<1|1));return ans;}
void let_dfs(int x){
	int FINAL=search(b[x]+1,n,1,n,1); 
	for(int i=head[x];i;i=tree[i].head){
		int y=tree[i].next; let_dfs(y); } 
	Ans[x]=search(b[x]+1,n,1,n,1)-FINAL;
	rebuild(b[x],1,n,1);}
int main(){
	std::ios::sync_with_stdio(false);cin>>n;
	for(int i=1; i<=n; ++i) cin>>a[i].num,a[i].pla=i;
	sort(a,a+n+1,cmp); for(int i=1; i<=n; ++i) b[a[i].pla]=i;
	REP(i,2,n) {int x;cin>>x;addeag(x,i);}
	let_dfs(1);REP(i,1,n) cout<<Ans[i]<<endl;
}

好了就这样
· THE END

keydou
关注
专栏目录
线段树小总结
01-02
一种常见的方法是将循环数组展开为两个非循环数组，然后在两个数组上分别构建线段树，通过合并两个查询结果来得到最终答案。 #### 总结 通过上述几个例子可以看出，线段树在解决区间问题时非常有效，尤其是在需要...
线段树合并
Cauchy的博客
05-21 3513
文章目录前置芝士线段树合并概念merge题目描述输入格式输出格式代码 前置芝士 权值线段树 动态开点线段树 线段树合并的全称为动态开点权值线段树合并 加个链接 线段树合并 概念 顾名思义，就是建立一棵新的线段树保存原有的两颗线段树的信息。 merge 线段树合并所完成的操作就是：在相同区间内，对应位置相加。 合并方式主要如下：两个相同区间的节点 p{p}p 和 q{q}q，合并区间 [l,r]{[l,r]}[l,r]。 若 p{p}p 和 q{q}q 有一者为 0{0}0，则另一者为根。 若 l=
算法笔记-线段树合并
m0_53899788的博客
06-04 1150
线段树合并
【学习笔记】线段树分裂
最新发布
Brute♂force
09-19 1217
有就应该有线段树分裂。它是线段树合并的逆过程。具体的，你需要以权值线段树中第 k 小的数为分界线，把线段树分成两半。
【YBT2023寒假Day6 C】子串染色（SAM）（线段树）（启发式合并）
欢迎您的光顾awa
02-07 536
对于一个 s 的子串 t，把它在 s 中所有出现的位置包含的所有下标染黑，黑色连续段的数目是子串 t 的价值。 然后给你一个 k 和一个串 s，求有多少个 s 的子串价值恰好为 k。
线段树的合并_黄嘉泰.pptx
09-14
总结来说，线段树是一种强大的数据结构，它能够有效地处理区间查询和更新的问题，尤其是在需要合并多棵树的情况下，通过精心设计的合并算法，可以实现高效的操作。在实际编程挑战和算法竞赛中，熟练掌握线段树的使用...
线段树 入门 总结 Interval Tree
06-18
### 线段树入门级总结 #### 一、初识线段树 ##### 1、线段树的称谓及意义 线段树（Interval Tree），顾名思义，是一种基于区间的特殊数据结构。它能够高效地解决涉及区间查询和修改的问题，尤其适用于动态查询或...
线段树及其应用（刘汝佳）
04-19
总结来说，线段树是一种强大的数据结构，能够高效地处理动态区间统计问题，其核心在于合理设计附加信息和维护算法，以及利用线段树的结构特性进行区间分解。通过灵活应用这些概念，我们可以解决各种复杂的问题，如...
线段树的资料 线段树的学习
04-02
总结来说，线段树是一种高效的数据结构，用于处理与区间相关的问题，如动态合并线段、查询覆盖信息等。通过巧妙地组织数据和附加信息，线段树可以在O(logN)的时间复杂度内完成查询和更新操作，远优于简单的线性搜索...
线段树合并复杂度证明
xyyxyyx的博客
12-11 962
摘抄自 styx的博客 假如初始所有的线段树点数总和为 NNN 。因为只要合并两个节点，节点总个数就会少掉一个，所以复杂度应该是 O(N)O(N)O(N) 的。 所以不是所有情况下的线段树合并都是 O(nlog⁡n)O(n \log n)O(nlogn) 的。 一般情况下我们只会对每个节点开动态开一条链，所以 N=nlog⁡nN=n\log nN=nlogn ，复杂度才会是 O(nlog⁡n)O(...
关于线段树分裂合并的复杂度
Gbaki的博客
04-25 389
考虑如下操作：初始有n个只有单点的线段树，进行m次线段树分裂和若干次线段树合并，最后只剩一个线段树。
【学习笔记】线段树合并
Brute♂force
09-15 1121
一般来说，线段树会有On个节点。但是有的时候，整棵线段树就只进行了一次插入操作，这样只会有Ologn个节点。处理树上问题时，我们有时需要把儿子的信息合并到父亲节点。这个时候可以使用，常数小，但复杂度多一个log。或者，我们也可以使用线段树合并。
关于线段树合并
m0_57344422的博客
08-14 429
线段树合并
线段树 & 线段树合并优化 DP
RabbieWjy的博客
05-19 788
线段树 & 线段树合并优化 DP 补充了之前动态规划优化课件中的线段树优化部分（？）
线段树合并学习笔记
Rabilista的博客
07-06 141
定义其实就是字面意思，就是将两棵线段树合并在一起，至于我们为什么要合并，我们可以先可以看道例题。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值