4.11-4.17 周记线段树kuangbin 8-17 区间修改/区间根号/最大连续子区间/DFS序

最新推荐文章于 2023-12-20 23:40:32 发布
最新推荐文章于 2023-12-20 23:40:32 发布
阅读量98 收藏
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51531927/article/details/115635467
版权

线段树

count colors
特别的地方：“小线段”和区间端点的区别，和离散化maylor’s poster有点像，在操作的时候要缩小区间，注意题目给我们的是染色区间的端点，就是如果对[3，9]进行操作 ，只能是对[3，8]操作或者是对[4，9]操作，我选第一种，我用左一个单位的左端点储存这个单位的颜色，比如[3，9]段的颜色变成1，那就是以3为左端点单位段变成1,tr[3].lz=1,tr[4].lz=1…一直到tr[8].lz=1,注意，因为9已经是右边端点了，9储存的是[9,10]的颜色，所以tr[9].lz!=1。所以在写代码就要把右区间都减少1.

#include<cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int N=8000+7;
struct node{
    int l,r,lz;///这个时候lz和val的值完全等同 不需要再添加新的变量
   // int val; 
}tr[N<<2];
int vis[N],n,val[N],pre=-1;//因为区间从0开始 所以应该置为-1
void push_down(int k){
    if(tr[k].lz!=-1)///以后在这里完成判断！
        tr[k<<1].lz=tr[k<<1|1].lz=tr[k].lz;
    tr[k].lz=-1;//记得置为-1，否则在query下传的时候在更早时候的值会下传把后来的值覆盖掉
}
void build(int k,int l,int r){
    tr[k].l=l,tr[k].r=r;tr[k].lz = -1;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
}
void update(int k,int l,int r,int num){
    if(tr[k].l>=l&&tr[k].r<=r){
        tr[k].lz=num;
        return;
    }
    if(tr[k].lz!=-1)push_down(k);
    if(tr[k<<1].r>=l)update(k<<1,l,r,num);///不需要push_up的原因是 如果更新到这里 那么第一个if是不满足的 也就是当前的k并不是（l,r)区间的子集 所以这时候去push_up是错误的
    if(tr[k<<1|1].l<=r)update(k<<1|1,l,r,num);

}
void query(int k,int l,int r){
    if(tr[k].l==tr[k].r){
        if(tr[k].lz!=-1&&tr[k].lz!=pre)vis[tr[k].lz]++;///pre用来表示之前查找到的颜色 因为一段只能算一次
        // 一开始理解错题意以为是一块就加1 其实是一段就加1 如果上一次的那一段的颜色和当前相同那么它们是同一段
        pre=tr[k].lz;
        return;
    }
    push_down(k);
    int mid=(tr[k].l+tr[k].r)>>1;
    if(l<=mid) query(k<<1,l,r);
    if(r>mid)query(k<<1|1,l,r);
}
int main(){
    while(scanf("%d",&n)==1){
        pre=-1;
        memset(vis,0,sizeof vis);
        build(1,0,7999);
        for(int i=1;i<=n;i++){
            int l,r;
            scanf("%d%d%d",&l,&r,&val[i]);
            update(1,l,r-1,val[i]);
        }
        query(1,0,7999);///因为是“块”，所以需要缩小区间 否则会覆盖
        for(int i=0;i<=8000;i++){
            if(vis[i])printf("%d %d\n",i,vis[i]);
        }
        printf("\n");
    }
}

区间根号
很厉害的就是最后所有值变成1的时候就不用继续操作了，其实不是特别难想，当你没有什么思路就直接模拟一下题目的操作，总会到最后一步的。可以用区间和来判断最后到达1 ，因为都不会变成0，线段树真的好强啊！

#include<cstdio>
#include <algorithm>
#include<cmath>
#include<iostream>
#define ll long long
using namespace std;
const int N=1E5+7;
struct node{
    int l,r;
    ll sum;
}tr[N<<2];
int n;
void push_up(int k){tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;}
void build(int k,int l ,int r){
    tr[k].l=l,tr[k].r=r;
    if(l==r){
        ll tmp;
        scanf("%lld",&tmp);
        tr[k].sum=tmp;
        return;
    }
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    push_up(k);
}
void update(int k,int l,int r){
    if(tr[k].sum==(tr[k].r-tr[k].l+1))//判断最后变成1
       return ;
    if(tr[k].l==tr[k].r){
        tr[k].sum=floor(sqrt(tr[k].sum));
        return;
    }
    if(tr[k<<1].r>=l)update(k<<1,l,r);
    if(tr[k<<1|1].l<=r)update(k<<1|1,l,r);
    push_up(k);
}
ll query(int k,int l,int r){
    if(tr[k].l>=l&&tr[k].r<=r){
        return tr[k].sum;
    }ll ans=0;
    if(tr[k<<1].r>=l)ans+=query(k<<1,l,r);
    if(tr[k<<1|1].l<=r)ans+=query(k<<1|1,l,r);
    return ans;
}
int main(){
    int cnt=0,m;
    while(~scanf("%d",&n)){
        printf("Case #%d:\n",++cnt);
        build(1,1,n);

        scanf("%d",&m);
        for(int i=1;i<=m;i++){
            int op,l,r;
            scanf("%d%d%d",&op,&l,&r);
            if(l>r)swap(l,r);//被恶心到了但不是第一次，最好看清题意，不要主观啊！
            if(op==0){
                update(1,l,r); 
            }
            else {
                printf("%lld\n",query(1,l,r));
            }
        }
        printf("\n");
    }
    return 0;
}

维护最大最小值
直接区间查询

#include<cstdio>
#include<algorithm>
using namespace std;
/*
 * 首先是构建一棵树 其次是要维护的是区间的最大数和最小数
 *  最后是QUERY求出最大和最小的差
 * 看我乱糟糟的代码就知道根本不理解线段树，push_down是区间修改才需要用到，
 * 而且总区间也没有看清楚，以为n就是范围了。以后看题以为看懂了再看一遍，
 * 把每一个变量的含义弄清楚。
 * */
const int N=50007;
struct node{
    int maxx,minn,l,r,lzx,lzn;
}tr[N<<2];
int n,m,a[N],ma=0,mi=0x3f3f3f3f;
int ans;
/*void push_down(int k){
    tr[k<<1].lzn=tr[k<<1|1].lzn=tr[k].lzn;
    tr[k<<1].lzx=tr[k<<1|1].lzx=tr[k].lzx;
    tr[k<<1].maxx=tr[k<<1|1].maxx=tr[k].maxx;
    tr[k<<1].minn=tr[k<<1|1].maxx=tr[k].maxx;
    tr[k].lzn=tr[k].lzx=0;
}*/
void push_up(int k){
    tr[k].maxx=max(tr[k<<1].maxx,tr[k<<1|1].maxx);
    tr[k].minn=min(tr[k<<1].minn,tr[k<<1|1].minn);
}
///根本不用下传标记 下传标记是在区间修改的时候 但是现在你已经直接获得了
/// 从树的顶端走到最下端要O（m*n*logn),现在的赋初值需要O(n*logn)
void build(int k,int l,int r){
    tr[k].l=l,tr[k].r=r;
    if(l==r) {
        int tmp;
        scanf("%d",&tmp);
        tr[k].minn=tr[k].maxx=tmp;
        return; }
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    push_up(k);
}

/*void update(int k,int l,int r,int num){
    if(tr[k].l>=l&&tr[k].r<=r){
        tr[k].maxx=max(tr[k].maxx,num);
        tr[k].minn=min(tr[k].minn,num);
        *//*tr[k].lzn=tr[k].minn;
        tr[k].lzx=tr[k].maxx;*//*
        return;
    }
*//*    push_down(k);*//*
    update(k<<1,l,r,num);
    if(tr[k<<1|1].l<=r)update(k<<1|1,l,r,num);
    push_up(k);
}*/
void  query(int k,int l,int r){
    if(tr[k].l>=l&&tr[k].r<=r){
        ma=max(ma,tr[k].maxx);
        mi=min(mi,tr[k].minn);
        return ;
    }
    if(tr[k<<1].r>=l)query(k<<1,l,r);
    if(tr[k<<1|1].l<=r)query(k<<1|1,l,r);
}
int main(){
    scanf("%d%d",&n,&m);
    build(1,1,n);
    for(int i=1;i<=m;i++){
        int l,r;
        ans=0;
        scanf("%d%d",&l,&r);
        ma=-1,mi=0x3f3f3f3f;
        query(1,l,r);
        ///QUERY之后直接获取当前的最大值和最小值即可
        // printf("%d\n",ans);
        printf("%d\n",ma-mi);
    }return 0;
}

最大连续子区间

#include<iostream>
#include<cstdio>
#include<cstring>
#include <algorithm>
#include<string>
using namespace std;
#define in(n) scanf("%d",&n);
#define ch(n) scanf("\n%c",&n);///我不会说因为这个错误”\n “没有加我把这段代码打了四次的
#define re(i,n) for(int i=1;i<=n;i++)
const int N=50010;
struct TREE{
    int l,r,ll,rr,sum;
}tr[N<<2];
int n,m,de[N];
void build(int k,int l,int r){
    tr[k].l=l,tr[k].r=r,tr[k].ll=tr[k].rr=tr[k].sum=(r-l+1);//ll表示当前节点从左端点开始向右的最大连续子区间，rr同理 sum在下面的操作不会更新 只是用来判断当前节点是否为连续和用来更新ll和rr的值
    ///一开始打错成r+l-1,结果当然比预想的大很多 
    ///所以我应该思考哪里变大 从所有值更改的情况查找
    if(l==r)return;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
   // cout<<"build"<<k<<l<<r<<' '<<tr[k].ll<<' '<<tr[k].rr<<endl;
}
void update(int k,int pos,int num){

    if(tr[k].l==tr[k].r){tr[k].ll=tr[k].rr=num;return;}
    int mid=(tr[k].l+tr[k].r)>>1;
    if(pos<=mid)update(k<<1,pos,num);
    else update(k<<1|1,pos,num);
    //这几个选择结构体现了线段树两个节点之间的区间连续这个特点
    //如果当前节点总的连续区间==当前节点左孩子节点从左端点向右的最大连续区间+当前节点右孩子节点从右端点向左的最大连续区间 说明当前节点是连续的
    // 注意一个节点(k)分下来的两个节点(k<<1),(k<<1|1)的区间和（先不管是否连续）一定是(k)节点的总区间 并且分下来的两个节点的区间不互相重叠
    if(tr[k].sum==tr[k<<1].ll+tr[k<<1|1].rr)tr[k].ll=tr[k].rr=tr[k].sum;
    else{
        if(tr[k<<1].ll==tr[k<<1].sum)tr[k].ll=tr[k<<1].sum+tr[k<<1|1].ll;
        else tr[k].ll=tr[k<<1].ll;
        if(tr[k<<1|1].rr==tr[k<<1|1].sum)tr[k].rr=tr[k<<1|1].sum+tr[k<<1].rr;
        else tr[k].rr=tr[k<<1|1].rr;
    }//cout<<"in"<<k<<endl<<tr[k].ll<<endl;
}
int query(int k,int pos){
    if(k==1){
        if(tr[k].l+tr[k].ll-1>=pos)return tr[k].ll;
        if(tr[k].r-tr[k].rr+1<=pos)return tr[k].rr;
    }
    if(tr[k].l+tr[k].ll-1>=pos)return tr[k].ll+tr[k-1].rr;//如果出现[k-1]是在当前节点的上一层，那么当前节点是整棵树的左端点，如果它存在 就一定会被(k==1)的情况覆盖掉
    //在上一个判断就已经return了 所以[k-1]只会和[k]同层  如果然后为什么加上左边或者右边就足够了呢？假设除了这两个节点还有其他节点的区间和它们相连，那么它们肯定拥有共同的父亲节点
    //那么它们在父亲节点就已经被更新完毕了 所以不会查询到当前这一层
    if(tr[k].r-tr[k].rr+1<=pos)return tr[k].rr+tr[k+1].ll;
    if(tr[k].l==tr[k].r)return 0;
    int mid=(tr[k].l+tr[k].r)>>1;
    if(pos<=mid)return query(k<<1,pos);
    else return query(k<<1|1,pos);
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        memset(tr,0,sizeof tr);
        memset(de,0,sizeof de);
        build(1,1,n);
        int cnt=0;
        re(i,m){
            char op[9];
            cin>>op;
            if(op[0]=='R'&&cnt){
                update(1,de[cnt--],1);
            }
            else {
                int x;in(x)///其实在这里调试的时候print了两次 绝对是进入了两次循环 所以这个时候判断一下进入条件就可以了！
                ///学会一步步推理和窄化问题
                if(op[0]=='D'){
                    de[++cnt]=x;
                    update(1,x,0);
                }
                else printf("%d\n",query(1,x));
            }
           // for(int j=1;j<=n*4;j++)printf("%d %d %d %d %d\n",j,tr[j].l,tr[j].r,tr[j].ll,tr[j].rr);printf("\n");
        }
    }
    return 0;
}

dfs序
从祖先开始dfs，给每一个人一个开始和结束的时间戳，标记他从开始进入dfs的序号和跳出dfs的序号。
在这里插入图片描述

#include<iostream>
#include<cstring>
#include<vector>
#include<cstdio>
#define ll long long
using namespace std;
const int N=5E4+7;
vector<int>to[N];
int n,m,cnt,st[N],ed[N],vis[N];
struct node{
    int l,r;
    ll task,lz;
}tr[N<<2];
void init(){
    memset(tr,0,sizeof tr);
    memset(st,0,sizeof st);
    memset(ed,0,sizeof ed);
    memset(to,0,sizeof to);
    for(int i=1;i<=n;i++)to[i].clear();
    memset(vis,0,sizeof vis);
    cnt=0;
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        to[v].push_back(u);
        vis[u]++;
    }
}
void dfs(int i){
    st[i]=++cnt;
    for(int j=0;j<to[i].size();j++)dfs(to[i][j]);
    ed[i]=cnt;
}
void build(int k,int l,int r){
    tr[k].l=l,tr[k].r=r,tr[k].task=tr[k].lz=-1;
    if(l==r)return;
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
}
void push_down(int k){
    if(tr[k].lz==-1)return;
    tr[k<<1].task=tr[k<<1|1].task=tr[k<<1].lz=tr[k<<1|1].lz=tr[k].lz;
    tr[k].lz=-1;
}
void update(int k,int l ,int r,ll task){
    if(l<=tr[k].l&&tr[k].r<=r){
        tr[k].lz=tr[k].task=task;
        return;
    }push_down(k);
    int mid=(tr[k].l+tr[k].r)>>1;//cout<<"update"<<k<<' '<<l<<' '<<r<<' '<<tr[k].l<<' '<<tr[k].r<<' '<<tr[k].task<<endl;
    if(l<=mid)update(k<<1,l,r,task);
    if(r>mid)update(k<<1|1,l,r,task);
}
ll query(int k,int l,int r){
    if(l<=tr[k].l&&tr[k].r<=r)return tr[k].task;
    push_down(k);
    int mid=(tr[k].l+tr[k].r)>>1;//cout<<"query"<<k<<' '<<l<<' '<<r<<' '<<tr[k].l<<' '<<tr[k].r<<' '<<tr[k].task<<endl;
    if(l<=mid)return query(k<<1,l,r);
    if(r>mid)return query(k<<1|1,l,r);
}
int main(){
    int t;
    int num=0;
    cin>>t;
    while(t--){
        printf("Case #%d:\n",++num);
        scanf("%d",&n);
        init();
        build(1,1,n);
        for(int i=1;i<=n;i++){
            if(!vis[i]){
                dfs(i);
                break;
            }
        }
        for(int i=1;i<=n;i++)//cout<<st[i]<<' '<<ed[i]<<endl;
        scanf("%d",&m);
        while(m--){
            char op[10];
            int peo;cin>>op; scanf("%d",&peo);
            if(op[0]=='C'){
                printf("%lld\n",query(1,st[peo],ed[peo]));
            }
            else if(op[0]=='T'){
               //cout<<peo<<st[peo]<<ed[peo]<<"dd"<<endl;
                ll task;scanf("%lld",&task);
                update(1,st[peo],ed[peo],task);
            }
        }
    }
    return 0;
}
___TRY_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最大连续区间——kuangbin线段树专题总结（6）
qq_37087993的博客
12-18 295
HDU 1540 Tunnel Warfare HDU 4553 约会安排 最大连续区间也是线段树比较套路的做法 维护三个标记 ls，rs，ms 分别表示从当前区间左端点开始的最长连续区间，最长连续区间，右端点开始的最长连续区间 标记主要在push_up中体现 void push_up(int id,int l,int r) { tree[id].ml = max(max(tree[id&...
POJ - 2421 Constructing Roads （kuangbin - 最小生成树）
iamcht的博客
10-09 170
题目描述(已转换成中文)   有N个村庄，从1到N，你应该修建一些道路，这样每两个村庄就可以连接起来。我们说两个村庄A和B相连，当且仅当A和B之间有一条路，或者存在一个村庄C使得A和C之间有一条路，并且C和B相连。   我们知道一些村庄之间已经有一些道路了，你的工作是修建一些道路，这样所有的村庄都连接起来，所有道路的长度都是最小的。 输入格式   第一行是整数N (3 <= N <= 100)，即村庄数。然后是N行，第i行包含N个整数，第j列是村i和村j之间的距离(距离应该是[1,1000]内的
【数据结构】线段树算法总结（区间修改）
一个重视算法和系统设计的实战派
12-20 1024
【代码总结】线段树算法总结（区间修改）
HDU-1540(线段树&区间合并&最大连续区间）
samscream的博客
08-16 2472
做kuangbin线段树专题的时候遇到的题目，感觉这是一道非常有趣的题目。线段树的题目做的比较少，没有见过这种通过线段树在区间上做文章的题目，感觉做完这个题目之后加深了对线段树左右孩子所覆盖的区间之间的关系的认识。 题意：1-n个地道，m个次操作，D代表摧毁第i个地道，Q代表查询包含第i个地道的最大连续地道数目，并输出。R代表修复最近摧毁的那个地道； 解题的关键思路&过程：这个题目一开...
约会安排 - HDU 4553 - 线段树 - 区间合并
LucienShui
06-04 560
约会安排 - HDU 4553 - 线段树 - 区间合并思路  国际惯例中文题目直接说思路，DS QT：找一段最靠前长度为QT的空间；NS QT：找一段最靠前长度为QT的空间，如果没有找到可以将DS占据的空间当做空闲空间，找一段最靠前的空间；STUDY!! L R：清空[L,R]区间的空间。  用两个线段树，一个记录DS，一个记录NS，维护最大左区间ma_l，最大右区间ma_r，以及区间内最大区间m
bryce1010-ACM-Template:人一我百，人十我万，追逐青春的梦想，怀着自信的心，永不放弃！by kuangbin （Bryce1010 ACM模板）
05-09
KuangBin的ACM模板 [github] f-zyj/ACM 模板 [github] 面试算法笔记 [github] STL 1. heap /* 堆 常用有两种构建堆的方式： 1. 使用“优先队列” 2. 使用`make_heap` (todo) */ #pragma once #include "../../all....
UVA - 11624 Fire! （kuangbin - 简单搜索）
iamcht的博客
09-28 250
题目描述(已转换成中文)   乔在迷宫中工作。不幸的是，迷宫的一部分着火了，迷宫的主人没有制定火灾的逃跑计划。请帮助乔逃离迷宫。根据乔在迷宫中的位置以及迷宫的哪个方块着火，你必须确定火焰烧到他之前，乔是否可以离开迷宫，如果能离开他能跑多快。   乔和火每分钟移动一个方格，上、下、左、右，四个方向中的一个。火势向四个方向同时蔓延。乔可以从迷宫的任何一个边界逃离迷宫。无论是乔还是火都不会到达有墙的位置。 输入格式   第一行输入包含一个整数，即测试次数,每个测试用例的第一行包含两个整数R和C，用空格分隔，1≤R
POJ - 3126 Prime Path （kuangbin - 简单搜索）
iamcht的博客
09-28 209
题目描述(已转换成中文)   给你两个四位的素数a，b。   a可以改变某一位上的数字变成c，但只有当c也是四位的素数时才能进行这种改变。   请你计算a最少经过多少次上述变换才能变成b。   例如：1033 -> 8179   1033   1733   3733   3739   3779   8779   8179   最少变换了6次。 输入格式   第一行输入整数T，表示样例数。 (T <= 100)   每个样例输入两个四位的素数a，b。(没有前导零) 输出格式   对于每个样例，输出
直流电机电枢控制（闭环）simulink.rar
09-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。
学习如何对其自动驾驶车辆进行编程simulink.rar
09-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。
空间相关风速时程模拟matlab代码.rar
09-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。
块函数 Square 的线性 Simulink.rar
09-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。
项目水资源分析模拟综合平，长江经济带小水电基础信息管理系统，java_basic.java.io,_myproject.zip
09-09
项目水资源分析模拟综合平，长江经济带小水电基础信息管理系统，java_basic.java.io,_myproject
小程序-滑动选项卡（源码）.zip
最新发布
09-09
小程序-滑动选项卡（源码）.zip
使用 SimPowerSystems 和 SimDriveline 演示燃料电池汽车 (FCV) 动力系统.rar
09-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。
KGM转MP3或者FLAC
09-09
KGM转MP3或者FLAC
基于ssm的在线云音乐系统的设计与实现.docx
09-09
基于ssm的在线云音乐系统的设计与实现.docx
Anno-Admin是一个开源项目，旨在通过注解生成后台管理系统。它可以帮助开
09-09
Anno-Admin是一个开源项目，旨在通过注解生成后台管理系统。它可以帮助开轻松地创建功能强_anno-admin
一般图最大加权匹配算法模板-ACM云计算解码
"一般图最大加权匹配-云计算解码（第2版），ACM常用算法模板，kuangbin" 本文主要讨论了如何在一般图中寻找最大加权匹配的问题，并提供了ACM竞赛常用的算法模板。最大加权匹配是图论中的一个重要问题，它在优化问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值