Segment Tree——线段树入门

已于 2022-10-12 21:27:51 修改
阅读量372 收藏
点赞数 2
分类专栏： 数据结构 文章标签： 算法 c++ 数据结构
于 2022-05-16 22:24:18 首次发布
;
本文链接：https://blog.csdn.net/m0_60630928/article/details/124808864
版权
本文深入探讨线段树这一数据结构，包括基础操作如建树、单点修改和区间查询，以及进阶应用如延迟操作、区间乘法、扫描线算法和主席树。通过实例展示了线段树在统计、最大数、方差计算、数值序列操作等场景中的高效解决方案。
摘要由CSDN通过智能技术生成

文章目录

基础操作

线段树是一种基于分治思想的二叉树结构，用于在区间上进行统计。每个节点代表一个区间，对于每个内部节点[l,r]（编号p），左子节点代表区间[l,mid]（编号2p），右子节点代表区间[mid+1,r]（编号2p+1）.可以用结构体数组保存一棵线段树，数组大小开到N*4
在这里插入图片描述

P2068 统计和

P2068 统计和

定义线段树

struct segment_tree
{
	int l,r;
	long long sum;
}tree[100010*4];

建树

void build(int p,int l,int r)
{
	tree[p].l=l,tree[p].r=r,tree[p].sum=0;
	if(l==r) return;//到达根节点 
	int mid=(l+r)/2;
	build(p*2,l,mid);//左子树 
	build(p*2+1,mid+1,r);//右子树 
}

单点修改

void change(int p,int x,int v)
{
	if(tree[p].l==tree[p].r)//到达对应单点（左右端点值都为x） 
	{
		tree[p].sum+=v;//修改 
		return;
	}
	int mid=(tree[p].l+tree[p].r)/2;
	if(x<=mid) change(p*2,x,v);//单点在左子树 
	else change(p*2+1,x,v);//单点在右子树 
	tree[p].sum=(tree[p*2].sum+tree[p*2+1].sum);//合并 
}

区间查询

假设当前询问的区间为[l,r]
递归到一个区间[tl,tr]时,有四种情况：

  1. l < = t l < = t r < = r l<=tl<=tr<=r l<=tl<=tr<=r,该区间被完全覆盖在询问区间内，直接返回[tr,tl]上的和；
  2. t l < = l < = t r < = r tl<=l<=tr<=r tl<=l<=tr<=r,当前区间的右边一部分在询问区间内，判断l与mid=(tr+tl)/2的大小关系，若l>mid，只需递归右子树，否则需要递归左右子树（右子树会在递归后直接返回）
  3. l < = t l < = r < = t r l<=tl<=r<=tr l<=tl<=r<=tr,参考上一条
  4. t r < = l < = r < = t r tr<=l<=r<=tr tr<=l<=r<=tr，递归左右子树
long long ask(int p,int l,int r)
{
    if(l<=tree[p].l&&r>=tree[p].r) 
		return tree[p].sum;//如果整个区间被覆盖，就返回维护的值
    int mid=(tree[p].l+tree[p].r)>>1;
    long long ans=0;
    if(l<=mid) ans+=ask(p*2,l,r);
    if(r>mid) ans+=ask(p*2+1,l,r);//累加答案，返回左右儿子的和
    return ans;
}

完整代码

#include<bits/stdc++.h>
using namespace std;

struct segment_tree
{
	int l,r;
	long long sum;
}tree[100010*4];

void build(int p,int l,int r)
{
	tree[p].l=l,tree[p].r=r,tree[p].sum=0;
	//cout<<"p:"<<p<<" l:"<<l<<" r:"<<r<<endl;
	if(l==r) return;//到达根节点 
	int mid=(l+r)/2;
	build(p*2,l,mid);//左子树 
	build(p*2+1,mid+1,r);//右子树 
}

void change(int p,int x,int v)
{
	if(tree[p].l==tree[p].r)//到达对应单点（左右端点值都为x） 
	{
		tree[p].sum+=v;//修改 
		return;
	}
	int mid=(tree[p].l+tree[p].r)/2;
	if(x<=mid) change(p*2,x,v);//单点在左子树 
	else change(p*2+1,x,v);//单点在右子树 
	tree[p].sum=(tree[p*2].sum+tree[p*2+1].sum);//合并 
}

long long ask(int p,int l,int r)
{
    if(l<=tree[p].l&&r>=tree[p].r) 
		return tree[p].sum;//如果整个区间被覆盖，就返回维护的值
    int mid=(tree[p].l+tree[p].r)>>1;
    long long ans=0;
    if(l<=mid) ans+=ask(p*2,l,r);
    if(r>mid) ans+=ask(p*2+1,l,r);//累加答案，返回左右儿子的和
    return ans;
}
int main()
{
	int n,m;
	scanf("%d %d",&n,&m);
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		char c; int x,y;
		cin>>c>>x>>y;
		if (c=='x') change(1,x,y);//单点修改 
		if (c=='y') printf("%lld\n",ask(1,x,y));//区间查询 
	}
	return 0;
}

P1198 [JSOI2008] 最大数

P1198 [JSOI2008] 最大数

#include<bits/stdc++.h>
using namespace std;

const int N=200010;
int m,mod,now=0;
long long temp;
int t[N*4];

void insert(int p,int l,int r,int x)
{
	if(l==r)
	{
		t[p]=x;
		return;
	}
	int mid=(l+r)>>1;
	if(mid>=now) insert(p*2,l,mid,x);
	if(mid<now) insert(p*2+1,mid+1,r,x);
	t[p]=max(t[p*2],t[p*2+1])%mod;
}

int ask(int p,int l,int r,int ll,int rr)
{
	if(ll<=l&&rr>=r)
		return t[p];
	int mid=(l+r)/2;
	int maxn=-0x3ffffff;
	if(mid>=ll) maxn=max(maxn,ask(p*2,l,mid,ll,rr));
	if(mid<rr) maxn=max(maxn,ask(p*2+1,mid+1,r,ll,rr));
	return maxn;
}

int main()
{
	cin>>m>>mod;
	for(int i=0;i<m;i++)
	{
		char op;
		cin>>op;
		if(op=='A')
		{
			++now;
			int x;
			scanf("%d",&x);
			int a=(x+temp)%mod;
			insert(1,1,m,a);
		}
		if(op=='Q')
		{
			int len;
			scanf("%d",&len);
			if(len==0) temp=0;
			else temp=ask(1,1,m,now-len+1,now)%mod;
			cout<<temp<<'\n';
		}
		//cout<<"now:"<<now<<" temp:"<<temp<<endl;
		//cout<<"t[1].val:"<<t[1]<<"t[2].val:"<<t[2]<<"t[3].val:"<<t[3]<<endl;
	}
    return 0;
}

P1471 方差

P1471 方差

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int n,m;
double a[N];
struct Node
{
	int l,r;
	double sum,total,add;
}tr[N*4];

void pushdown(int u)
{
	tr[u<<1].total+=2*tr[u<<1].sum*tr[u].add+(tr[u<<1].r-tr[u<<1].l+1)*tr[u].add*tr[u].add;
	tr[u<<1].sum+=(tr[u<<1].r-tr[u<<1].l+1)*tr[u].add;
	tr[u<<1].add+=tr[u].add;
	tr[u<<1|1].total+=2*tr[u<<1|1].sum*tr[u].add+(tr[u<<1|1].r-tr[u<<1|1].l+1)*tr[u].add*tr[u].add;
	tr[u<<1|1].sum+=(tr[u<<1|1].r-tr[u<<1|1].l+1)*tr[u].add;
	tr[u<<1|1].add+=tr[u].add;
	tr[u].add=0;
}

void build(int u,int l,int r)
{
	if(l==r)
	{
		tr[u]={l,r,a[l],a[l]*a[l],0};
		return;
	}
	else
	{
		tr[u].l=l,tr[u].r=r;
		int mid=l+r>>1; 
		build(u<<1,l,mid);
		build(u<<1|1,mid+1,r);
		tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
		tr[u].total=tr[u<<1].total+tr[u<<1|1].total;
	}
}

void modify(int u,int l,int r,double v)
{
	if(l<=tr[u].l&&tr[u].r<=r)
	{
		tr[u].total+=2*tr[u].sum*v+(tr[u].r-tr[u].l+1)*v*v;
		tr[u].sum+=(tr[u].r-tr[u].l+1)*v;
		tr[u].add+=v;
	}
	else
	{
		pushdown(u);
		int mid=tr[u].l+tr[u].r>>1;
		if(l<=mid) modify(u<<1,l,r,v); 
		if(r>mid) modify(u<<1|1,l,r,v);
		tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
		tr[u].total=tr[u<<1].total+tr[u<<1|1].total;
	}
}

Node query(int u,int l,int r)
{
	if(l<=tr[u].l&&tr[u].r<=r) return tr[u];
	pushdown(u);
	int mid=tr[u].l+tr[u].r>>1;
	Node res,tmp;
	res.sum=0,res.total=0;
	if(l<=mid) tmp=query(u<<1,l,r),res.total+=tmp.total,res.sum+=tmp.sum;
	if(r>mid) tmp=query(u<<1|1,l,r),res.total+=tmp.total,res.sum+=tmp.sum;
	return res;
}


int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		scanf("%lf",&a[i]);
	memset(tr,0,sizeof(tr));
	build(1,1,n);
	while(m--)
	{
		int op;
		scanf("%d",&op);
		if(op==1)
		{
			int l,r;
			double v;
			scanf("%d%d%lf",&l,&r,&v);
			modify(1,l,r,v);
		}
		else
		{
			int l,r;
			scanf("%d%d",&l,&r);
			Node t1=query(1,l,r);
			double ave=t1.sum*1.0/(r-l+1);
			double s=t1.total*1.0/(r-l+1)-ave*ave;
			//printf("t.total:%.ld t.sum:%ld ave:%.4lf s:%.4lf\n",t2,t1,ave,s);
			if(op==2) printf("%.4lf\n",ave);
			else printf("%.4lf\n",s);	
		}
	}
    return 0;
}

延迟操作

P3372 【模板】线段树 1

P3372 【模板】线段树 1
延迟标记
之前遇到区间修改时可能会遍历区间内的所有数，效率极其低下，有了线段树这种每个结点代表一个区间的数据结构，我们可以在结构体里新增一个变量add，用于储存对区间的增值操作，在未访问到这个区间时，我们可以不用管（这样就省掉了很多无用功233），如果访问到这个区间，就把这个区间对应的sum值加上（add*区间内点数），将add下放到左右两个子树，再将当前节点的add归零。
延迟标记的含义为“该节点曾经被修改，但其子节点尚未被更新”，其本身信息已被修改完毕。

void spread(int p)
{
	if(tree[p].add!=0)
	{
		tree[p*2].sum+=(tree[p*2].r-tree[p*2].l+1)*tree[p].add;=
		tree[p*2+1].sum+=(tree[p*2+1].r-tree[p*2+1].l+1)*tree[p].add;=
		tree[p*2].add+=tree[p].add;
		tree[p*2+1].add+=tree[p].add;
		tree[p].add=0;
	}
}

#include<bits/stdc++.h>
using namespace std;

int n,m,a[100010];

struct segment_tree
{
	int l,r;
	long long sum,add;
}tree[100010*4];

void build(int p,int l,int r)
{
	tree[p].l=l,tree[p].r=r;
	if(l==r)
	{
		tree[p].sum=a[l];
		return;
	}
	int mid=(l+r)/2;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	tree[p].sum=tree[p*2].sum+tree[p*2+1].sum;
}

void spread(int p)
{
	if(tree[p].add!=0)
	{
		tree[p*2].sum+=(tree[p*2].r-tree[p*2].l+1)*tree[p].add;=
		tree[p*2+1].sum+=(tree[p*2+1].r-tree[p*2+1].l+1)*tree[p].add;=
		tree[p*2].add+=tree[p].add;
		tree[p*2+1].add+=tree[p].add;
		tree[p].add=0;
	}
}

void change(int p,int l,int r,int x)
{
	if(l<=tree[p].l&&r>=tree[p].r)
	{
		tree[p].sum+=(long long)x*(tree[p].r-tree[p].l+1);
		tree[p].add+=x;
		return;
	}
	spread(p);//延迟标记
	int mid=(tree[p].l+tree[p].r)/2;
	if(l<=mid) change(p*2,l,r,x);
	if(r>mid) change(p*2+1,l,r,x);
	tree[p].sum=tree[p*2].sum+tree[p*2+1].sum;
}

long long ask(int p,int l,int r)
{
    if(l<=tree[p].l && r>=tree[p].r) 
		return tree[p].sum;//如果被覆盖，就返回维护的值
    spread(p);//下传延迟标记，并查询左右儿子
    int mid=(tree[p].l+tree[p].r)>>1;
    long long ans=0;
    if(l<=mid) ans+=ask(p*2,l,r);
    if(r>mid) ans+=ask(p*2+1,l,r);//累加答案，返回左右儿子的和
    return ans;
}

int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	build(1,1,n);
	while(m--)
	{
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==1)
		{
			int x;
			scanf("%d",&x);
			change(1,l,r,x);
		}
		else if(op==2)
			printf("%lld\n",ask(1,l,r));
	}
	return 0;
}

P2574 XOR的艺术

P2574 XOR的艺术

#include<bits/stdc++.h>
using namespace std;
const int N=200020;
int a[N];

struct segment_tree
{
	int l,r,num,mark;
}t[N*4];

void build(int p,int l,int r)
{
	t[p].l=l,t[p].r=r;
	if(l==r)
	{
		t[p].num=a[l];
		//cout<<"p:"<<p<<' '<<a[l]<<endl;
		return;
	}
	int mid=(l+r)>>1;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	t[p].num=t[p*2].num+t[p*2+1].num;
}

void spread(int p)
{
	if(t[p].mark)
	{
		t[p*2].num=(t[p*2].r-t[p*2].l+1)-t[p*2].num;
		t[p*2+1].num=(t[p*2+1].r-t[p*2+1].l+1)-t[p*2+1].num;
		t[p*2].mark^=1;
		t[p*2+1].mark^=1;
		t[p].mark=0;
	}
}

void change(int p,int l,int r)
{
	if(l<=t[p].l&&t[p].r<=r)
	{
		t[p].num=(t[p].r-t[p].l+1)-t[p].num;
		t[p].mark^=1;
		return;
	}
	int mid=(t[p].l+t[p].r)>>1;
	spread(p);
	if(l<=mid) change(p*2,l,r);
	if(mid<r) change(p*2+1,l,r);
	t[p].num=t[p*2].num+t[p*2+1].num;
}

int ask(int p,int l,int r)
{
	if(t[p].l>=l&&t[p].r<=r) 
		return t[p].num;//如果完全包含，返回区间
	int mid=(t[p].l+t[p].r)/2;
	int ans=0;
	spread(p);//下传标记
	if(l<=mid) ans+=ask(p*2,l,r);//继续向下
	if(r>mid) ans+=ask(p*2+1,l,r);
	return ans;
}

int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		scanf("%1d",&a[i]);
	build(1,1,n);
	while(m--)
	{
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==1) cout<<ask(1,l,r)<<endl;
		if(op==0) change(1,l,r);
	}
    return 0;
}

P1438 无聊的数列

P1438 无聊的数列

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=1e5+10;
int n,m,a[N];

struct Node
{
	int l,r;
	LL sum,add;
}tr[N*4];

void build(int u,int l,int r)
{
	tr[u]={l,r,0,0};
	if(l==r) return;
	int mid=l+r>>1;
	build(u<<1,l,mid);
	build(u<<1|1,mid+1,r);
}
void pushdown(int u)
{
	tr[u<<1].sum+=(tr[u<<1].r-tr[u<<1].l+1)*tr[u].add;
	tr[u<<1|1].sum+=(tr[u<<1|1].r-tr[u<<1|1].l+1)*tr[u].add;
	tr[u<<1].add+=tr[u].add;
	tr[u<<1|1].add+=tr[u].add;
	tr[u].add=0;
}

void modify(int u,int l,int r,int v)
{
	if(tr[u].l>=l&&tr[u].r<=r)
	{
		tr[u].sum+=(tr[u].r-tr[u].l+1)*v;
        tr[u].add+=v;
	}
	else
	{
		pushdown(u);
		int mid=(tr[u].l+tr[u].r)>>1;
		if(l<=mid) modify(u<<1,l,r,v);
		if(r>mid) modify(u<<1|1,l,r,v);
		tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
	}
}


LL query(int u,int l,int r)
{
	if(tr[u].l>=l&&tr[u].r<=r) return tr[u].sum;
	else
	{	
		pushdown(u);
		int mid=(tr[u].l+tr[u].r)>>1;
		LL sum=0;
		if(l<=mid) sum+=query(u<<1,l,r);
		if(r>mid) sum+=query(u<<1|1,l,r);
		return sum;
	}
}

int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	build(1,1,n);
	while(m--)
	{
		int op;
		scanf("%d",&op);
		if(op==1)
		{
			int l,r,k,d;
			scanf("%d%d%d%d",&l,&r,&k,&d);
			modify(1,l,l,k);
			if(l<r) modify(1,l+1,r,d);
			if(r<n) modify(1,r+1,r+1,-k-d*(r-l));
		}
		if(op==2)
		{
			int x;
			scanf("%d",&x);
			printf("%lld\n",a[x]+query(1,1,x));
		}
	}
    return 0;
}

真的容易在各种奇奇怪怪的地方打错啊，(✖人✖)。
如果有更多种操作（乘上一个值等）可以在结构体再开别的变量，保存标记信息，但需要各个标记下放的顺序。这模板2要了我老命，爬

P3373 【模板】线段树 2

P3373 【模板】线段树 2

区间乘法：将整个区间上的数乘上一个数时同时要把它储存的add和mu都乘上该数。每次延迟标记下放遵循“先乘后加”：先把区间上的数乘上储存的mu再作区间加法。

#include<bits/stdc++.h>
#define ll long long 
using namespace std;
int n,m,a[1000005],mod;

struct segment_tree
{
	ll sum,l,r,mu,add;
}t[1000005];

ll read()
{
	ll x=0;char ch=getchar();
	while(ch<'0'||ch>'9')ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	return x;
}
void build(ll p,ll l,ll r)
{
	t[p].l=l,t[p].r=r,t[p].mu=1;//乘法运算的幺元是1 
	if(l==r)
	{
		t[p].sum=a[l]%mod;
		return;
	}
	ll mid=(l+r)>>1;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}

void spread(ll p)//重点关注 ！！！ 
{ 
	t[p*2].sum=(t[p*2].sum*t[p].mu+(t[p*2].r-t[p*2].l+1)*t[p].add%mod)%mod;
	t[p*2+1].sum=(t[p*2+1].sum*t[p].mu+(t[p*2+1].r-t[p*2+1].l+1)*t[p].add%mod)%mod;
	t[p*2].mu=(t[p*2].mu*t[p].mu)%mod;
	t[p*2+1].mu=(t[p*2+1].mu*t[p].mu)%mod;
	t[p*2].add=(t[p*2].add*t[p].mu+t[p].add)%mod;
	t[p*2+1].add=(t[p*2+1].add*t[p].mu+t[p].add)%mod;
	t[p].add=0;
	t[p].mu=1;
}

void pluss(ll p,ll l,ll r,ll x)
{
	if(l<=t[p].l&&t[p].r<=r)
	{
		t[p].sum=(t[p].sum+(t[p].r-t[p].l+1)*x%mod)%mod;
		t[p].add+=x;
		return;
	}
	spread(p);
	ll mid=(t[p].l+t[p].r)>>1;
	if(l<=mid) pluss(p*2,l,r,x);//一直都是（l,r)，算出mid仅用于比较 
	if(mid<r) pluss(p*2+1,l,r,x);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}

void mu(ll p,ll l,ll r,ll x)
{
	if(l<=t[p].l&&t[p].r<=r)
	{
		t[p].add=(t[p].add*x)%mod;
		t[p].mu=(t[p].mu*x)%mod;
		t[p].sum=(t[p].sum*x)%mod;
		return;
	}
	spread(p);
	ll mid=(t[p].l+t[p].r)>>1;
	if(l<=mid) mu(p*2,l,r,x);
	if(mid<r) mu(p*2+1,l,r,x);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}

ll ask(ll p,ll l,ll r)
{
	if(l<=t[p].l&&t[p].r<=r)
		return t[p].sum;
	spread(p);//每次询问到这里也要下放标记 
	ll mid=(t[p].l+t[p].r)>>1;
	ll val=0;
	if(l<=mid) val=(val+ask(p*2,l,r))%mod;
	if(mid<r )val=(val+ask(p*2+1,l,r))%mod;
	return val;
}
int main()
{
	cin>>n>>m>>mod;
	for(int i=1;i<=n;i++)
		a[i]=read();
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		int op=read();
		if(op==1)
		{
			ll cn=read(),cm=read(),cw=read();
			mu(1,cn,cm,cw);
		}else if(op==2)
		{
			ll cn=read(),cm=read(),cw=read();
			pluss(1,cn,cm,cw);
		}
		else 
		{
			ll cn=read(),cm=read();
			cout<<ask(1,cn,cm)<<endl;
		}
    }
}

扫描线

247. 亚特兰蒂斯

247. 亚特兰蒂斯

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10;
int n;
struct segment
{
	double x,y1,y2;
	int k;
	bool operator< (const segment &t)const
	{
		return x<t.x;
	}
}seg[N*2];//储存竖线 
struct Node
{
	int l,r;
	int cnt;
	double len;
}tr[N*8];//在纵坐标上建线段树 

vector<double>line;

int find(double x)
{
	return lower_bound(line.begin(),line.end(),x)-line.begin();
}

void pushup(int u)
{
	if(tr[u].cnt) tr[u].len=line[tr[u].r+1]-line[tr[u].l];
	else if(tr[u].l!=tr[u].r)
		tr[u].len=tr[u<<1].len+tr[u<<1|1].len;
	else tr[u].len=0;
}
void build(int u,int l,int r)
{
	tr[u]={l,r,0,0};
	if(l!=r)
	{
		int mid=l+r>>1;
		build(u<<1,l,mid);
		build(u<<1|1,mid+1,r);
	}
	
}

void modify(int u,int l,int r,int k)
{
	if(l<=tr[u].l&&tr[u].r<=r)
		tr[u].cnt+=k;
	else
	{
		int mid=(tr[u].l+tr[u].r)>>1;
		if(l<=mid) modify(u<<1,l,r,k);
		if(mid<r) modify(u<<1|1,l,r,k);
	}
	pushup(u);
}

int main()
{
	int T=1;
	while(scanf("%d",&n),n)
	{
		line.clear();
		int cnt=0;
		for(int i=0;i<n;i++)
		{
			double x1,x2,y1,y2;
			scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
			seg[cnt++]={x1,y1,y2,1};//k==1表示矩形左边 
			seg[cnt++]={x2,y1,y2,-1};//k==2表示矩形右边 
			line.push_back(y1);
			line.push_back(y2);
		}
		sort(line.begin(),line.end());
        line.erase(unique(line.begin(),line.end()),line.end());
		build(1,0,line.size()-2);
		sort(seg,seg+2*n);
		double ans=0;
		for(int i=0;i<2*n;i++)
		{
			if(i>0) ans+=tr[1].len*(seg[i].x-seg[i-1].x);
			modify(1,find(seg[i].y1),find(seg[i].y2)-1,seg[i].k); 
		}
		printf("Test case #%d\n",T++);
        printf("Total explored area: %.2lf\n\n",ans);
	}
    return 0;
}

主席树

P3834 【模板】可持久化线段树 2

P3834 【模板】可持久化线段树 2

#include<bits/stdc++.h>
using namespace std;
const int N=200010;
int a[N],b[N],n,m,tot,total,root[N];
struct Node
{
    int l,r;
    int cnt;
}tr[N*4+N*20];

int build(int l,int r)
{
    int p=++tot;
    if(l==r) return p;
    int mid=(l+r)>>1;
    tr[p].l=build(l,mid),tr[p].r=build(mid+1,r);
    return p;
}

int insert(int p,int l,int r,int x)
{
    int q=++tot;//点分裂
    tr[q]=tr[p];
    if(l==r)
    {
        tr[q].cnt++;
        return q;
    }
    int mid=(l+r)>>1;
    if(x<=mid) tr[q].l=insert(tr[p].l,l,mid,x);
    else tr[q].r=insert(tr[p].r,mid+1,r,x);
    tr[q].cnt=tr[tr[q].l].cnt+tr[tr[q].r].cnt;
    return q;
}

int query(int p,int q,int l,int r,int k)
{
    if(l==r) return l;
    int dif=tr[tr[q].l].cnt-tr[tr[p].l].cnt;
    int mid=(l+r)>>1;
    if(k<=dif) return query(tr[p].l,tr[q].l,l,mid,k);
    else return query(tr[p].r,tr[q].r,mid+1,r,k-dif);
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]),b[i]=a[i];
    sort(a+1,a+n+1);
    total=unique(a+1,a+n+1)-a-1;
    root[0]=build(1,total);
    for(int i=1;i<=n;i++)
        b[i]=lower_bound(a+1,a+total+1,b[i])-a;
    for(int i=1;i<=n;i++)
        root[i]=insert(root[i-1],1,total,b[i]);
    while(m--)
    {
        int l,r,k;
        scanf("%d%d%d",&l,&r,&k);
        printf("%d\n",a[query(root[l-1],root[r],1,total,k)]);
    }
    return 0;
}

P1972 [SDOI2009] HH的项链

P1972 [SDOI2009] HH的项链
每次都是先把 l a s t [ a [ i ] ] last[a[i]] last[a[i]]的位置先改了（之前没有的话就直接继承上一个节点的了），形成树t，再在t的基础上继续修改。查询的时候我们用右端点控制树的版本，而用左端点控制范围。

#include<bits/stdc++.h>
using namespace std;

const int N=1e6+10;
int n,a[N],root[N],last[N],ans[N],tot,m;
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
	return x*f;
}
struct Node
{
    int l,r;
    int cnt;
}tr[N*40];


int build(int l,int r)
{
    int p=++tot;
    if(l==r) return p;
    int mid=(l+r)>>1;
    tr[p].l=build(l,mid),tr[p].r=build(mid+1,r);
    return p;
}

int insert(int p,int idx,int l,int r,int x)
{
    int q=++tot;//点分裂
    tr[q]=tr[p],tr[q].cnt+=x;
	if(l<r)
	{
		int mid=(l+r)>>1;
	    if(idx<=mid) tr[q].l=insert(tr[p].l,idx,l,mid,x);
	    else tr[q].r=insert(tr[p].r,idx,mid+1,r,x);
	}
	return q;
}

int query(int idx,int q,int l,int r)
{
	if(l==r) return tr[q].cnt;
	int mid=l+r>>1;
	if(idx<=mid) return query(idx,tr[q].l,l,mid)+tr[tr[q].r].cnt;
	else return query(idx,tr[q].r,mid+1,r);
}

int main()
{
	cin>>n;
	root[0]=build(1,n);
	for(int i=1;i<=n;i++)
	{
		a[i]=read();
		if(!last[a[i]])//该数据第一次出现 
			root[i]=insert(root[i-1],i,1,n,1);
		else
		{
			int t=insert(root[i-1],last[a[i]],1,n,-1);
			root[i]=insert(t,i,1,n,1);
		}
		last[a[i]]=i;
	}
    cin>>m;
    for(int i=1;i<=m;i++)
	{
		int l,r;
		scanf("%d%d",&l,&r);
		printf("%d\n",query(l,root[r],1,n));
	}
    return 0;
}
春弦_
关注
专栏目录
Lct系列小结
袋鼠与蒟蒻
07-02 1057
  这个东西欠了很久了(博客也停了很久了) 这篇博文不负责讲解Lct的基础知识（太麻烦）所以有需要的同学可以看这里 PART 1  我们首先给一个模板 struct Splay{     int F,s[2],rev;     int val,sum;     inline void NewNode(int fa,int x){         F=fa; s[0]=s[1]=rev=...
segment tree
07-22
线段树详细讲义和实现(英文)
Segment-Tree
acei6的博客
05-04 209
Segment Tree   线段树(Segment Tree)是个用空间换时间的数据结构,可以用于区间的染色、查询、求和等操作。线段树从名字就可以看出是对于一个一维线段的操作，将原本逐个遍历的操作进行优化。   首先，线段树的构成其实是一种二叉树，树的根节点是一整个区间，而叶子则是区间的最小单位，每个父节点是两个子节点的合并区间，并且两个子节点区间是对半分的。 (1,4) / ...
Segment Tree（线段树）
小熊听
09-12 315
线段树代码模板：public class NumArray { Node root; int[] nums; public NumArray(int[] nums) { this.nums=nums; if(nums.length>0){ root=build(root,0,nums.length-1); } }
Segment Tree
swen29的博客
11-25 386
线段树 模板
平衡树学习笔记
Recalling_Clouds的博客
01-12 283
平衡树学不会的，这辈子都学不会的 一、前置芝士 平衡树本质上看是一种 BST（二叉排序树） 而 BST 其实是一种非常容易理解的良心数据结构 BST 保证了这颗树的中序遍历是单调上升的 举个例子： BST 支持插入、删除以及查询等多种操作，我们一一来讲述 插入 插入很简单 我们知道二叉排序树有一个性质：对于每一个结点，设它的点权为 valvalval，那么它的左子树中的每一个点权值必定小于 valvalval，它的右子树中的每一个点权值必定大于 valvalval 插入时我们对于当前访问到的点的权值
HDU题目分类大全【大集合】
欢迎来到扣子不会飞的博客！
03-18 3569
基础题： 1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、 1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、 1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、...
hdoj杭电问题分类
04-02 5385
杭电上的题虽然多，但是一直苦于找不到问题分类，网页都是英文的，所以平时做题也没怎么看，今天仔细一看，问题分类竟然就在主页。。。。做了那么久的题居然没发现，表示已经狗带。。不要笑，不知道有没有像我一样傻的孩子，可以参考一下。。。 点进来就是。。。
segment tree(线段树)
liuchenjane的博客
02-16 920
简介  线段树(segment tree)是一种存储区间的树形结构，方便查询哪一个区间包含了指定的点，原则上，它是一种固定结构， 一旦建成该树，它的结构不会改变。 对于n个区间的集合，建一棵线段树的时间复杂度和空间复杂度都是O(nlgn)。 2. 定义 一维线段树结构： 假设有一个区间集合，每一个区间元素从左到右依次是： 。 步骤： ste
线段树（segment tree)，看这一篇就够了
热门推荐
正西风落叶下长安
03-18 5万+
定义 线段树（segment tree），顾名思义， 是用来存放给定区间（segment, or interval）内对应信息的一种数据结构。与树状数组（binary indexed tree）相似，线段树也用来处理数组相应的区间查询（range query）和元素更新（update）操作。与树状数组不同的是，线段树不止可以适用于区间求和的查询，也可以进行区间最大值，区间最小值（Range Mi...
【线段树】Segment Tree
C++的星空
05-03 389
Segment Tree 时间限制:1 Sec内存限制:512 MB 提交:107解决:23 [提交] [状态] [命题人:admin] 题目描述 Mcginn opens the code which he wrote 25 years ago. Clever Mcginn wants to know how many positive interger n satisfie...
线段树（SegmentTree）
数据工匠记
06-11 688
线段树（segment tree）顾名思义， 是用来存放给定区间（segment or interval）内对应信息的一种数据结构。
算法数据结构——线段树（Segment Tree）精讲及python实现
最新发布
学习中
08-25 1049
算法数据结构——线段树（Segment Tree）精讲及python实现
Segment Tree介绍与使用
xing1989的专栏
07-25 2353
首先，看如下事例： 假设有数组 A[0..n-1]，我们可以进行如下操作： （1）求范围[ l, r ]间元素之和。0 （2）更新某位置 i 处值，A[i] = new_val， 0 简单直观方法，就是遍历数组，可知此时（1）时间复杂度O(n)，（2）时间复杂度O(1)。这种方法对于多更新操作的有利。 另一方法，创建新数组B，其中B[i]=SUM(A[0]..A[i])，0 那么当两类
数据结构--树--线段树（Segment Tree）
Michael是个半路程序员
03-13 3226
文章目录1. 概念2. 建树3. 查询4. 修改5. 完整代码及测试 1. 概念 线段树是一种二叉树，是用来表示一个区间的树： 常常用来查询区间的：和、最小值、最大值 树结点中存放不是普通二叉树的值，其结点结构如下 class TreeNode { public: int sum;//区间和 int MAX;//区间最大的 int MIN;//区间最小的 in...
10、线段树(segment_tree)
阿牧路泽
12-31 218
1、简介 线段树算法是一种快速查询一段区间内的信息的算法，由于其实现简单，所以广泛应用于程序设计竞赛中。 线段树是一棵完美二叉树，即所有的叶子节点的深度均相同, 并且所有的非叶子节点都有两个子节点。每个节点维护一个区间，这个区间为父节点二分后的子区间，根节点维护整个区间，叶子节点维护单个元素，当元素个数为n时，对区间的操作都可以在O(log n)的时间内完成，因为此时树的深度为log2 n + 1...
线段树解决RmqWithShifts问题
在这个资源中，我们探讨了如何使用线段树（Segment Tree）解决RmqWithShifts问题。线段树是一种数据结构，用于高效地处理数组或序列上的区间查询和修改操作。在这个实例中，我们看到一个C++实现，它包括一个`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

春弦_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值