线段树学习

目录

eg1：最大整数

eg2：你能回答这些问题吗

eg3：一个简单的整数问题2；

eg4：亚特兰蒂斯，扫描线；

eg5：维护序列

线段树:

①pushup（）：由子节点更新父节点信息；

②build（）：将一段区间初始化为线段树

③modify（）：修改一个点或者区间；单点：easy；区间：用到pushdown，hard；

④query：查询一段区间的信息；

⑤pushdown（）：由父节点更新子节点信息；

线段树是一颗满二叉树（除了最后一层）：根节点是原区间，左孩子：[L,mid] ,右孩子：[mid+1, R] mid是（l+r）/2 下取整；

和堆类似：用一维数组来存储线段树；

开空间一般开4n！！；最坏有2n-1+2n=4n-1个点；

build（int u ，int l，int r）：

query():

查询的递归：

pushup（）：由子节点信息更新父节点；

pushdown（）：

用于解决区间修改的操作；

懒标记add：

当前节点可加可不加，保持前后一致即可；

pushdown：将add传给儿子，并清除父亲的add；

具体更新：

eg1：最大整数

最多添加m个数，我们先开出m个数的数组，然后把添加有一个数看成修改那个位置的数； 

线段树存储的值和题目有关，pushup是由子结点的值更新父节点，也和题目有关；

#include
#include
#include
#define rep1(i,a,n) for(register ll i=a;ia;i--) 
#define per2(i,n,a) for(register ll i=n;i>=a;i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define endl "n"
#define lowbit(x) (-x&x)
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef pair PII;
typedef double db;
const int N=2e5+10;
struct ji
{
	int l,r;
	int v;
}tr[N*4];
int m,p;
void pushup(int u)
{
	tr[u].v=max(tr[u<<1].v,tr[u<<1|1].v);
}
void build(int u,int l,int r)
{
	tr[u]={l,r};
	if(l==r)return;
	int mid=l+r>>1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
}
int query(int u,int l,int r)
{
	if(tr[u].l>=l&&tr[u].r<=r)return tr[u].v;
	int mid=tr[u].l+tr[u].r>>1;
	int v=0;
	if(l<=mid)v=query(u<<1,l,r);
	if(r>mid)v=max(v,query(u<<1|1,l,r));
	return v;
}
void modify(int u,int x,int v)
{
	if(tr[u].l==x&&tr[u].r==x)
	{
		tr[u].v=v;
		return;
	}
	int mid=tr[u].l+tr[u].r>>1;
	if(x<=mid)modify(u<<1,x,v);
	else modify(u<<1|1,x,v);
	pushup(u);
}
signed main()
{
	quick_cin();
	int n=0,last=0;
	cin>>m>>p;
	build(1,1,m);
	char c;int x;
	while(m--)
	{	
		cin>>c>>x;
		if(c=='Q')
		{
			last=query(1,n-x+1,n);
			cout< 
eg2：你能回答这些问题吗 
 
 操作：
 单点修改，区间查询；区间查询的是最大连续子段的和，所以node除了存l，r还有tmax，最大连续字段和（因题而异）；
 
但是此题无法直接通过子节点求出父节点的tmax，所以需要辅助信息：每个区间的最大前缀和和最大后缀和；这样即可完成更新；
 
 
 
 这样tmax=max(左儿子tmax，右儿子tmax，左儿子最大后缀和+右儿子最大前缀和）
 
即可完成tmax的更新，但是最大前缀和lmax，最大后缀和rmax也需要求；
 
拿lmax举例：
 
 
 如果最大前缀和没有跨过mid，就和左儿子的lmax相等；
 
跨过mid，就是左儿子的和sum+右儿子的lmax；
 
最大后缀和同理；
 
但是又引出了sum，sum能不能右左右儿子直接得到呢？答案是可以的；就是左儿子的sum+右儿子的sum；
 
最终的node：
 
 
多通读理解几遍； 
 
#include
#include
#include
#define rep1(i,a,n) for(register ll i=a;ia;i--) 
#define per2(i,n,a) for(register ll i=n;i>=a;i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define endl "n"
#define lowbit(x) (-x&x)
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef pair PII;
typedef double db;
const int N=5e5+10;
int n,m;
struct node
{
	int l,r;
	int sum,lmax,rmax,tmax;
}tr[N*4];
int w[N];
void pushup(node &u,node &l,node &r)
{
	u.sum=l.sum+r.sum;
	u.lmax=max(l.lmax,l.sum+r.lmax);
	u.rmax=max(r.rmax,r.sum+l.rmax);
	u.tmax=max(max(l.tmax,r.tmax),l.rmax+r.lmax);
}
void pushup(int u)
{
	pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}
void build(int u,int l,int r)
{
	if(l==r)
	{
		tr[u]={l,r,w[r],w[r],w[r],w[r]};
		return;
	}
	tr[u]={l,r};
	int mid=l+r>>1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
	pushup(u);
}
void modify(int u,int x,int v)
{
	if(tr[u].l==x&&tr[u].r==x)tr[u]={x,x,v,v,v,v};
	else
	{
		int mid=tr[u].l+tr[u].r>>1;
		if(x<=mid)modify(u<<1,x,v);
		else modify(u<<1|1,x,v);
		pushup(u);
	}
}
node query(int u,int l,int r)
{
	if(tr[u].l>=l&&tr[u].r<=r)return tr[u];
	else
	{
		int mid=tr[u].l+tr[u].r>>1;
		if(r<=mid)return query(u<<1,l,r);
		if(l>mid)return query(u<<1|1,l,r);
		else
		{
			auto left=query(u<<1,l,r);
			auto right=query(u<<1|1,l,r);
			node ans;
			pushup(ans,left,right);
			return ans;
		}
	}
}
signed main()
{
	quick_cin();
	cin>>n>>m;
	rep2(i,1,n)cin>>w[i];
	build(1,1,n);
	int k,x,y;
	while(m--)
	{
		cin>>k>>x>>y;
		if(k==1)
		{
			if(x>y)swap(x,y);
			cout< 
eg3：一个简单的整数问题2； 
理解modify的区别；记住pushdown，pushup的使用时机；
 
#include
#define rep1(i,a,n) for(ll i=a;ia;i--) 
#define per2(i,n,a) for(ll i=n;i>=a;i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define INF 0x3f3f3f3f
#define pb push_back
#define endl "n"
using namespace std;
typedef long long ll;
typedef pair PII;
typedef double db;
const int N=1e5+10;
int n,m;
int w[N];
struct node
{
	int l,r;
	ll sum,add;
}tr[N*4];
void pushup(int u)
{
	tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
}
void pushdown(int u)
{
	node &root=tr[u],&left=tr[u<<1],&right=tr[u<<1|1];
	if(root.add)
	{
		left.add+=root.add,left.sum+=(ll)(left.r-left.l+1)*root.add;
		right.add+=root.add,right.sum+=(ll)(right.r-right.l+1)*root.add;
		root.add=0;
	}
}
void build(int u,int l,int r)
{
	if(l==r)tr[u]={l,r,w[r]};
	else
	{
		tr[u]={l,r};
		int mid=l+r>>1;
		build(u<<1,l,mid),build(u<<1|1,mid+1,r);
		pushup(u);
	}
}
void modify(int u,int l,int r,int d)
{
	if(tr[u].l>=l&&tr[u].r<=r)
	{
		tr[u].sum+=(ll)(tr[u].r-tr[u].l+1)*d;
		tr[u].add+=d;
	}
	else
	{
		pushdown(u);
		int mid=tr[u].l+tr[u].r>>1;
		if(l<=mid)modify(u<<1,l,r,d);
		if(r>mid)modify(u<<1|1,l,r,d);
		pushup(u);
	}
}
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;
	}
}
signed main()
{
	quick_cin();
	cin>>n>>m;
	rep2(i,1,n)cin>>w[i];
	build(1,1,n);
	char c;int l,r,d;
	while(m--)
	{
		cin>>c>>l>>r;
		if(c=='C')
		{
			cin>>d;
			modify(1,l,r,d);
		}
		else cout< 
eg4：亚特兰蒂斯，扫描线； 
 
 
 
直接学这种方法是怎么实现和解决问题的：
 
就是用垂直x轴的线从左往右扫，得到的线段长度*宽度（xi-xi-1），即为小矩阵的面积，求和即为所有的面积且不重复；
 
那么怎么实现线段长度的更新呢？换言之，如何保证线段长度正确合理呢？
 
对每次输入的矩形，左边打上+1的标记，右边打上-1的标记，这样加1之后，只要该段区间所有地方都>0，就说明该区间可以被当作长度，知道遇到它原来的右边界，然后减去1，表示该矩形不再贡献长度；
 
由此产生两个操作：
 
k=1或-1；
 
 
 统计信息只往下看！！；
 
特殊性：
 因为只看最终找到的长度，所有区间查询只看tr[1]，根节点的长度信息；
 
二是操作都是成对的，即（1，5）+1，之后一定会（1，5）-1；
 
综上，不需要pushdown来分裂区间，也可以保证答案的正确性；
 
因为xy可能是小数，所以需要离散化！！；
 
#include
#define rep1(i,a,n) for(ll i=a;ia;i--) 
#define per2(i,n,a) for(ll i=n;i>=a;i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define INF 0x3f3f3f3f
#define pb push_back
#define endl "n"
using namespace std;
typedef long long ll;
typedef pair PII;
typedef double db;
const int N=1e5+10;
int n;
struct segment
{
	db x,y1,y2;
	int k;
	bool operator<(const segment &t)const
	{
		return xys;
int find(db y)
{
	return lower_bound(ys.begin(),ys.end(),y)-ys.begin();
}
void pushup(int u)
{
	if(tr[u].cnt)tr[u].len=ys[tr[u].r+1]-ys[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(tr[u].l>=l&&tr[u].r<=r)
	{
		tr[u].cnt+=k;
		pushup(u);
	}
	else
	{
		int mid=tr[u].l+tr[u].r>>1;
		if(l<=mid)modify(u<<1,l,r,k);
		if(r>mid)modify(u<<1|1,l,r,k);
		pushup(u);
	}
}
signed main()
{
	quick_cin();
	int T=0;
	while(cin>>n,n)
	{	
		T++;
		ys.clear();
		int j=0;
		rep1(i,0,n)
		{
			db x1,y1,x2,y2;
			cin>>x1>>y1>>x2>>y2;
			seg[j++]={x1,y1,y2,1};
			seg[j++]={x2,y1,y2,-1};
			ys.pb(y1);
			ys.pb(y2);
		}
		sort(ys.begin(),ys.end());
		ys.erase(unique(ys.begin(),ys.end()),ys.end());//去重
		build(1,0,ys.size()-2);//区间比点的个数少1；
		sort(seg,seg+n*2);
		double ans=0;
		rep1(i,0,n*2)
		{
			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);
		}
		cout<<"Test case #"< 
eg5：维护序列 
 
 
 两个懒标记add 和 mul；
 
sum的维护；用x*mul+add的形式来维护，这样形式上很统一，并且可以互相转化；默认mul是1，add是0；
 
只乘一个数x，mul=x，add=0，只加一个数x：mul=1，add+=x；
 
都有：
 
 
 把mul=a变成ac，add=b变成bc+d；
 
#include
#define rep1(i,a,n) for(ll i=a;ia;i--) 
#define per2(i,n,a) for(ll i=n;i>=a;i--)
#define quick_cin() cin.tie(0),cout.tie(0),ios::sync_with_stdio(false)
#define INF 0x3f3f3f3f
#define pb push_back
#define endl "n"
using namespace std;
typedef long long ll;
typedef pair PII;
typedef double db;
const int N=1e5+10;
int w[N];
int n,p,m;
struct node
{
	int l,r;
	int sum,add,mul;
}tr[N*4];
void pushup(int u)
{
	tr[u].sum=(tr[u<<1].sum+tr[u<<1|1].sum)%p;
}
void eval(node &t,int add,int mul)
{
	t.sum=((ll)t.sum*mul+(ll)(t.r-t.l+1)*add)%p;
	t.mul=((ll)t.mul*mul)%p;
	t.add=((ll)t.add*mul+add)%p;
}
void pushdown(int u)
{
	eval(tr[u<<1],tr[u].add,tr[u].mul);
	eval(tr[u<<1|1],tr[u].add,tr[u].mul);
	tr[u].add=0,tr[u].mul=1;
}
void build(int u,int l,int r)
{
	if(l==r)tr[u]={l,r,w[r],0,1};
	else
	{
		tr[u]={l,r,0,0,1};
		int mid=l+r>>1;
		build(u<<1,l,mid),build(u<<1|1,mid+1,r);
		pushup(u);
	}
}
void modify(int u,int l,int r,int add,int mul)
{
	if(tr[u].l>=l&&tr[u].r<=r)eval(tr[u],add,mul);
	else
	{
		pushdown(u);
		int mid=tr[u].l+tr[u].r>>1;
		if(l<=mid)modify(u<<1,l,r,add,mul);
		if(r>mid)modify(u<<1|1,l,r,add,mul);
		pushup(u);
	}
}
int query(int u,int l,int r)
{
	if(tr[u].l>=l&&tr[u].r<=r)return tr[u].sum;
	pushdown(u);
	int mid=tr[u].l+tr[u].r>>1;
	int sum=0;
	if(l<=mid)sum=query(u<<1,l,r);
	if(r>mid)sum=(sum+query(u<<1|1,l,r))%p;
	return sum;
}
signed main()
{
	quick_cin();
	cin>>n>>p;
	rep2(i,1,n)cin>>w[i];
	cin>>m;
	int c,l,r,d;
	build(1,1,n);
	while(m--)
	{
		cin>>c>>l>>r;
		if(c==1)
		{
			cin>>d;
			modify(1,l,r,0,d);
		}
		else if(c==2)
		{
			cin>>d;
			modify(1,l,r,d,1);
		}
		else cout<