线段树骚操作总结

线段树小结

对线段树基础的深入理解

线段树简介

线段树是二叉搜索树的一种,维护[1,N]区间中的值,左儿子维护[1,N>>1]的值,右儿子维护[N>>1|1,1]的值,不断递归,最后每个节点都能维护一段区间的值,非常擅长处理区间动态问题,每次操作的复杂度是O(logn)。就我学习的这段时间我认为大多数一维线性区间问题都可以利用线段树去做,而二维平面问题可以利用扫描线降维成一维来使用线段树,总之是非常强大的工具。
然而网上的大多数博客总是把有关线段树的一些骚操作全部分开来讲,找好的总结博客实在太累,这边小结一下方便自己以后回忆。

基础框架

基础框架是学的HH大神的线段树板子(密码:wmju),框架异常清晰,不愧是大神%%%,我自己习惯把树维护的东西全都封装在结构体里,这样敲起来虽然烦,但是看上去比较好理解(大概)。
线段树总体框架分为5个函数,下面介绍的几个骚操作都使用了下面至少两个框架:

struct TREE{
    //线段树
}tree[N<<2];
// << 左移运算符,相当于*2^n操作
// >> 右移运算符,相当于/2^n操作
// |  或运算符
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define ls rt<<1
#define rs rt<<1|1
void pushup(){
    //节点上传
}
void pushdown(){
    //标记下传
}
void build(){
    //建树
}
void update(){
    //区间更新
}
void query(){
    //区间询问
}

区间统计

给你一段区间,区间中的每个点都维护着一个值,问[L,R]区间中所有点的值的总和。
线段树的基础用法,维护不同区间中的和,思路也比较简单。
例题:找不到只考区间统计的题,下面会有题用到。

区间最值

一段区间内每个点都维护着一个值,问[L,R]区间中的最值是多少
线段树基础用法+1,不过是区间统计维护每个点的总和改为最值,思路简单+1
例题:HDU 1754: I Hate It(区间修改+区间最值)
题意:两种操作,第一种操作询问[A,B]区间的最高成绩,第二种是将A同学的成绩改成B。单点修改+区间最值板子题(单点修改在下面会介绍)。不过这题我利用树状数组去做了,目前没有线段树的实现(树状数组敲这题有点烦)

单点修改

一段区间内每个点都维护着一个值,但是会对单个点进行修改,然后在修改的过程中问你以上两种询问。
线段树基础用法+2,基础思路是update到最后一个点(目标点),然后在回溯的过程中不断pushup更新父节点。
例题:HDU 1166:敌兵布阵(单点修改+区间统计)
题意:初始给你敌军营地每个军营的敌人数量,有三种操作,第一二种表示第i个军营增加或者减少j个敌人,然后第三种操作是询问区间[i,j]敌人的数量。线段树单点修改区间访问板子题。

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "< pii;
typedef vector vi;
int tree[200005];
void pushup(int rt){
    tree[rt] = tree[rt<<1]+tree[rt<<1|1];//统计左右儿子的和
}
int build(int l, int r, int rt){//建树
    if(l == r){
        cin >> tree[rt];
        return tree[rt];
    }
    int mid = (l + r) >> 1;
    return tree[rt] = build(l, mid, rt<<1) + build(mid+1, r, rt<<1|1);
}
void update(int p, int t, int l, int r, int rt){//更新
    if(l == r){
        tree[rt] += t;
        return;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) update(p, t, l, mid, rt<<1);
    else update(p, t, mid+1, r, rt<<1|1);
    pushup(rt);
}
int query(int L, int R, int l, int r, int rt){//询问
    if(L<=l && r<=R) return tree[rt];
    int mid = (l + r)>>1;
    int sum = 0;
    if(L <= mid) sum += query(L,R,l,mid,rt<<1);
    if(mid+1 <= R) sum += query(L,R,mid+1,r,rt<<1|1);
    return sum;
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    int n;
    int T;
    cin >> T;
    int t = 0;
    while(T--){
        cin >> n;
        cout << "Case " << ++t << ':' << endl;
        build(1,n,1);
        string s;
        while(cin >> s){
            if(s == "End") break;
            int i,j;
            cin >> i >> j;
            if(s == "Query") cout << query(i,j,1,n,1) << endl;
            if(s == "Add") update(i, j, 1, n, 1);
            if(s == "Sub") update(i, -j, 1, n, 1);
        }
    }
    return 0;
}

区间修改

一段区间内每个点都维护着一个值,但是会对一段区间的每个点进行修改,然后在修改的过程中问你以上两种询问。
线段树基础用法,基础思路是update到区间内的最后一个点(目标点),然后在回溯的过程中不断pushup更新父节点,但是对于一些数据量不是很大的题目中这么做及时单步操作不止 O(logn)也会超时,多数情况下就要用到后面会将的lazy-tag(懒惰标记)了。
例题:POJ 3468:A Simple Problem with Integers(区间修改+区间统计+懒惰标记)
题意:给定初始值,两种操作,一种是在区间[a,b]上增加c,另一种是询问区间[a,b]的和。区间修改+区间统计板子题。不过这题由于数字区间太大,直接开这么大的线段树妥妥炸,需要离散化

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "< pii;
typedef vector vi;
struct TREE{
    ll sum, lay;
}tree[(100005)<<2];
void pushup(int rt){//统计左右儿子的和
    tree[rt].sum = tree[rt<<1].sum + tree[rt<<1|1].sum;
}
void pushdown(int rt, int i){//下传标记
    if(tree[rt].lay){
        ll lay = tree[rt].lay;
        tree[rt].lay = 0;//注意清除标记
        tree[rt<<1].lay += lay;
        tree[rt<<1|1].lay += lay;
        tree[rt<<1].sum += lay*(i-(i>>1));
        tree[rt<<1|1].sum += (i>>1)*lay;
    }
}
void build(int l,int r,int rt){//建树
    if(l == r){
        scanf("%lld", &tree[rt].sum);
        return;
    }
    int mid = (l+r)/2;
    build(l, mid, rt<<1);
    build(mid+1, r, rt<<1|1);
    pushup(rt);
    return;
}
void update(int t, int L, int R,int l, int r, int rt){//更新
    if(L <= l && r <= R){//到这里更新就可以结束了
        tree[rt].lay += t;//打个标记,剩下的让标记完成
        tree[rt].sum += t*(r-l+1);
        return;
    }
    pushdown(rt, r-l+1);
    int mid = (l+r)/2;
    if(L <= mid) update(t,L,R,l,mid,rt<<1);
    if(R > mid) update(t,L,R,mid+1,r,rt<<1|1);
    pushup(rt);
}
ll query(int L,int R,int l,int r,int rt){//查询
    if(L <= l && r <= R){
        return tree[rt].sum;
    }
    pushdown(rt, r-l+1);//记得下放标记
    ll sum = 0;
    int mid = (l+r)/2;
    if(L <= mid) sum += query(L,R,l,mid,rt<<1);
    if(mid < R) sum += query(L,R,mid+1,r,rt<<1|1);
    return sum;
}
int main()
{
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    int n,m;
    cin >> n >> m;
    build(1,n,1);
    while(m--){
        char q;
        int a,b;
        cin >> q;
        scanf("%d%d", &a, &b);
        if(q == 'C'){
            int c;
            scanf("%d", &c);
            update(c,a,b,1,n,1);
        }
        if(q == 'Q')
            cout << query(a,b,1,n,1) << endl;
    }
    return 0;
}

以上都是线段树的基础操作,接下来总结一下基础的骚操作

lazy-tag(懒惰标记)

对于一段区间的更新,多数情况下可能是不需要更新的那么详细的,因为询问操作很有可能到这一步就截然而止了,儿子的大小并不会被询问函数关注到,因此儿子的更新在这种情况下并不显得那么重要,所以更新时完全没必要更新到儿子。
打个比方,比如我现在在[1,10]这段区间中需要更新,但是我在下一次询问的时候询问[1,5],很显然[1,3]和[4,5]以及它们的子区间并不会被询问到,因此我只需要更新到[1,5]区间就可以了。但是,加入你下下次的询问区间[1,3],这个时候如果不更新节点,那么这次的更新就会失效!因为你的更新在[1,5]就停止了!那么怎么办呢?我可不可以做一个标记,在我询问[1,3]区间的时候就可以利用这个标记继续更新[1,3]了!这个标记就叫lazy-tag,中文名懒惰标记。
但是懒惰标记对于初学者来说是学习线段树的第一道坎,对于每一种操作的标记不仅有不同的叠加方式,对于多种标记共同存在的情况顺序还不好处理,确实是要花一定时间思考的。
例题:HDU 4578:Transformation(区间修改+区间统计+懒惰标记)
题意:四种操作,第一种是将[x,y]区间替换成c,第二种是将[x,y]区间全部加c,第三种是将[x,y]区间全部乘c,第四种是询问[x,y]区间所有的值的p方和(1≤p≤3)。
题解:懒惰标记教你做人题,标记关系和维护方案都很难理解,码量也在惊人的200行,DeBug都能累死。
好在只要求1-3次方的和,那么我们就维护三棵线段树:区间一次方的和二次方的和三次方的和,更新时三棵树同时更新。
讲一下多种标记如何解决。第一种标记set标记比较简单粗暴,直接把add标记和mul标记清空(注意,加懒惰标记清为0,乘懒惰标记清为1),优先级最高。
接着是mul和add标记,比较难处理他们的关系,我们用一个例子解释

假设原来的值为x,它首先经历了乘法标记a,变成a*x。接下来加进来一个值b,变成了(ax+b),然后现在关键来了,我们乘进来一个值c,那么原本的乘法标记(mullazy == a)和加法标记(addlazy == b)要怎么处理呢?先观察它乘进来是啥:(ax+b)*c,根据分配率,它会变成a*cx+b*c,那么乘法标记不就是(mullazy == a*c),加法标记就是(addlazy == b*c),而这时再加一个d,(mullazy*x+addlazy)+d,也就addlazy+=d了,也就是说:当一个乘法标记a进来时,mullazy = a,addlazy = a;而一个加法标记b进来时,只要addlazy += b即可,而且从例子中也可以看出,对于值x,在处理时先乘上mullazy,在加上addlazy,即 X = (mullazy*x + addlazy)

接下来就是p次方的和了,这需要用到这个:

(a+b)^2 = a^2+2ab+b^2
(a+b)^3 = a^3 + 3a^2b + 3ab^2 + c^3

我们虽然可以很快的得到答案,但是在加法懒惰标记的更新上,我们需要用到上面的公式。即

(sum1+a) = sum1+a
(sum2+a)^2 = sum2 + 2sum2*a + a^2
(sum3+a)^3 = sum3 + 3sum3^2*a + 3sum3*a^2 + a^3

具体操作还是看代码吧

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "< pii;
typedef vector vi;
const int mod = 10007;
struct TREE {
    ll sum1, sum2, sum3, add, mul, sets;
    //sum1:一次方的和
    //sum2:二次方的和
    //sum3:三次方的和
    //剩下的是标记
}tree[100005 << 2];
inline void Set(ll sets,int rt,ll i) {//重置标记操作
    tree[rt].sum1 = (sets*i) % mod;
    tree[rt].sum2 = (sets*sets*i) % mod;
    tree[rt].sum3 = (sets*sets*sets*i) % mod;
}
inline void Add(ll add,int rt,ll i) {//加标记操作
    tree[rt].add = (tree[rt].add + add) % mod;
    tree[rt].sum3 = (tree[rt].sum3 + (add*add*add*i % mod) + 3 * add*((tree[rt].sum2 + tree[rt].sum1*add) % mod) % mod) % mod;
    tree[rt].sum2 = (tree[rt].sum2 + (add*add*i % mod + (2 * add*tree[rt].sum1) % mod) % mod) % mod;
    tree[rt].sum1 = (tree[rt].sum1 + add * i % mod) % mod;
}
inline void Mul(ll mul, int rt) {//乘标记操作
    tree[rt].mul = (tree[rt].mul*mul) % mod;
    tree[rt].add = (tree[rt].add*mul) % mod;
    tree[rt].sum1 = (tree[rt].sum1*mul) % mod;
    tree[rt].sum2 = (tree[rt].sum2*mul*mul) % mod;
    tree[rt].sum3 = (tree[rt].sum3*mul*mul*mul) % mod;
}
//以上操作在上面又讲
inline void pushup(int rt) {//上传左右儿子的和
    tree[rt].sum1 = (tree[rt << 1].sum1 + tree[rt << 1 | 1].sum1) % mod;
    tree[rt].sum2 = (tree[rt << 1].sum2 + tree[rt << 1 | 1].sum2) % mod;
    tree[rt].sum3 = (tree[rt << 1].sum3 + tree[rt << 1 | 1].sum3) % mod;
}
inline void pushdown(int rt, int i) {//下传标记,注意优先级
    if (tree[rt].sets != 0) {
        ll sets = tree[rt].sets;
        tree[rt].sets = 0;
        tree[rt << 1].sets = tree[rt << 1 | 1].sets = sets;
        Set(sets, rt << 1, i - (i >> 1));
        Set(sets, rt << 1 | 1, (i >> 1));
        tree[rt << 1].add = tree[rt << 1 | 1].add = 0;
        tree[rt << 1].mul = tree[rt << 1 | 1].mul = 1;
    }
    if (tree[rt].mul != 1) {
        ll mul = tree[rt].mul;
        tree[rt].mul = 1;
        Mul(mul, rt << 1);
        Mul(mul, rt << 1 | 1);
    }
    if (tree[rt].add != 0) {
        ll add = tree[rt].add;
        tree[rt].add = 0;
        Add(add, rt << 1, i - (i >> 1));
        Add(add, rt << 1 | 1, i >> 1);
    }
}
inline void update(ll t, ll q, ll L, ll R, int l, int r, int rt) {//更新
    if (tree[rt].mul == 0) tree[rt].mul = 1;//这个是初始化乘法标记用的,循环初始化居然会T,8秒诶,用个memset快了6秒多!
    if (L <= l && r <= R) {//更新到这里就可以停了,记得打标记
        if (q == 1) {
            Add(t, rt, r - l + 1);
        }
        if (q == 2) {
            Mul(t, rt);
        }
        if (q == 3) {
            tree[rt].mul = 1;
            tree[rt].add = 0;
            tree[rt].sets = t;
            Set(t, rt, r - l + 1);
        }
        return;
    }
    pushdown(rt, r - l + 1);
    int mid = (l + r) >> 1;
    if (L <= mid) update(t, q, L, R, l, mid, rt << 1);
    if (mid < R) update(t, q, L, R, mid + 1, r, rt << 1 | 1);
    pushup(rt);
    return;
}
inline ll query(ll t, ll L, ll R, int l, int r, int rt) {//询问
    if (L <= l && r <= R) {
        if (t == 1)
            return tree[rt].sum1;
        if (t == 2)
            return tree[rt].sum2;
        if (t == 3)
            return tree[rt].sum3;
    }
    pushdown(rt, r - l + 1);
    int mid = (l + r) >> 1;
    ll a = 0, b = 0;
    if (L <= mid) a = query(t, L, R, l, mid, rt << 1);
    if (mid < R) b = query(t, L, R, mid + 1, r, rt << 1 | 1);
    return (a + b) % mod;
}
int main()
{
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        if (n == 0)break;
        memset(tree, 0, sizeof tree);
        while (m--) {
            ll op, x, y, c;
            scanf("%lld%lld%lld%lld", &op, &x, &y, &c);
            if (op != 4) {
                update(c, op, x, y, 1, n, 1);
            }
            else {
                printf("%lld\n", query(c, x, y, 1, n, 1));
            }
        }
    }
    return 0;
}

区间合并

给你一段区间,询问区间[l,r]中的最长连续区间,这时候就要用到区间合并了。
区间合并线段树的定义:

struct TREE{
    int len;//这个节点维护的区间长度
    int maxl,maxr,max;
    //maxl:区间[l,r]中从l开始的区间的长度
    //maxr:区间[l,r]中从r开始的区间的长度
    //max:区间[l,r]中的最大长度
}tree[N<<2];

每个节点维护的值可以用下面三张图表示
(待补)
区间合并真正让人难以理解的是区间合并的pushup函数

#define ls rt<<1
#define rs rt<<1|1
void pushup(int rt){
    tree[rt].max = max(tree[ls].maxr+tree[rs].maxl, max(tree[ls].maxl,tree[rs].maxr));
    tree[rt].maxl = (tree[ls].maxl == tree[ls].len) ? tree[ls].maxl + tree[rs].maxl : tree[ls].maxl;
    tree[rt].maxr = (tree[rs].maxr == tree[rs].len) ? tree[rs].maxr + tree[ls].maxr : tree[rs].maxr;
}

解释一下这三个值的维护方式:
> 1、对于tree[rt].max,按照上面三张图的解释就不难理解了,寻找左儿子的左连续区间右儿子的右连续区间左儿子右连续区间与右儿子右连续区间之和三者的最大值,就是这个点最大的连续区间。
>2、对于tree[rt].maxl,它虽然可以直接继承左儿子的左连续区间,但是有一个特殊情况,如果左儿子的左连续区间与他的长度相等,那么它有可能可以衔接上右儿子的左连续区间
>3、对于tree[rt].maxr,同理2

很多人不理解2和3的原因,这里再用一张图解释
(待补)
衔接上右儿子的左连续区间后才是作为父亲的总的左连续区间,这就是区间合并
操作完pushup之后,tree[1].max就是要求的最大连续区间啦~
什么,你想知道[L,R]的最大连续区间?那就写query函数询问吧

int query(int L,int R,int l,int r,int rt){
    if(tree[rt].max == 0 || tree[rt].max == r - l + 1)  return tree[rt].max;
    int mid = (l+r)>>1;
    if(l <= mid)return r > mid - tree[rt].maxr ? tree[rt].maxr + tree[rp].maxl : query(L,R,lson);
    else return r <= tree[rt].maxl + mid ? tree[tr].maxl + tree[tr].maxr : query(L,R,rson);
}

例题:HDU 4553:约会安排(区间合并)
题意:小明是个屌丝,帮他安排时间规划,题目有点绕,可以去上面的链接看。
题解:我觉得这题不能作为区间合并的板子题,然而集训的时候唯一的一题区间合并居然这么难。。开两棵树分别维护女神时间和屌丝时间,女神时间的优先级大于屌丝时间,给屌丝安排时间的时候只要问屌丝树有没有长度满足就可以了,而给女神安排时间需要先询问女神树,有满足长度的时间再去屌丝树上放屌丝的gezi

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "< pii;
typedef vector vi;
const int maxn = 100000;
struct TREE {
    int len;
    int nsmaxr, nsmaxl, nsmax;//屌丝树
    int dsmaxr, dsmaxl, dsmax;//女神树
    int nslay, dslay, sxlay;//标记,最后一个是学习标记
}tree[maxn << 2];
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,ls
#define rson mid+1,r,rs
void ds(int rt) {//屌丝标记操作
    tree[rt].dslay = 1;
    tree[rt].dsmax = tree[rt].dsmaxl = tree[rt].dsmaxr = 0;
}
void ns(int rt) {//女神标记操作
    tree[rt].nslay = 1;
    tree[rt].dslay = 0;
    tree[rt].dsmax = tree[rt].dsmaxl = tree[rt].dsmaxr = 0;
    tree[rt].nsmax = tree[rt].nsmaxl = tree[rt].nsmaxr = 0;
}
void sx(int rt) {//学习标记操作
    tree[rt].dslay = tree[rt].nslay = 0;
    tree[rt].sxlay = 1;
    tree[rt].nsmax = tree[rt].nsmaxl = tree[rt].nsmaxr = tree[rt].len;
    tree[rt].dsmax = tree[rt].dsmaxl = tree[rt].dsmaxr = tree[rt].len;
}
void pushup(int rt) {//区间合并
    tree[rt].dsmax = max(tree[ls].dsmaxr + tree[rs].dsmaxl, max(tree[ls].dsmax, tree[rs].dsmax));
    tree[rt].dsmaxl = (tree[ls].dsmaxl == tree[ls].len) ? tree[ls].dsmaxl + tree[rs].dsmaxl : tree[ls].dsmaxl;
    tree[rt].dsmaxr = (tree[rs].dsmaxr == tree[rs].len) ? tree[rs].dsmaxr + tree[ls].dsmaxr : tree[rs].dsmaxr;

    tree[rt].nsmax = max(tree[ls].nsmaxr + tree[rs].nsmaxl, max(tree[ls].nsmax, tree[rs].nsmax));
    tree[rt].nsmaxl = (tree[ls].nsmaxl == tree[ls].len) ? tree[ls].nsmaxl + tree[rs].nsmaxl : tree[ls].nsmaxl;
    tree[rt].nsmaxr = (tree[rs].nsmaxr == tree[rs].len) ? tree[rs].nsmaxr + tree[ls].nsmaxr : tree[rs].nsmaxr;
}
void pushdown(int rt) {//下传标记,同样注意优先级
    if (tree[rt].sxlay) {
        sx(ls);
        sx(rs);
        tree[rt].sxlay = 0;
    }
    if (tree[rt].dslay) {
        ds(ls);
        ds(rs);
        tree[rt].dslay = 0;
    }
    if (tree[rt].nslay) {
        ns(ls);
        ns(rs);
        tree[rt].nslay = 0;
    }
}
void build(int l, int r, int rt) {//建树,初始化
    tree[rt].len = r - l + 1;
    tree[rt].nslay = tree[rt].dslay = tree[rt].sxlay = 0;
    if (l == r) {
        tree[rt].dsmax = tree[rt].nsmax = 1;
        tree[rt].dsmaxl = tree[rt].nsmaxl = 1;
        tree[rt].dsmaxr = tree[rt].nsmaxr = 1;
        return;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    pushup(rt);
    return;
}
void update(int op, int L, int R, int l, int r, int rt) {//更新
    if (L <= l && r <= R) {
        if (op == 2)
            sx(rt);
        else if (op == 1)
            ds(rt);
        else ns(rt);
        return;
    }
    pushdown(rt);
    int mid = (l + r) >> 1;
    if (L <= mid) update(op, L, R, lson);
    if (mid < R) update(op, L, R, rson);
    pushup(rt);
    return;
}
int query(int op, int t, int l, int r, int rt) {//询问是否存在时间,如果存在,返回最早的左时间
    if (l == r)
        return l;
    pushdown(rt);
    int mid = (l + r) >> 1;
    if (op == 1) {
        if (tree[ls].dsmax >= t) return query(op, t, lson);
        if (tree[ls].dsmaxr + tree[rs].dsmaxl >= t) return mid - tree[ls].dsmaxr + 1;
        return query(op, t, rson);//
    }
    else {
        if (tree[ls].nsmax >= t) return query(op, t, lson);
        if (tree[ls].nsmaxr + tree[rs].nsmaxl >= t) return mid - tree[ls].nsmaxr + 1;
        return query(op, t, rson);//
    }
}
int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    int T;
    scanf("%d", &T);
    for (int i = 1;i <= T;i++) {
        int t, n;
        printf("Case %d:\n", i);
        scanf("%d%d", &t, &n);
        build(1, t, 1);
        while (n--) {
            //getchar();
            char s[10];
            int q;
            scanf("%s%d", s, &q);
            if (s[0] == 'D') {
                if (tree[1].dsmax < q) puts("fly with yourself");
                else {
                    int x = query(1, q, 1, t, 1);
                    printf("%d,let's fly\n", x);
                    update(1, x, q + x - 1, 1, t, 1);
                }
            }
            else if (s[0] == 'N') {
                if(tree[1].dsmax < q){
                    if (tree[1].nsmax < q) puts("wait for me");
                    else {
                        int x = query(0, q, 1, t, 1);
                        printf("%d,don't put my gezi\n", x);
                        update(0, x, x + q - 1, 1, t, 1);
                    }
                }
                else {
                    int x = query(1, q, 1, t, 1);
                    printf("%d,don't put my gezi\n", x);
                    update(0, x, x + q - 1, 1, t, 1);
                }
            }
            else {
                int r;
                scanf("%d", &r);
                puts("I am the hope of chinese chengxuyuan!!");
                update(2, q, r, 1, t, 1);
            }
        }
    }
    return 0;
}

扫描线

在一个二维空间中,求几个随意放置的矩形面积交、面积并、周长并,可以利用扫描线的思想
很多博客解释扫描线是一条只存在脑内的不存在的线,确实扫描线是一个不存在的线,但是我认为把线段树维护的看做是那条线更容易理解扫描线的思想
对扫描线的深入理解
我们先定义扫描线为一棵线段树维护的线段,它维护的值是对应区间中矩形的数量。那么求解这一类问题,就要先搞定矩形数量与边的关系。假设扫描线从下往上扫,遇到矩形的边就停下来进行一次更新和计算,那么n个矩形就会遇到2*n条边(很显然),这些边我们把底部称为入边,扫描线经过这条边就说明边对应区间上的矩阵数量+1,就把线段树上相应区间标记+1,然后再把顶部称为出边,扫描线经过这里说明这条边上对应区间的矩阵数量-1,就把线段树上相应区间标记-1。这样就可以记录当前边上存在的矩阵数量了,当矩阵数量>=1就可以计算面积并,>=2就可以计算面积交,周长并就上下左右扫两次,遇到边的数量==1记录区间长度就好了。
例题:HDU 1255:覆盖的面积(离散化 + 扫描线)
题意:四个字,求面积交(扫描线板子题),由于涉及浮点数,而线段树不能处理浮点区间,需要离散化

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "< pii;
typedef vector vi;
struct Line {
    double x, X, y;//起点,终点,高度
    int flag;//入边+1,出边-1
    void in(double a, double b, double c, int f) { x = a, X = b, y = c, flag = f; };
    bool operator<(const Line &b) const {
        return y 1)
        tree[rt].sum2 = tree[rt].sum1 = S[r + 1] - S[l];
    else if (tree[rt].lay == 1) {
        tree[rt].sum1 = S[r + 1] - S[l];
        if (l == r) tree[rt].sum2 = 0;
        else tree[rt].sum2 = tree[rt << 1].sum1 + tree[rt << 1 | 1].sum1;
    }
    else {
        if (l == r) tree[rt].sum1 = tree[rt].sum2 = 0;
        else {
            tree[rt].sum1 = tree[rt << 1].sum1 + tree[rt << 1 | 1].sum1;
            tree[rt].sum2 = tree[rt << 1].sum2 + tree[rt << 1 | 1].sum2;
        }
    }
}
void update(int v, int L, int R, int l, int r, int rt) {//更新
    if (L <= l && r <= R) {
        tree[rt].lay += v;
        pushup(l, r, rt);
        return;
    }
    int mid = (l + r) >> 1;
    if (L <= mid) update(v, L, R, l, mid, rt << 1);
    if (R > mid) update(v, L, R, mid + 1, r, rt << 1 | 1);
    pushup(l, r, rt);
    return;
}
int main()
{
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    int T;
    scanf("%d", &T);
    while (T--) {
        int n;
        memset(tree, 0, sizeof tree);
        scanf("%d", &n);
        rep(i, 1, n+1) {
            double x, y, X, Y;
            scanf("%lf%lf%lf%lf", &x, &y, &X, &Y);
            line[i].in(x, X, y, 1), line[n + i].in(x, X, Y, -1);
            S[i] = x, S[n + i] = X;
        }
        n <<= 1;
        sort(S + 1, S + n + 1);
        sort(line + 1, line + n + 1);
        int s = unique(S + 1, S + n + 1) - (S + 1);
        double sum = 0;
        for (int i = 0;i < n - 1;i++) {
            int l = lower_bound(S + 1, S + s + 1, line[i].x) - S;
            int r = lower_bound(S + 1, S + s + 1, line[i].X) - S;
            if(l < r) update(line[i].flag, l, r-1, 1, L, 1);
            sum += tree[1].sum2*(line[i+1].y - line[i].y);
        }
        printf("%.2lf\n", sum);
    }
    return 0;
}

小记

花了三天时间学习线段树(入门),觉得线段树是真的强大,但是代码量也不小,对于一些简单的任务分块和树状数组同样可以胜任相同的工作,但是你爹终究是你爸爸,想要实现更强大的算法少不了代码,也算是另一种以空间换时间的概念吧(还有敲代码的时间)。关于线段树还有主席树等更多的拓展,摸了摸自己日益稀疏的头,不知道还能撑多久。

你可能感兴趣的:(线段树骚操作总结)