ACM学习笔记：线段树

title : 线段树
date : 2021-8-15
tags : ACM，数据结构

线段树

线段树基础

首先上个板子来复习一下线段树的基本写法。

//基础板 P3372 【模板】线段树 1
#include<bits/stdc++.h>
using namespace std;
int n,m,l,r,k,q; 
long long arr[100005],tree[270000],lazy[270000];

void build(int node,int l,int r){  //建树 
    if(l==r){
        tree[node]=arr[l];
        return;
    }
    int mid=(l+r)/2;
    build(node*2,l,mid); //左区间建树 
    build(node*2+1,mid+1,r); //右区间建树 
    tree[node]=tree[node*2]+tree[node*2+1]; //区间和 
}

void pushdown(int node,int start,int end){ //下传操作 
    int mid=(start+end)/2;
    if(lazy[node]){ 
        tree[node*2]+=lazy[node]*(mid-start+1); //更新区间和 
        tree[node*2+1]+=lazy[node]*(end-mid);
        lazy[node*2]+=lazy[node]; //懒标记下传 
        lazy[node*2+1]+=lazy[node];
    }
    lazy[node]=0;
}

void update(int node,int start,int end,int l,int r,int c){ //更新操作 
    if(l<=start&&end<=r){ //如果区间在更新范围内，直接标记返回 
        tree[node]+=(end-start+1)*c; //区间和加上Len倍的c 
        lazy[node]+=c; //打标记 
        return;
    }
    int mid=(start+end)/2;
    pushdown(node,start,end); //下传 
    if(l<=mid){update(node*2,start,mid,l,r,c);} //更新左区间 
    if(r>mid){update(node*2+1,mid+1,end,l,r,c);}//更新右区间 
    tree[node]=tree[node*2]+tree[node*2+1];  //pushup
}

long long query(int node,int start,int end,int l,int r){ //查询操作 
    int mid=(start+end)/2;
    if(l<=start&&end<=r) return tree[node]; //如果在查询范围内，直接返回 
    pushdown(node,start,end);
    long long sum=0;
    if(l<=mid) sum=query(node*2,start,mid,l,r); //查询左区间 
    if(r>mid) sum+=query(node*2+1,mid+1,end,l,r); //查询右区间 
    return sum;
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&arr[i]);
    build(1,1,n);  
    while(m--){
        scanf("%d%d%d",&q,&l,&r);
        if(q==1){
            scanf("%d",&k);
            update(1,1,n,l,r,k); //区间修改 
        }else printf("%lld\n",query(1,1,n,l,r)); //区间查询 
    }
return 0;
}

延迟标记

延迟标记，也叫lazy tag,是在区间中新增一个标记，在下一次访问该区间时，向左右区间下放（pushdown）节点的标记，以便完成区间修改+区间询问。

区间染色

例题：POJ 2528 Mayor's posters

区间离散化

对于区间[1,5],[2,7],[7,100],[3,1e7],我们肯定不能直接对区间[1,1e7]进行修改，而是应该先进行排序并离散化，1->1,2->2,3->3,5->4,7->5,100->6,1e7->7，之后区间可以表示为[1,4],[2,5],[5,6],[3,7]。然而这样的表示实际上扩大了访问的区间，因此我们要在间隔大于1的两个元素中间再加数字，正确的表示方法如下:

$$ x[1]=1,x[2]=2,x[3]=3,x[4]=4,x[5]=5,x[6]=6,x[7]=7,x[8]=100,x[9]=101,x[10]=1e7 $$

发现了新增的节点x[4],x[6]和[x8]，这有什么用呢？

比如我要涂色[1,3]->颜色1,[5,7]->颜色2，加点前[1,3]->颜色1,[4,5]颜色2，可以发现最终两种颜色把[1,5]覆盖掉了，事实上中间还有一片(3,4)颜色未处理；我们增加节点后的效果是涂掉[1,3],[5,7]，那么数颜色数量的时候就能答案就修正了。

//Mayor's posters
#include<iostream>
#include<vector>
#include<algorithm>
#define MID int mid=(p->l + p->r)>>1
using namespace std;
struct Post{ // 海报
    int l,r;
} pst[10100];
int nodenum,cnt,ans;
int t,n,hs[10000010];
vector<int>vt;

struct Node{
    int l,r;
    bool full; // 区间[l,r]是否被完全覆盖
    Node *ls, *rs; 
}tr[1000000];

void buildTree(Node *p, int l, int r){ //建树 
    p->l=l;
    p->r=r;
    p->full=0; //初始化节点 
    if(l==r)return; //如果是叶子，直接返回 
    nodenum++;
    p->ls=tr+nodenum; //建立左右子树 
    nodenum++;
    p->rs=tr+nodenum;
    MID;
    buildTree(p->ls,l,mid); //左区间建树 
    buildTree(p->rs,mid+1,r); //右区间建树 
}
bool check(Node *p,int l,int r){ //判断该区间是否有覆盖 
    if (p->full) return false; //已经被覆盖了，这份海报就看不到了 
    if (p->l==l&&p->r==r){
        p->full=1; //覆盖此区间 
        return true;
    }
    bool res;
    MID;
    if(r<=mid) res=check(p->ls,l,r); //全在左区间，找左子树 
    else if(l>mid) res=check(p->rs,l,r);
    else{
        bool b1=check(p->ls,l,mid);
        bool b2=check(p->rs,mid+1,r);
        res=b1||b2; //其中一点没覆盖即可 
    }
    if (p->ls->full&&p->rs->full){
        p->full=1;//如果左右区间都被覆盖，那么这个区间也被覆盖了 
    }
    return res;
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin>>t;
    while(t--){
        cin>>n;
        nodenum=0,cnt=0,ans=0; //清空数据 
        for(int i=0;i<n;i++) {
            cin>>pst[i].l>>pst[i].r;
            vt.push_back(pst[i].l); //把区间端点放入容器 
            vt.push_back(pst[i].r);
        }
        sort(vt.begin(),vt.end());//排序 
        vt.erase(unique(vt.begin(),vt.end()),vt.end()); //去重 
        for(int i=0;i<vt.size();i++){
            hs[vt[i]]=cnt++; //记录元素所在数的节点编号 
            if(i<vt.size()-1){
                if(vt[i+1]-vt[i]>1) cnt++; //中间再插一个点 
            }
        } 
        buildTree(tr,0,cnt);//开始建树 
        for(int i=n-1;i>=0;i--){ //这里倒序，要从没被覆盖的开始数 
            if(check(tr,hs[pst[i].l],hs[pst[i].r])){
                ans++; //可见海报增加 
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

区间第K大

由于篇幅问题这个问题另开一篇主席树的博文讲吧。

扫描线线段树

扫描线算法可用于解决多个矩形围成的周长和面积问题。

扫描线算法

用一根线对图像从下往上进行扫描，扫描到边的时候对答案进行计算。相当于给妙计分层，然后计算每一层的面积，最后汇总到答案当中。

矩阵面积并

给定多个矩形，边一定平行于x或y轴。求所有矩形的面积之和。

(1)每个矩形的上下边加入扫描线并标记，下边标记为1，上边标记为-1\\ (2)让扫描线从从低到高排序，而矩形的左右边从小到大排序\\ (3)考虑数据范围，我们进行离散化处理\\ (3)建立线段树，那么区间可表示为区域的y1,y2，以及长度。\\ (4)遍历所有相邻左右边，每次通过线段树询问出高度，然后面积相加。\\

注意我们这里要维护的是线段长度而非点的值，所以我们要对线段树进行修改，即左孩子的右值=右孩子的左值，这样才能使维护不出现缝隙。

// luoguP5490 【模板】扫描线
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+7;

struct L{
    ll x,y1,y2,flag;
    L(ll X=0,ll Y1=0,ll Y2=0,ll T=0){
        x=X,y1=Y1,y2=Y2,flag=T;
    }
}line[N<<1];

struct node{
    int l,r;
    ll len;
    ll lazy;
}t[N<<2];

int n,cnt;
ll seg[N];
map<ll,int>val;

ll len(int p){
    //获得区域p的高度，即两扫描线相减 
    return seg[t[p].r+1]-seg[t[p].l]; 
}

void update(int p){
    if(t[p].lazy) t[p].len=len(p); //如果该区间被标记过 
    else if(t[p].l==t[p].r) t[p].len=0; //区间长度为0 
    else t[p].len=t[p<<1].len+t[p<<1|1].len; //两区间相加 
}

void build(int p,int l,int r){ 
    t[p].l=l; //建树时只需记录区间左右就可以了 
    t[p].r=r;
    if(l==r) return;
    int mid=l+r>>1;
    build(p<<1,l,mid); //对左边建树 
    build(p<<1|1,mid+1,r); //对右边建树 
}

void change(int p,int l,int r,int k){
    if(l<=t[p].l&&t[p].r<=r){ //如果区间在所求上下边中 
        t[p].lazy+=k; //打上标记 
        update(p); //更新区间长度 
        return;
    }
    int mid=t[p].l+t[p].r>>1;
    if(l<=mid) change(p<<1,l,r,k); //向下更新 
    if(r>mid) change(p<<1|1,l,r,k);  //向上更小 
    update(p); //最后要更新整个区间 
}

bool cmp(L a,L b){
    return a.x<b.x; //按照x坐标排序 
}

signed main(){
    ios::sync_with_stdio(0); //读入优化 
    cin.tie(0);cout.tie(0);
    cin>>n;
    for(int i=1;i<=n;i++){
        ll x1,y1,x2,y2;
        cin>>x1>>y1>>x2>>y2;
        seg[++cnt]=y1; //加入扫描线 
        line[cnt]=L(x1,y1,y2,1); //加入竖线 
        seg[++cnt]=y2;
        line[cnt]=L(x2,y1,y2,-1);
    }
    sort(line+1,line+cnt+1,cmp); //对竖线排序 
    sort(seg+1,seg+1+cnt); //扫描线从低到高排序 
    int m=unique(seg+1,seg+1+cnt)-(seg+1); //去重 
for(int i=1;i<=m;i++) val[seg[i]]=i; //离散化 
build(1,1,m); //建树 
ll ans=0; //记录答案 
for(int i=1;i<cnt;i++){ //对于cnt-1条竖边 
int x=val[line[i].y1],y=val[line[i].y2]-1; //区域的上下边 
change(1,x,y,line[i].flag); //查询并更新区域的高 
ans+=t[1].len*(line[i+1].x-line[i].x); //累加区域面积 
    }
printf("%lld",ans); //输出答案 
return 0;
}