线段树总结分析第三版

区间修改部分

1.批量等值修改

前提条件

是要区间修改,区间查询,且修改操作修改的值是相同的,比如批量+1,批量-1.
有一种特例是批量替换,

情景

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

例题1区间等值操作

题解代码
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];
传入的lazy写成int类型,导致卡壳非常久。
晚上再写一遍。
注意不要混淆long longint
void pushdown(node &x,ll lazy){
	x.sum += lazy*(x.r - x.l + 1);
	x.lazy += lazy;
}
//一次调用需要从外界赋值,打上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线段树区间覆盖,二分查找

区别似乎可以用储存的是什么,还有操作是什么来区分

题解代码

#include 
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 5E4 + 10;
struct node {
    int l, r;
    int val;
    int lazy;
    lazy不能初始化为01的原因,要区分lazy的是否存在,存在时状态为非空还是空
    一般直觉是可以把有花设置为1,无花设置为0,可以用区间长度-查到的数量进行有花和无花数量的查询,所以这个应该不是什么问题,写出来之后再替换下。
}t[N << 2];
void pushdown(node& op, int lazy) {
    op.val = lazy * (op.r - op.l + 1);
    op.lazy = lazy;
    解除储存的懒标记
    理解这个代码的关键点在于这里的符号是等于,而不是+=
	}
void pushdown(int x) {
    if (t[x].lazy == -1) return;
    pushdown(t[x << 1], t[x].lazy), pushdown(t[x << 1 | 1],t[x].lazy);
    t[x].lazy = -1;
    向根部递归,解除所有子树里的节点的懒标记
}

void pushup(int x) {
	t[x].val = t[x << 1].val + t[x << 1 | 1].val; 
}

void build(int l, int r, int x = 1) {
    t[x] = { l, r, 1, -1 };
    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 <= t[x].l && r >= t[x].r) {
        pushdown(t[x], c);
        return;
    }
    pushdown(x);
    int mid = t[x].l + t[x].r >> 1;
    if (l <= mid) modify(l, r, c, x << 1);
    if (r > mid) modify(l, r, c, x << 1 | 1);
    pushup(x);
}

int ask(int l, int r, int x = 1) { //查询[l, r]区间的空花瓶数目
    if (l <= t[x].l && r >= t[x].r) return t[x].val;
    pushdown(x);
    int mid = t[x].l + t[x].r >> 1;
    int res = 0;
    if (l <= mid) res += ask(l, r, x << 1);
    if (r > mid) res += ask(l, r, x << 1 | 1);
    return res;
    1代表花瓶是空的
}

int n, m;
int getindex(int a, int c) { //找到[a, n]区间, 第c个可以放花瓶的位置
    int l = a, r = n;
    while (l < r) {
        int mid = l + r >> 1;
        if (ask(a, mid) >= c) r = mid;
        else l = mid + 1;
    }
    return l;
}
int main()
{
    int T; cin >> T;
    while (T--) {
        scanf("%d %d", &n, &m);
        build(1, n);
        while (m--) {
            int k, x, y; scanf("%d %d %d", &k, &x, &y);
            if (k == 1) {
                int cou = ask(x + 1, n);
                找到总共能插的花瓶数量
                if (!cou) printf("Can not put any one.\n");
                else {
                    int L = getindex(x + 1, 1);
                    找到第一个能插花瓶的下标
                    int R = getindex(x + 1, min(y, cou)); //注意要和cou取一个min
                    找到最后一个插花瓶的地方,或者是最后一个能插花瓶的地方
                    modify(L, R, 0);
                    l到r的数量设置为0,插花。
                    printf("%d %d\n", L - 1, R - 1);
                }
            }
            else {
                int res = y - x + 1 - ask(x + 1, y + 1);
	                x到y的花瓶数量 - x到y的空花瓶数量
	                res就是非空(被清空)的花瓶数量
                modify(x + 1, y + 1, 1);
	                x到y的数量设置为1
	                1代表花瓶是空的
                printf("%d\n", res);
            }
        }
        puts("");
    }
    return 0;
}


经过模仿得到的acwing代码

#include 
#include 
#include 
#include 
using namespace std;
const int N = 5e4 + 10;
统计的是花瓶数量,不需要开long longstruct node{
	int l,r;
	int sum;
	int lazy;
}tr[N<<2];
void pushdown(int u,int lazy){
	批量修改后,子树内所有的节点状态都相等,所以直接用lazy存状态,然后乘区间长度就可以表示出当前节点下的1状态节点个数,直接赋给sum。
	lazy存一个当前节点下的所有节点的状态。
	tr[u].sum = lazy * (tr[u].r - tr[u].l + 1);
	tr[u].lazy = lazy;
}
void pushdown(int u){
	if(tr[u].lazy == -1) return ;
	pushdown(u<<1,tr[u].lazy),pushdown(u<<1|1,tr[u].lazy);
	tr[u].lazy = -1;
}
void pushup(int u){
	
	tr[u].sum = tr[u<<1].sum + tr[u<<1|1].sum
}
void build(int u,int l,int r){
build需要和之前的题对比一下
	tr[u] = {l,r,1,-1};
	if(l == r) return;
	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 v){
没什么区别,传统批量等值修改的modify
	if(l <= tr[u].l && tr[u].r <= r){
		pushdown(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 query(int u,int l,int r){
没什么区别,传统批量等值修改的query
	if(l <= tr[u].l && tr[u].r <= r) return tr[u].sum;
	pushdown(u);
	int mid = tr[u].l + tr[u].r >> 1;
	int res = 0;
	if(l <= mid) res += query(u<<1,l,r);
	if(r > mid) res += query(u<<1|1,l,r);
	return res;
}
int n,m;
int find(int x,int v){
找a到n的第v个空花瓶。没有第v个会返回n
二分是要看mid和返回值的关系 
	int l = x,r = n;
	while(l < r){
		int mid = l  + r >> 1;
		if(query(1,x,mid) >= v) r = mid;
		else l = mid + 1;
	}
	return l;
}
int main(){
	int t;
	cin >> t;
	while(t--){
		scanf("%d%d",&n,&m);
		build(1,1,n);
		while(m--){
			int op,l,r;
			scanf("%d%d%d",&op,&l,&r);
			
			if(op == 1){
				l++;
				int cnt = query(1,l,n);
//				cout << cnt << endl;
				if(!cnt) printf("Can not put any one.\n");
				else{
					int L = find(l,1);
					
					int R = find(l,min(r,cnt));
					因为是找最后一个能插花的位置,所以要先用花的数量和空花瓶数量比较下,选出最小的一个,保证find查到的返回值位置是空花瓶。
//					cout << L << " " << R << endl;
					modify(1,L,R,0);
					printf("%d %d\n",L-1,R-1);
				}
			}
			else{
				l++,r++;
				int res = r - l + 1 - query(1,l,r);
				modify(1,l,r,1);
				printf("%d\n",res);
			}
		}
		puts("");
	}
	return 0;
}

例题3最大连续区间的维护,给连续区间长度,找端点

与例题2的区别,

此题要求在一个连续的区间上操作,所以是要知道一段区间是否连续,是否足够长,
用节点信息fmax,lmax,rmax来维护区间最大连续,左到右的最大连续,右到左的最大连续

情景:

如果这段时间空闲就安排活动。


因为要找到最左的区间,用深度优先搜索来找。
递归方面倒是和例题2很像,都是有一个左侧空瓶优先。但不会例题2递归做法,还不太懂。


套路

区间合并

前提条件:找连续区间
情景

区间合并,最大连续的情景
每组i向柜台的麋鹿Canmuu申请一组Di连续的房间。
任意两个相邻村庄之间可以通过地道保持连通。八路军司令询问从第 x 个村庄可以到达多少个地道完好的村庄(包括第 x 个村庄本身)。
就是找一段最靠前的符合要求的连续空间分配给每个请求,

应对:
用fmax,lmax,和rmax来维护最大连续。

查询区间,端点如果有优先级
递归优先的情景Canmuu总是选择尽可能小的r值。
就是找一段最靠前的符合要求的连续空间分配给每个请求,

dfs深搜递归查询,有先的放在前面。


一个染色优先度的套路,

前提条件

分色1,和色2,两种颜色
色1优先级高,可以无视色2进行区间染色,优先染无色区间,次优先染色2区间,不能染色1区间
色2不能在色1染色过的地方染色。

情景:

如果没有找到,小明就冒着木叽叽的风险无视所有屌丝基友的约定,
女神时间安排操作优先于屌丝。

处理方法

用两颗树来维护女神和屌丝的时间。女神邀约时先在屌丝树上找空闲(满足条件的最大连续)找不到再在女神树上找空闲(满足条件的最大连续)
女神操作染色时,要在两棵树上都进行染色,而屌丝操作只染一棵树。

题解代码

#include 
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E5 + 10;
struct node {
    int l, r;
    int fmax, lmax, rmax;
    int lazy;
    0代表没时间,1代表有时间。
}t1[N << 2], t2[N << 2]; // 基友, 女神
void pushdown(node& op, int lazy) {
	需要标记时使用
    op.fmax = lazy * (op.r - op.l + 1);
    直接把这个节点标注成了完全连续,进行区间覆盖成10
    op.lmax = op.fmax, op.rmax = op.fmax;
    经过fmax被赋值后,fmax变成了区间长度乘lazy状态,可以直接赋给lmax和fmax
    op.lazy = lazy;
}
void pushdown(node t[], int x) {
	需要访问子节点时使用。
    if (t[x].lazy == -1) return;
    pushdown(t[x << 1], t[x].lazy), pushdown(t[x << 1 | 1], t[x].lazy);
    t[x].lazy = -1;
}
一个输入tr[x],一个输入tr,用地址和引用来区分两个pushdown
void pushup(node& p, node& l, node& r) {
    p.fmax = max(max(l.fmax, r.fmax), l.rmax + r.lmax);
    p.lmax = l.lmax + (l.lmax == l.r - l.l + 1 ? r.lmax : 0);
    如果完全左子节点完全连续,就加上右子节点的从左往右最大连续,是一段连续的区间
    p.rmax = r.rmax + (r.rmax == r.r - r.l + 1 ? l.rmax : 0);
    如果右子节点完全连续,就加上左子节点的从左往右最大连续。
}
void pushup(node t[], int x) { pushup(t[x], t[x << 1], t[x << 1 | 1]); }
节点维护多个信息时写个pushup重载简化代码.
一个简化代码的操作,输入u变换成u<<1,u<<1|1的节点,传入函数引用里。
void build(int l, int r, int x = 1) {
    t1[x] = t2[x] = { l, r, 1, 1, 1, -1 };lazy初始化为-1其他为1.
    if (l == r) return;
    int mid = l + r >> 1;
    build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
    pushup(t1, x), pushup(t2, x);
}

int findleft(node t[], int c, int x = 1) { //找到当前树中最左侧有连续c空闲时间的左端点(起始点)
	不用担心搜不到结果,因为是用tr[1] 最上层节点的fmax确定过有这样一段连续时间才搜的
    if (t[x].l == t[x].r) return t[x].l;
    符合条件就return
    pushdown(t, x);
    if (t[x << 1].fmax >= c) return findleft(t, c, x << 1);
    dfs,把1的深度搜完,转战2
    if (t[x << 1].rmax + t[x << 1 | 1].lmax >= c) return t[x << 1].r - t[x << 1].rmax + 1;2的深度搜完,转战3
    搜到了立刻返回,
    return findleft(t, c, x << 1 | 1);3的深度搜完
}
维护最大连续,不需要query,
如果要求某个区间的最大连续的话要l==tr[u].l ,r == tr[u].r然后返回fmax
此题要找最左的符合要求的连续长度,如果有就在里面搜。要判断有没有,只需要看根节点的fmax是否符合要求即可,
void modify(node t[], int l, int r, int x = 1) { //修改某一课树的
    if (l <= t[x].l && r >= t[x].r) { pushdown(t[x], 0); return; }
    pushdown(t, x);
    int mid = t[x].l + t[x].r >> 1;
    if (l <= mid) modify(t, l, r, x << 1);
    if (r > mid) modify(t, l, r, x << 1 | 1);
    pushup(t, x);
}
void modify(int l, int r, int c, int x = 1) { //两棵树一起修改的
鸡血状态下会推掉所有邀约,所以要两棵树一起修改成1.
女神邀请时两颗树要一起修改成0,所以要从外部引入值。
    if (l <= t1[x].l && r >= t1[x].r) {
    两棵树的l,r是一样的,判一棵就行
        pushdown(t1[x], c), pushdown(t2[x], c);
        return;
    }
    pushdown(t1, x), pushdown(t2, x);
    int mid = t1[x].l + t1[x].r >> 1;
    if (l <= mid) modify(l, r, c, x << 1);
    if (r > mid) modify(l, r, c, x << 1 | 1);
    pushup(t1, x), pushup(t2, x);
}
int main()
{
    int T; cin >> T;
    rep(Case, T) {
        printf("Case %d:\n", Case);
        int n, m; scanf("%d %d", &n, &m);
        build(1, n);
        while (m--) {
            char s[10]; scanf("%s", s);
            if (*s == 'S') {
                int l, r; scanf("%d %d", &l, &r);
                modify(l, r, 1);
                赋值1,相当于一个清空的状态。
                printf("I am the hope of chinese chengxuyuan!!\n");
            }
            else {
                int x; scanf("%d", &x);
                if (*s == 'N') {
                    if (t1[1].fmax >= x) { //基友树有足够的时间
                        int l = findleft(t1, x);
                        modify(l, l + x - 1, 0);
                        赋值0,有约状态,
                        printf("%d,don't put my gezi\n", l);
                    }
                    else if (t2[1].fmax >= x){ //女神树有足够的时间
                        int l = findleft(t2, x);
                        modify(l, l + x - 1, 0);
                        printf("%d,don't put my gezi\n", l);
                    }
                    else printf("wait for me\n");
                }
                else if (*s == 'D') {
                    if (t1[1].fmax >= x) {
                        int l = findleft(t1, x);
                        modify(t1, l, l + x - 1);
                        printf("%d,let's fly\n", l);
                    }
                    else printf("fly with yourself\n");
                }
            }
        }
    }
    return 0;
}

经过模仿得到的acwing代码

#include 
#include 
#include 
#include 
using namespace std;
const int N = 1e5 + 10;
struct node{
	int l,r;
	int fmax,lmax,rmax;
	int lazy;
}t1[N<<2],t2[N<<2]; 
void pushdown(node &t,int lazy){
	t.fmax = lazy * (t.r - t.l + 1);
	t.lmax = t.rmax = t.fmax;
	t.lazy = lazy;
}
void pushdown(node t[],int u){
	if(t[u].lazy != -1){
		pushdown(t[u<<1],t[u].lazy),pushdown(t[u<<1|1],t[u].lazy);
		t[u].lazy = -1;
	}
}
void pushup(node&p,node&l,node&r){
	p.fmax = max(max(l.fmax,r.fmax),l.rmax + r.lmax);
	p.lmax = l.lmax + (l.lmax == l.r - l.l + 1 ? r.lmax : 0);
	p.rmax = r.rmax + (r.rmax == r.r - r.l + 1 ? l.rmax : 0);
}
void pushup(node t[],int u){
	pushup(t[u],t[u<<1],t[u<<1|1]);
}
void build(int u,int l,int r){
	t1[u] = t2[u] = {l,r,1,1,1,-1};
	if(l == r) return;
	int mid = l + r >> 1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
	pushup(t1,u),pushup(t2,u);
}


void modify(node tr[],int u,int l,int r){
	if(tr[u].l >= l && tr[u].r <= r){
		pushdown(tr[u],0);
		return;
	}
	pushdown(tr,u);
	int mid = tr[u].l + tr[u].r >> 1;
	if(l <= mid) modify(tr,u<<1,l,r);
	if(r > mid) modify(tr,u<<1|1,l,r);
	pushup(tr,u);
}
void modify(int u,int l,int r,int v){
	if(t1[u].l >= l && t1[u].r <=r ){
		pushdown(t1[u],v),pushdown(t2[u],v);
		return;
	}
	pushdown(t1,u),pushdown(t2,u);
	int mid = t1[u].l + t1[u].r >> 1;
	if(l <= mid) modify(u<<1,l,r,v);
	if(r > mid) modify(u<<1|1,l,r,v);
	pushup(t1,u),pushup(t2,u);
}
int main(){
	int t;
	cin >> t;
	for(int Case = 1;Case <= t;Case++){
		printf("Case %d:\n",Case);
		int  n,m;
		scanf("%d%d",&n,&m);
		build(1,1,n);
		while(m--){
			char s[10];
			scanf("%s",s);
			if(*s == 'S'){
				int l,r;
				scanf("%d%d",&l,&r);
				modify(1,l,r,1);
				printf("I am the hope of chinese chengxuyuan!!\n");
			}
			else{
				int x;
				scanf("%d",&x);
				if(*s == 'N'){
					if(t1[1].fmax >= x){
						int l = findleft(t1,1,x);
						modify(1,l,l+x-1,0);
						printf("%d,don't put my gezi\n", l);
					}
					else if(t2[1].fmax >= x){
						int l = findleft(t2,1,x);
						modify(1,l,l+x-1,0);
						printf("%d,don't put my gezi\n", l);
					}
                    else printf("wait for me\n");		
				}
				else if(*s == 'D'){
					if(t1[1].fmax >= x){
						int l = findleft(t1,1,x);
						modify(t1,1,l,l+x-1);
                        printf("%d,let's fly\n", l);
					}
                    else printf("fly with yourself\n");
				}
			}
		}
		
	}
	return 0;
}

套路

前提条件

给连续区间长度,求满足长度要求的连续区间端点。
######应对:
dfs,fmax,lmax,rmax,搜fmax,rmax+lmax,

int findleft(node tr[],int u,int v){
	if(tr[u].l == tr[u].r ) return tr[u].l;
	
	pushdown(tr,u);
	if(tr[u<<1].fmax >= v)return findleft(tr,u<<1,v);
	会递到第一个左子节点<v的位置,然后回归到最后一个左子节点<= v的位置,然后往下面的语句走。
	if(tr[u<<1].rmax +tr[u<<1|1].lmax >= v) return tr[u<<1].r - tr[u<<1].rmax + 1;
	中间的区间不符合要求,说明答案不在左子节点,就往右子节点递归。
	return findleft(tr,u<<1|1,v);
}

例题4最大连通区间维护,给点找连续区间长度

	找连续区间,用递归找,x点在的连续区间,长度大于n的连续区间。
	没有优先级,可以先找左子节点,也可以先找右子节点。
	和例题3的递归一样,x在左右子节点的合并区间或在叶子节点才返回具体的值。
	fmax不能用来确定x的位置,所以没有任何用,此题就没有使用fmax,只使用了
	lmax和rmax

套路:

前提条件:给点,找连续区间长度

应对,根据点与mid的值来确定在左右子节点,然后找

左rmax的左端点,
右lmax的右端点
看x在不在。在则返回左rmax+右lmax,
不在则继续搜左子节点(右子节点)
搜到叶子返回节点的lmax或rmax

int query(int u,int x){
	if(tr[u].l == tr[u].r) return tr[u].lmax;
	int mid = tr[u].l + tr[u].r >> 1;
	if(x <= mid){
		if(x>= tr[u<<1].r - tr[u<<1].rmax + 1) return tr[u<<1].rmax + tr[u<<1|1].lmax;
		return query(u<<1,x);
	}
	else{
		if(x<= tr[u<<1|1].l + tr[u<<1|1].lmax - 1) return tr[u<<1].rmax + tr[u<<1|1].lmax;
		return query(u<<1|1,x);   
	}
}

题解代码

#include 
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 5E4 + 10;
struct node {
    int l, r;
    int lmax, rmax; //左右最大连续长度
}t[N << 2];
void pushup(node& p, node& l, node& r) { //区间合并
    p.lmax = l.lmax + (l.lmax == l.r - l.l + 1 ? r.lmax : 0);
    p.rmax = r.rmax + (r.rmax == r.r - r.l + 1 ? l.rmax : 0);
}
void pushup(int x) { pushup(t[x], t[x << 1], t[x << 1 | 1]); }

void build(int l, int r, int x = 1) {
    t[x] = { l, r, 1, 1 };
    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 a, int c, int x = 1) {
    if (t[x].l == t[x].r) {
        t[x].lmax = t[x].rmax = c;
        return;
    }
    int mid = t[x].l + t[x].r >> 1;
    modify(a, c, x << 1 | (a > mid));
    pushup(x);
}

int ask(int a, int x = 1) {
    if (t[x].l == t[x].r) return t[x].lmax;

    int mid = t[x].l + t[x].r >> 1;
    if (a <= mid) { //表明a在左子树, 看看左子树右连续区间是否包含a点
        node& op = t[x << 1];
        if (a >= op.r - op.rmax + 1) return op.rmax + t[x << 1 | 1].lmax;
        询问a是否在从右往左最大连续的区间内,
        return ask(a, x << 1); //不包含a
    }
    else { //表明a在右子树, 看看右子树左连续区间是否包含a点
        node& op = t[x << 1 | 1];
        if (a <= op.l + op.lmax - 1) return op.lmax + t[x << 1].rmax;
        询问a是否在从左往右最大连续内,在则返回左右子节点的合并区间
        return ask(a, x << 1 | 1); //不包含a
        不在则继续搜
    }
}
int main()
{
    int n, m;
    while (~scanf("%d %d", &n, &m)) {
        stack<int> st; //记录最后被删除的点
        build(1, n);
        rep(i, m) {
            char s[2]; scanf("%s", s);
            if (s[0] == 'D') {
                int a; scanf("%d", &a);
                modify(a, 0);
                st.push(a);
            }
            else if (s[0] == 'Q') {
                int a; scanf("%d", &a);
                printf("%d\n", ask(a));
            }
            else modify(st.top(), 1), st.pop();
        }
    }
    return 0;
}


模仿后得到的acwing代码

#include 
#include 
#include 
#include 
#include 
using namespace std;
const int N = 5e4 + 10;
struct node{
	int l,r;
	int lmax,rmax;
	
}tr[N<<2];
void pushup(node &tr,node &l,node &r){
    tr.lmax = l.lmax + (l.lmax == l.r - l.l + 1 ? r.lmax : 0);
    tr.rmax = r.rmax + (r.rmax == r.r - r.l + 1 ? l.rmax : 0);
		 
}
void pushup(int u){
	pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}
void build(int u,int l,int r){
	tr[u] = {l,r,1,1};
	if(l == r) return;
	int mid = l + r >> 1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
	pushup(u);
}
int query(int u,int x){
	if(tr[u].l == tr[u].r) return tr[u].lmax;
	int mid = tr[u].l + tr[u].r >> 1;
	if(x <= mid){
		if(x>= tr[u<<1].r - tr[u<<1].rmax + 1) return tr[u<<1].rmax + tr[u<<1|1].lmax;
		 找到了直接返回值,因为第一次找到肯定是最接近根节点,最大的。
		return query(u<<1,x  );
		找连续区间,用递归找,x点在的连续区间,长度大于n的连续区间。
		没有优先级,可以先找左子节点,也可以先找右子节点。
		和例题3的递归一样,x在左右子节点的合并区间或在叶子节点才返回具体的值。
		fmax不能用来确定x的位置,所以没有任何用,此题就没有使用fmax,只使用了
		lmax和rmax
	}
	else{
		if(x<= tr[u<<1|1].l + tr[u<<1|1].lmax - 1) return tr[u<<1].rmax + tr[u<<1|1].lmax;
		return query(u<<1|1,x);   
	}
	
}
void modify(int u,int x,int v){
	if(tr[u].l == tr[u].r){
		tr[u].lmax = tr[u].rmax = 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);  
}
int main()
{
    int n, m;
    while (~scanf("%d %d", &n, &m)) {
        stack<int> st; //记录最后被删除的点
        可以连续修复,所以用stack存摧毁的位置,先进后出,栈顶就是最新的一个元素。
        build(1,1, n);
        for(int i= 1;i <= m;i++) {
            char s[2]; scanf("%s", s);
            if (s[0] == 'D') {
                int a; scanf("%d", &a);
                modify(1,a, 0);
                st.push(a);
            }
            else if (s[0] == 'Q') {
                int a; scanf("%d", &a);
                printf("%d\n", query(1,a));
            }
            else modify(1,st.top(), 1), st.pop();
        }
    }
    return 0;
}

习题1最大连续区间维护,例题3的简化版:

题链:

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

代码

#include 
#include 
#include 
#include 
using namespace std;
const int N = 5e4 + 10;
struct node{
	int l,    r;
	int fmax,lmax,rmax;
	int lazy;
}tr[N<<2];
void pushdown(node &tr,int lazy){
	tr.fmax = lazy * (tr.r - tr.l + 1);
	tr.lmax = tr.rmax = tr.fmax;
	tr.lazy = lazy;
}
void pushdown(int u){
	if(tr[u].lazy != -1){
		pushdown(tr[u<<1],tr[u].lazy) ,pushdown(tr[u<<1|1],tr[u].lazy);
		tr[u].lazy = -1;
	}
}
void pushup(node &tr,node &l,node &r){
	tr.fmax = max(max(l.fmax,r.fmax),l.rmax + r.lmax);
	tr.lmax = l.lmax + (l.lmax == l.r - l.l + 1 ? r.lmax : 0);
	tr.rmax = r.rmax + (r.rmax == r.r - r.l + 1 ? l.rmax : 0);
}
void pushup(int u){
	pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}
void build(int u,int l,int r){
	tr[u].l = l,tr[u].r = r,tr[u].fmax  = tr[u].lmax = tr[u].rmax = 1,tr[u].lazy = -1;
	if(l == r) return;
	int mid = l + r >> 1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
	pushup(u);
}
int findleft(int u,int v){
	if(tr[u].l == tr[u].r) return tr[u].l;
	pushdown(u);
	if(tr[u<<1].fmax >= v) return findleft(u<<1,v);
	if(tr[u<<1].rmax + tr[u<<1|1].lmax >= v) return tr[u<<1].r - tr[u<<1].rmax + 1;
	return findleft(u<<1|1,v);
}
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;
	build(1,1,n);
	while(m--){
		int op;
		scanf("%d",&op);
		if(op == 1){
			int x;
			scanf("%d",&x);
			if(tr[1].fmax >= x) {
				int l = findleft(1,x);
				printf("%d\n",l);
				modify(1,l,l+x-1,0);
			}
			else {
				printf("0\n");
			}
			
		}
		else{
			int l,r;
			scanf("%d%d",&l,&r);
			modify(1,l,l+r-1,1);
		}
	}
	return 0;
}

习题2批量替换,例题1的变式

就只是根据操作变了个pushdown。
根节点tr[1].sum,查询树的总和

代码

#include 
#include 
#include 
#include 
using namespace std;
const int N = 1e5 + 10;
struct node{
	int l,r;
	int sum;
	int lazy;
}tr[N<<2];
void pushdown(node &tr,int lazy){
	tr.sum = lazy * (tr.r - tr.l + 1);
	tr.lazy = lazy;
}
void pushdown(int u){
	if(tr[u].lazy != -1){
		pushdown(tr[u<<1],tr[u].lazy),pushdown(tr[u<<1|1],tr[u].lazy);
		tr[u].lazy = -1;
	}
}
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,1,-1};
	if(l == r) return;
	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 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 t;
	cin >> t;
	for(int Case = 1;Case <= t;Case++){
		int n,m;
		scanf("%d%d",&n,&m);
		build(1,1,n);
		while(m--){
			int l,r,v;
			scanf("%d%d%d",&l,&r,&v);
			modify(1,l,r,v);
		}
		
		printf("Case %d: The total value of the hook is %d.\n",Case,tr[1].sum);
	}
	return 0;
}

2.批量自适应修改

题链

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

卡壳点:

忘记build,递归的 tr[u].l == tr[u].r == 写成 =
区间修改,题目给的时l和len,以为是l和r导致错误
用l和len表示r错误,写成了l + len,应该是l + len -1 ;

代码

#include 
#include 
#include 
#include 
using namespace std;
const int N = 5e4 + 10;
struct node{
	int l,    r;
	int fmax,lmax,rmax;
	int lazy;
}tr[N<<2];
void pushdown(node &tr,int lazy){
	tr.fmax = lazy * (tr.r - tr.l + 1);
	tr.lmax = tr.rmax = tr.fmax;
	tr.lazy = lazy;
}
void pushdown(int u){
	if(tr[u].lazy != -1){
		pushdown(tr[u<<1],tr[u].lazy) ,pushdown(tr[u<<1|1],tr[u].lazy);
		tr[u].lazy = -1;
	}
}
void pushup(node &tr,node &l,node &r){
	tr.fmax = max(max(l.fmax,r.fmax),l.rmax + r.lmax);
	tr.lmax = l.lmax + (l.lmax == l.r - l.l + 1 ? r.lmax : 0);
	tr.rmax = r.rmax + (r.rmax == r.r - r.l + 1 ? l.rmax : 0);
}
void pushup(int u){
	pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}
void build(int u,int l,int r){
	tr[u].l = l,tr[u].r = r,tr[u].fmax  = tr[u].lmax = tr[u].rmax = 1,tr[u].lazy = -1;
	if(l == r) return;
	int mid = l + r >> 1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
	pushup(u);
}
int findleft(int u,int v){
	if(tr[u].l == tr[u].r) return tr[u].l;
	pushdown(u);
	if(tr[u<<1].fmax >= v) return findleft(u<<1,v);
	if(tr[u<<1].rmax + tr[u<<1|1].lmax >= v) return tr[u<<1].r - tr[u<<1].rmax + 1;
	return findleft(u<<1|1,v);
}
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;
	build(1,1,n);
	while(m--){
		int op;
		scanf("%d",&op);
		if(op == 1){
			int x;
			scanf("%d",&x);
			if(tr[1].fmax >= x) {
				int l = findleft(1,x);
				printf("%d\n",l);
				modify(1,l,l+x-1,0);
			}
			else {
				printf("0\n");
			}
			
		}
		else{
			int l,r;
			scanf("%d%d",&l,&r);
			modify(1,l,l+r-1,1);
		}
	}
	return 0;
}

前提条件

是区间修改,区间查询,且修改操作的修改的值是根据具体节点储存的值而变化的,比如开根,幂,替换,乘除;
新做的题里发现替换可以直接批量赋值来实现,属于等值修改。


情景

对一个序列里的元素执行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].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){
只有叶子节点才能初始化成lazy1
	if(l == r){
		tr[u] = {l,r,0,1};
		 return;
	}
	tr[u] = {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 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,因为代表的含义是两个子节点值是否相等

懒标记区间自适应修改至少耗时2s,如果能操作简单,能用简单的语句来确定是否可以省略操作(如例题1tr[u].r - tr[u].l + 1) == tr[u].sum)判断区间内是否全为1而可以省略掉区间开方操作。

其他套路:

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

习题1开方单点剪枝1e5 + 2e5,常数n为6以内:

题链

花神游历各国
22ACM集训队-树状数组与线段树基础 - Virtual Judge (vjudge.net)


比较

与例题1是同一题型,但例题1的题解里没有用到fmax来维护区间最大值,而是直接用
tr[u].sum 与 tr[u].r - tr[u].l +1 是否相等来判断是否return。
例题1的做法仅限于元素最小是1的情况下,
习题1的元素最小为0,所以不能用这种做法。
于是归结出第一个剪枝套路

卡壳点:

没注意node内的maxn也要在modify内开方。
注意操作时除了l,r之外的属性基本都要处理
build初始化,注意叶子节点和根节点的初始化可能会不同。


代码

#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
struct node{
	int l,r;
	ll sum;
	int maxn;
}tr[N<<2];
ll w[N];
void pushup(int u){
	tr[u].sum = tr[u<<1].sum + tr[u<<1|1].sum;
	tr[u].maxn = max(tr[u<<1].maxn,tr[u<<1|1].maxn);
}
void build(int u,int l,int r){
	if(l == r){
		tr[u] = {l,r,w[r],w[r]};
		return;
	}tr[u] = {l,r,0,0 };
//	cout << w[r] << endl;
	
	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].maxn <= 1) return;

	if(tr[u].l == tr[u].r) {
	tr[u].sum = sqrt(tr[u].sum);       tr[u].maxn = sqrt(tr[u].maxn);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);
//            cout << l << " " << r << endl;
            if (op==1) printf("%lld\n", query(1,l, r));
            else modify(1,l, r);
        }
        printf("\n");
    }
    return 0;
}

套路:

区间单点修改开平方剪枝:

前提条件,

对区间进行开平方,并需要动态维护区间和:

应对

节点中用fmax维护区间最值,modify时区间最值<=1就直接return。
如果节点值最小是1的话,直接通过判断tr[u].sum 与 tr[u].r - tr[u].l +1 是否相等可以确定是否需要剪枝。(区间值全为1)

3.区间染色

普通例题

题链

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

套路:

lazy代替sum:

前提条件:

题目不需要求区间长度,操作时各种值无优先级,在区间上互相进行区间覆盖操作,求最后的状态。

情景

操作之间存在覆盖,遮挡的影响

之前画的一些线段可能会被后面的一些线段所覆盖
给出每张海报所贴的范围li,ri(1<=li<=ri<=10000000) 。求出最后还能看见多少张海报。
疑问

染过色后lazy被pushdown下移会不会有影响?
:modify经过lazy所在节点时,也就是lazy底下有节点被另外染色了此时lazy下移,这个节点没资格再代表其下的所有节点了。
判断是否颜色相同可以用个pushup,见批量自适应修改里的例题2多种操作里的pushup,但没什么必要。

代码

统计颜色种类及段数。
卡壳点:segment fault
用N作为下标访问元素时要养成写N-1的习惯,防止出现数组越界

#include 
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E4 + 10;
cou要开8011
int cou[N];
struct node {
    int l, r;
    int lazy;
}t[N << 2];
void pushdown(node& op, int lazy) { 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) {
	t[x] = { l, r, 0 };
    if (l == r) return;
    int mid = l + r >> 1;
    build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
}

void modify(int l, int r, int c, int x = 1) {
    if (l <= t[x].l && r >= t[x].r) { pushdown(t[x], c); return; }
    写错条件成叶子节点。
    pushdown(x);
    int mid = t[x].l + t[x].r >> 1;
    忘记/2
    if (l <= mid) modify(l, r, c, x << 1);
    if (r > mid) modify(l, r, c, x << 1 | 1);
    忘记变成x<<1|1
}

int last = 0; //表示上一次碰到的颜色, 记得当遍历叶子结点时没有颜色的时候也要记录.
void ask(int x = 1) {
	
    if (last != t[x].lazy) cou[t[x].lazy]++;
    判断是否间隔开
    if (t[x].lazy || t[x].l == t[x].r) { last = t[x].lazy; return; }
    当前节点lazy不为0,表示当前节点下的所有节点都经过区间修改,变成一样的颜色,不用再继续深入。
    //	有标记直接进上面的语句了,不需要pushdown 
    遍历整棵树
    ask(x << 1), ask(x << 1 | 1);
    先左后右保证last一定在t[x]的左边
}
int main()
{
    int n;
    while (~scanf("%d", &n)) {
        build(1, 8010); last = 0;  
        memset(cou, 0, sizeof cou);
        o1查询的优化。
        rep(i, n) {
            int l, r, c; scanf("%d %d %d", &l, &r, &c);
            modify(l + 1, r, c + 1); //这里是为了让建树区间下标从1开始, 涂色记录也从1开始
        }
        ask();
        rep(i, 8010) if (cou[i]) printf("%d %d\n", i - 1, cou[i]);
        printf("\n");
    }
    return 0;
}

离散化例题

离散化,下标很大,值很小

我们看这组数据[1,10],[1,3],[6,10],很明显答案是3
但是离散化之后为[1,4],[1,2],[3,4],答案变成了2
为解决这种问题,我们可以在更新线段树的时候将区间从[l,r]变成[l,r-1],就将区间转化成了[1,3],[1,1],[3,3]这样的树
但是当我们遇到这样的数据[1,3],[1,1],[2,2],[3,3],就会导致区间更新时出错,我们可以将初始数据的r都加上1,就排除了li和ri相等的情况,如果没有这种情况,离散化后的区间也都是一样的
其实这道题数据很弱,不管这样的情况也能过(逃
正解https://www.luogu.com.cn/paste/vl2ora2z

#include 
#include 
#include 
#include 
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E5 + 10;
bool vis[N]; //标记是否已经出现过第i张海报
struct node {
   int l, r;
   int id; //id表示lazy标签, 也表示当前节点值. 
}t[N << 2];
vector<int> v; vector<pair<int, int> > area; //v为离散化数组, area存放海报区间
int find(int x) { return lower_bound(v.begin(), v.end(), x) - v.begin(); }
离散化用
void pushdown(node& op, int id) { op.id = id; }
void pushdown(int x) {
   if (!t[x].id) return;
   pushdown(t[x << 1], t[x].id), pushdown(t[x << 1 | 1], t[x].id);
   t[x].id = 0; 
}
//因为线段树内部不维护任何数值, 所以也可以省去pushup这一操作.

void build(int l, int r, int x = 1) {
   t[x].l = l,t[x].r = r,t[x].id = 0 ;//id: 特别的, 如果0也是染色的点, 那么应初始化为-1
   if (l == r) return;
   int mid = l + r >> 1;
   build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
}

void modify(int l, int r, int c, int x = 1) {
   if (l <= t[x].l && r >= t[x].r) { pushdown(t[x], c); return; }
   pushdown(x);
   int mid = t[x].l + t[x].r >> 1;
   if (l <= mid) modify(l, r, c, x << 1);
   if (r > mid) modify(l, r, c, x << 1 | 1);
}

int ask(int x = 1) { 
   if (t[x].id) { //当前子树均为同一值, 没必要再递归下去了
       if (vis[t[x].id]) return 0;
       return vis[t[x].id] = 1;
   }
   if (t[x].l == t[x].r) return 0; //到叶子结点一定要结束递归
   
   return ask(x << 1) + ask(x << 1 | 1);
}

int main()
{
   int T; cin >> T; 
   while (T--) {
       v.clear(); v.push_back(-0x3f3f3f3f); //这里是为了离散化下标从1开始
       area.clear();
       int n; scanf("%d", &n);
       rep(i, n) {
           vis[i] = 0; //顺带初始化vis
           int l, r; scanf("%d %d", &l, &r);
           r++; 
           v.push_back(l), v.push_back(r);
           area.push_back(make_pair(l,r));
       }
       
       /* 离散化部分 */
       sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());
       rep(i, n) if (v[i] - v[i - 1] != 1) v.push_back(v[i] - 1); //记为*
       sort(v.begin(), v.end());
       
       build(1, v.size() - 1); //因为我的v数组有个-INF, 所以实际的建树大小应为v.size()-1
       
       for (int i = 0; i < n; ++i) {
           int l = area[i].first, r = area[i].second;
           l = find(l), r = find(r);
           modify(l, r-1, i + 1); //个人习惯编号从1开始
       }
       printf("%d\n", ask());
   }
   return 0;
}

区别

区间等值修改里,
lazy存的是子树中所有节点要修改的值或要修改成的值,根据题意决定初始化的值,如例题1中批量+v操作,初始化为0,例题2批量替换,初始化为v的定义域之外的值。
sum存的是子树所有节点sum的总和 ,一般初始化为0.
是一个修改时给节点打上lazy,遇到lazy时解开lazy的过程。

区间自适应修改里,
lazy作为一个bool变量,存的是当前节点是否能代表子树接受修改,根据题意决定初始化的值
sum只有在lazy为1时有实际意义,
存的是这颗所有节点的值都相同的子树里的这个相同的值
修改值时,直接修改节点的值

你可能感兴趣的:(树状数组与线段树,c++,算法,开发语言)