线段树笔记草稿

一个左节点u << 1和右节点u << 1 | 1 的证明
线段树笔记草稿_第1张图片

区间修改部分

1.批量等值修改

前提条件

是要区间修改,区间查询,且修改操作修改的值是相同的

情景

一般是要对一个数组执行k次操作,每次改变其中一个区间内所有元素的值,然后询问一个区间内所有元素的最值或总和,

题解代码
void Pushdown(int k){    //更新子树的lazy值,这里是RMQ的函数,要实现区间和等则需要修改函数内容
    if(lazy[k]){    //如果有lazy标记
        lazy[k<<1] += lazy[k];    //更新左子树的lazy值
        lazy[k<<1|1] += lazy[k];    //更新右子树的lazy值
        t[k<<1] += lazy[k];        //左子树的最值加上lazy值
        t[k<<1|1] += lazy[k];    //右子树的最值加上lazy值
        lazy[k] = 0;    //lazy值归0
    }
}

注意懒标记中储存区间修改的值与长度的乘积,大概率开long long

struct node {
    int l, r;
    ll val;
    ll lazy;
}t[N << 2];
void pushdown(node& op, ll lazy) {
    op.val += lazy * (op.r - op.l + 1);
    op.lazy += lazy;
}
void pushdown(int x) {
    if (!t[x].lazy) return;
    pushdown(t[x << 1], t[x].lazy), pushdown(t[x << 1 | 1], t[x].lazy);
    t[x].lazy = 0;
}
void build(int l, int r, int x = 1\没有值传入时,默认初始化为1) {
    t[x] = { l, r, w[l], 0 };
    if (l == r) return;
    int mid = l + r >> 1;
    build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
    pushup(x);
}

void modify(int l, int r, int c, int x = 1) {
    if (l <= tr[x].l && r >= tr[x].r) { pushdown(tr[x], c); return; }\通过打标记的方法来赋值
    pushdown(x);
    操作时遇到了懒标记就处理下(懒的思想,顺路就搞下,不顺路就拖着不干)
    int mid = tr[x].l + tr[x].r >> 1;
    if (l <= mid) modify(l, r, c, x << 1);\modify的递归也变成了和线段树单点修改query里的递归形式,有交集就递归。
    if (r > mid) modify(l, r, c, x << 1 | 1);
    pushup(x);
}

ll ask(int l, int r, int x = 1) {
    if (l <= t[x].l && r >= tr[x].r) return tr[x].val;
    pushdown(x);
    //query的唯一变化就是加上了一个pushdown();
    int mid = tr[x].l + tr[x].r >> 1;
    ll res = 0;
    if (l <= mid) res += ask(l, r, x << 1);
    if (r > mid) res += ask(l, r, x << 1 | 1);
    return res;
}

int main()
{
    int n, m; cin >> n >> m;
    rep(i, n) scanf("%d", &w[i]);
    build(1, n);
    
    while (m--) {
        char op[2]; int l, r; scanf("%s %d %d", op, &l, &r);
        
        if (*op == 'Q') printf("%lld\n", ask(l, r));
        else {
            int c; scanf("%d", &c);
            modify(l, r, c);
        }
    }
    return 0;
}


自己写的acwing式代码
#include 
#include 
#include 
#include 
using namespace std;
const int N = 1e5 + 10;
typedef long long ll;
struct node{
	int l,r;
	ll sum;
	ll lazy;
}tr[N<<2];
int w[N];

void pushdown(node &x,ll lazy){
	x.sum += lazy*(x.r - x.l + 1);
	x.lazy += lazy;
}
void pushdown(int u){
	if(!tr[u].lazy) return;
	pushdown(tr[u<<1],tr[u].lazy),pushdown(tr[u<<1|1],tr[u].lazy);
	tr[u].lazy = 0;
}
void pushup(int u){
	tr[u].sum = tr[u<<1].sum + tr[u<<1|1].sum;
}
void build(int u,int l,int r){
	tr[u].l = l,tr[u].r = r,tr[u].sum =w[r];
	if(l == r) return;
	int mid = l + r >> 1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
	pushup(u);
}
ll query(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
	ll res = 0;
	int mid = tr[u].l + tr[u].r >> 1;
	pushdown(u);
	if(l <= mid) res += query(u<<1,l,r);
	if(r > mid) res += query(u<<1|1,l,r);
	return res;
}
void modify(int u,int l,int r,int v){
	if(tr[u].l >= l && tr[u].r <= r){
		pushdown(tr[u],v);
		return;
	}
	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); 
	pushup(u);
}
int main(){
	int n,m;
	cin >> n >> m;
	for(int i =1;i <= n;i++) scanf("%d",&w[i]);
	build(1,1,n);
	while(m--){
		char op[2];
		int l,r;
		scanf("%s%d%d",op,&l,&r);
		if(*op == 'Q') printf("%lld\n",query(1,l,r));
		else{
			int c;
			scanf("%d",&c);
			modify(1,l,r,c);
		}
	}
	return 0;
}




注意:

线段树的初始化在build里完成,多组数据集时不需要再额外初始化。


2.批量自适应修改

前提条件

是区间修改,区间查询,且修改操作的修改的值是根据具体节点储存的值而变化的,比如开根,幂,替换,乘除;


情景

对一个序列里的元素执行k次自适应操作,每次操作一个区间,然后询问区间内所有元素的值。
也有询问某个区间内所有值经过某种处理后的值。(此种问法是询问时用一个变量储存找到的值,经过处理后返回



例题1单种操作

Can you answer these queries?
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)
主要就是把modify的递归条件改成了和传统query操作相同的有交集
复杂度比较高,可能需要一些剪枝,某条件下操作了等于白操作之类的。

代码

#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
struct node{
	int l,r;
	ll sum;
}tr[N<<2];
ll w[N];
void pushup(int u){
	tr[u].sum = tr[u<<1].sum + tr[u<<1|1].sum;
}
void build(int u,int l,int r){
	tr[u] = {l,r,w[r]};
//	cout << w[r] << endl;
	if(l == r) return;
	int mid = l + r >> 1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
	pushup(u);
}
ll query(int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r) {
		return tr[u].sum;
		
	}	
//		cout << tr[u].sum;
	ll res =0 ;
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) res += query(u<<1,l,r);
	if(r > mid) res += query(u<<1|1,l,r);
	
	return res;
}
void modify(int u,int l,int r){
	
	if(tr[u].l == tr[u].r) tr[u].sum = sqrt(tr[u].sum);
	else{
		if(tr[u].l >= l && tr[u].r <= r && tr[u].sum == tr[u].r - tr[u].l + 1) return;
		int mid = tr[u].l + tr[u].r >> 1;
		if(l <= mid) modify(u<<1,l,r);
		if(r > mid) modify(u<<1|1,l,r);
		pushup(u);	
	}
	
}
	

int main()
{
    int T = 1;
    int n, m;
    while (cin >> n) {
        for(int i = 1;i <= n;i++) scanf("%lld", &w[i]);
        
        build(1,1, n);
        
        printf("Case #%d:\n", T++);
        scanf("%d", &m);
        while (m--) {
            int op, l, r; scanf("%d %d %d", &op, &l, &r);
            if (l > r) swap(l, r);
//            cout << l << " " << r << endl;
            if (op) printf("%lld\n", query(1,l, r));
            else modify(1,l, r);
        }
        printf("\n");
    }
    return 0;
}

例题2多种操作

Transformation HDU - 4578
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)

题解代码

Transformation HDU - 4578 (线段树,审题很重要)_Soar-的博客-CSDN博客

#include
 
using namespace std;
#define lson i<<1,l,m
#define rson i<<1|1, m+1,r
const int mod = 10007;
const int maxn=1e5+10;
 
int x[maxn<<2],flag[maxn<<2];
 x是tr,flag是lazy
void pushup(int i,int l,int r)
{
    if(!flag[i<<1] || !flag[i<<1|1])左右子节点无值
        flag[i] = 0;
    else if(x[i<<1] != x[i<<1|1])左右子节点有值且不等
        flag[i] = 0;
    else flag[i]=1,x[i]=x[i<<1];左右子节点值相等
    所以这是一个记录懒标记的函数,如果左右子节点的值相同,就上传。
    
    通过用父节点的节点的值来代表子节点的值接受处理,降低复杂度
}
 
void pushdown(int i,int l,int r)
{
    if(flag[i])
    {
        flag[i<<1] = flag[i<<1|1] =1;
        x[i<<1] = x[i<<1|1] = x[i];
        flag[i]=0;
    }
    这是一个下传懒标记并处理懒标记的函数,如果有懒标记,说明这个节点是代表子节点接受处理的,所以直接将值下传到子节点,然后清除懒标记
}
 
void update(int ql,int qr,int p,int v,int i,int l,int r)
{
	妙:直接传入op,也就是p,根据p的值进行不同操作,减少了很多赘余的代码。
	我写时想的是写3个modify,也就是update,根据op不同,调用不同的modify,麻烦得很。
    if(ql<=l && qr>=r && flag[i])
    这里是有懒标记,且节点区间全都在需要处理的区间内,直接处理当前节点,然后pushdown,就可以实现区间处理
    {
        if(p==1)
            x[i] = (x[i]+v)%mod;
        else if(p==2)
            x[i] = (x[i]*v)%mod;
        else x[i] = v;
        修改当前节点值的话是不需要pushup的,因为pushup的操作是根据子节点的值来决定是否赋予当前节点一个懒标记,只修改当前节点值,代表当前节点已经是叶子节点,或者左右节点值相同,所以就算pushup了,懒标记还是会保持原有状态
        return;
    }
    pushdown(i,l,r);
 可能没有懒标记,会需要逐个单点修改,所以用两个if的原始query递归形式
    int m = (l+r)>>1;
    if(ql<=m) update(ql,qr,p,v,lson);
    if(qr>m) update(ql,qr,p,v,rson);
    进行子节点单点值修改操作后都需要pushup,来更新懒标记状态
    
    pushup(i,l,r);
}
int query(int ql,int qr,int num,int i,int l,int r)
l,r是当前节点的l,r
{
    if(flag[i] && ql<=l && qr>=r)
    {
        int ans=1;
        for(int j=0;j<num;j++)ans=(ans*x[i])%mod;//pow操作,每次pow取余,如果是10007的三次方就有可能爆int了,所以用循环来每次操作后取余
        ans=(ans*(r-l+1))%mod;
        return ans;
    }
 
    pushdown(i,l,r);
 
    int m = (l+r)>>1;
    int ans=0;
    if(ql<=m)ans+=query(ql,qr,num,lson);
    if(qr>m)ans+=query(ql,qr,num,rson);
    return ans%mod;
}
 
int main()
{
    int n,m;
    while(cin>>n>>m,n||m)
    {
        memset(flag,1,sizeof flag);
        memset(x,0,sizeof x);
        int p,x,y,v;
        while(m--)
        {
            scanf("%d%d%d%d",&p,&x,&y,&v);
            if(p>=1 && p<=3)update(x,y,p,v,1,1,n);
            else printf("%d\n",query(x,y,v,1,1,n));
        }
    }
}

经过模仿后得到的acwing版代码

#include 
#include 
#include 
#include 
using namespace std;
const int N = 1e5 + 10,mod = 10007;
struct node{
	int l,r;
	int sum;
	int lazy;
}tr[N<<2];
void pushup(int u){
	if(!tr[u<<1].lazy || !tr[u<<1|1].lazy) tr[u].lazy = 0;
	有一个子节点懒标记是0(当前节点的子节点的两个子节点的值不相等)则当前节点懒标记就变成0,由此可以推断出,懒标记的含义是表示当前节点的子树里所有节点的值 ,都相等,可以直接用当前节点的值来进行操作。 

	else if(tr[u<<1].sum != tr[u<<1|1].sum) tr[u].lazy = 0;
	else tr[u].lazy = 1,tr[u].sum = tr[u<<1].sum;
}
void pushdown(int u){
	if(tr[u].lazy){
		tr[u<<1].lazy = tr[u<<1|1].lazy = 1;
		tr[u<<1].sum = tr[u<<1|1].sum = tr[u].sum;
		tr[u].lazy = 0;
	}
}
void build(int u,int l,int r){
	tr[u] = {l,r,0,1};
	if(l == r) return;
	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 op,int v){
	if(tr[u].l >= l && tr[u].r <= r && tr[u].lazy){
		if(op == 1) tr[u].sum = (tr[u].sum + v) % mod;
		else if(op == 2) tr[u].sum = (tr[u].sum * v)%mod;
		else {
			tr[u].sum = v;	
		}		

		return;
	}
	pushdown(u);
	有懒标记要先处理,然后再运算。
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) modify(u<<1,l,r,op,v);
	if(r > mid) modify(u<<1|1,l,r,op,v);
	pushup(u);
	
}
int query(int u,int l,int r,int v){
	if(tr[u].l  >= l && tr[u].r <= r && tr[u].lazy){
		int res = 1;
		for(int i = 0;i < v;i++) res = (res * tr[u].sum) % mod;
		res = res * (tr[u].r - tr[u].l + 1) % mod;
		return res;
	}
	pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	int res = 0;
	if(l <= mid) res = (res + query(u<<1,l,r,v) )	%mod; 
	if(r > mid) res = (res + query(u<<1|1,l,r,v)) % mod;
	return res % mod;
}
int main(){
	int n,m;
	while(cin >> n >> m,n||m){
//		for(int i=0;i <= N << 2;i++) tr[i]= {0,0,0,0};	
		build(1,1,n);
		int op,l,r,v;
		while(m--){
			scanf("%d%d%d%d",&op,&l,&r,&v);
//			cout << op << " " << l << " " << r << " " << v << endl;
			if(op >=1 && op <= 3){
				modify(1,l,r,op,v);
			}
			else {
				printf("%d\n",query(1,l,r,v));
			}
		}
	}
	return  0;
}

注意

注意点就是非数组模拟节点的代码要用build初始化,然后懒标记初始化为1,因为代表的含义是两个子节点值是否相等

其他套路:

涉及到一个多组输入的套路
前提条件是没有明确组数,结束关键词的多组数据集输入
取反while(~scanf(“%d”,&n)
和while(scanf(“%d”,&n) != EOF)
还有while(cin >> n)三种形式

你可能感兴趣的:(树状数组与线段树,算法,图论,数据结构)