线段树(扫描线法，单点修改区间查询

于 2021-06-15 13:06:22 发布
阅读量123 收藏
点赞数
分类专栏： 笔记 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/supreme567/article/details/117907288
版权

在这里插入图片描述

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 200010;

int m, p;
struct Node
{
    int l, r;
    int v;  // 区间[l, r]中的最大值
}tr[N * 4];

void pushup(int u)  // 由子节点的信息，来计算父节点的信息
{
    tr[u].v = max(tr[u << 1].v, tr[u << 1 | 1].v);
}

void build(int u, int l, int r)
{
    tr[u] = {l, r};
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}

int query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v;   // 树中节点，已经被完全包含在[l, r]中了

    int mid = tr[u].l + tr[u].r >> 1;
    int v = 0;
    if (l <= mid) v = query(u << 1, l, r);
    if (r > mid) v = max(v, query(u << 1 | 1, l, r));

    return v;
}

void modify(int u, int x, int v)
{
    if (tr[u].l == x && tr[u].r == x) tr[u].v = v;
    else
    {
        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 = 0, last = 0;
    scanf("%d%d", &m, &p);
    build(1, 1, m);

    int x;
    char op[2];
    while (m -- )
    {
        scanf("%s%d", op, &x);
        if (*op == 'Q')
        {
            last = query(1, n - x + 1, n);
            printf("%d\n", last);
        }
        else
        {
            modify(1, n + 1, (last + x) % p);
            n ++ ;
        }
    }

    return 0;
}

在这里插入图片描述
线段树，懒标记（这道题需要两个懒标记，而且要根据加和·乘运算变成一个运算

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 100010;
int n,w[N],p;
struct node{
    int l,r,sum,add,mul;
}tr[4*N];
void pushup(int u){
    tr[u].sum=(tr[u<<1].sum+tr[u<<1|1].sum)%p;
}
// void eval(node &t,int add,int mul){
//     t.sum=(t.sum*mul+add)%p;
//     t.add=(t.add*mul+add)%p;
//     t.mul=(t.mul*mul)%p;
// }
void eval(int u,int add,int mul){
    tr[u].sum=(tr[u].sum*mul %p+ (tr[u].r-tr[u].l+1)*add   )%p;
    tr[u].add=(tr[u].add*mul+add)%p;
    tr[u].mul=(tr[u].mul*mul)%p;
    
}
void pushdown(int u){
    eval(u<<1,tr[u].add,tr[u].mul);
    eval(u<<1|1,tr[u].add,tr[u].mul);
    tr[u].mul=1;
    tr[u].add=0;
}
void build(int u,int l,int r){
    if(l==r)tr[u]={l,r,w[r],0,1};
    else{
        tr[u]={l,r,0,0,1};
        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 add,int mul){
    if(tr[u].l>=l&&tr[u].r<=r)eval(u,add,mul);
    else{
        pushdown(u);
        int mid=tr[u].l+tr[u].r>>1;
        if(mid<r)modify(u<<1|1,l,r,add,mul);
        if(mid>=l)modify(u<<1,l,r,add,mul);
        pushup(u);
    }
}
int query(int u,int l,int r){
    if(tr[u].l>=l&&tr[u].r<=r)return tr[u].sum;
    
    pushdown(u);
    int mid=tr[u].l+tr[u].r>>1;
    int ans=0;
    if(mid>=l)ans=query(u<<1,l,r);
    if(mid<r)ans=(ans+query(u<<1|1,l,r) )%p;
    return ans;
}
signed main(){
    cin>>n>>p;
    for(int i=1;i<=n;i++)cin>>w[i];
    build(1,1,n);
    int t;
    cin>>t;
    while(t--){
        int op,l,r;
        cin>>op>>l>>r;
        if(op==2){
            int add;
            cin>>add;
            modify(1,l,r,add,1);
        }
        else if(op==1){
            int mul;
            cin>>mul;
            modify(1,l,r,0,mul);
        }
        else cout<<query(1,l,r)<<endl;
    }
}

在这里插入图片描述
利用差分的思想和更相减损法求gcd知识，不用懒标记实现单点修改区间查询

#include<bits/stdc++.h>
#define node Node
using namespace std;
typedef long long LL;
#define int long long
const int N = 500010;
int n,m,w[N];
struct node{
    int l,r,sum,d;
}tr[N*4];

int gcd(int a,int b){
    return b?gcd(b,a%b):a;
}

void pushup(node & t,node & a,node &b){
    t.sum=a.sum+b.sum;
    t.d=gcd(a.d,b.d);
}
void pushup(int u){
    pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}

void build(int u, int l, int r)
{
    if (l == r)
    {
        LL b = w[r] - w[r - 1];
        tr[u] = {l, r, b, b};
    }
    else
    {
        tr[u].l = l, tr[u].r = r;
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u,int x,int v){
    if(tr[u].l==x&&tr[u].r==x){
        // tr[u].sum+=v;
        // tr[u].d+=v;
        int b=tr[u].sum+v;
        tr[u]={x,x,b,b};
    }
    else{
        
        int mid= tr[u].l+tr[u].r>>1;
        if(mid<x)modify(u<<1|1,x,v);
        else modify(u<<1,x,v);
        
        pushup(u);
    }
}

Node query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u];
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else
        {
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            Node res;
            pushup(res, left, right);
            return res;
        }
    }
}



signed main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>w[i];
    build(1,1,n);
    while(m--){
        char c;
        int l,r;
        cin>>c>>l>>r;
        if(c=='C'){
            int v;
            cin>>v;
            modify(1,l,v);
            //差分思想，l~r这段区间加上一个数要在l加上去，在r+1减回去
            if(r+1<=n)modify(1,r+1,-v);//边界
        }
        else{
            node left=query(1,1,l);
            node right={0,0,0,0};
            if(l+1<=r)right=query(1,l+1,r);
            cout<<abs( gcd(left.sum ,  right.d )  )<<endl;
            
        }
    }
}

在这里插入图片描述
在这里插入图片描述

我真的吐了我靠这个线段树的边界条件居然这么苛刻
在这里插入图片描述
只有这样才是正确的·
我快吐了woc

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 100010;
int n,w[N],m;

struct node{
    int l,r,sum,add;
}tr[N*4];

void pushup(int u){
    tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
}
void pushdown(int u){
    auto &left=tr[u<<1];
    auto &right=tr[u<<1|1];
    auto &root=tr[u];
    if(root.add){
    left.add+=root.add,left.sum+=(left.r-left.l+1)*root.add;
    right.add+=root.add,right.sum+=(right.r-right.l+1)*root.add;
    root.add=0;
    }
}
void build(int u,int l,int r){
    if(l==r)tr[u]={l,r,w[l],0};
    else{
        tr[u]={l,r};
        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){
        tr[u].sum+= (tr[u].r-tr[u].l+1)*v;
        tr[u].add+=v;
    }
    else{
        pushdown(u);
        int mid=tr[u].l+tr[u].r>>1;
        if(l<=mid)modify(u<<1,l,r,v);
        if(mid<r)modify(u<<1|1,l,r,v);
        pushup(u);
    }
}

int query(int u,int l,int r){
    if(tr[u].l>=l&&tr[u].r<=r)return tr[u].sum;
    else{
        pushdown(u);
        int mid=tr[u].l+tr[u].r>>1;
        int ans=0;
        if(l<=mid)ans=query(u<<1,l,r);
        if(mid<r)ans+=query(u<<1|1,l,r);
        pushup(u);
        return ans;
    }
}

signed main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>w[i];
    build(1,1,n);
    char op[2];
    int l,r;
    while(m--){
        scanf("%s%d%d",op,&l,&r);
        //cout<<*op<<endl;
        if(*op=='Q')cout<<query(1,l,r)<<endl;
        else{
            int v;
            cin>>v;
            modify(1,l,r,v);
        }
    }
}

在这里插入图片描述
这道题·维护的东西有点多
lmax表示最大前缀和
rmax表示最大后缀和
tmax表示最大子串和
sum表示求和

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 500010;

int n, m;
int w[N];
struct Node
{
    int l, r;
    int sum, lmax, rmax, tmax;
}tr[N * 4];

void pushup(Node &u, Node &l, Node &r)
{
    u.sum = l.sum + r.sum;
    u.lmax = max(l.lmax, l.sum + r.lmax);
    u.rmax = max(r.rmax, r.sum + l.rmax);
    u.tmax = max(max(l.tmax, r.tmax), l.rmax + r.lmax);
}

void pushup(int u)
{
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

void build(int u, int l, int r)
{
    if (l == r) tr[u] = {l, r, w[r], w[r], w[r], w[r]};
    else
    {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int x, int v)
{
    if (tr[u].l == x && tr[u].r == x) tr[u] = {x, x, v, v, v, v};
    else
    {
        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);
    }
}

Node query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u];
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else
        {
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            Node res;
            pushup(res, left, right);
            return res;
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    build(1, 1, n);

    int k, x, y;
    while (m -- )
    {
        scanf("%d%d%d", &k, &x, &y);
        if (k == 1)
        {
            if (x > y) swap(x, y);
            printf("%d\n", query(1, x, y).tmax);
        }
        else modify(1, x, y);
    }

    return 0;
}

在这里插入图片描述

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 100010;

int n;
struct Segment
{
    double x, y1, y2;
    int k;
    bool operator< (const Segment &t)const
    {
        return x < t.x;
    }
}seg[N * 2];
struct Node
{
    int l, r;
    int cnt;
    double len;
}tr[N * 8];

vector<double> ys;

int find(double y)
{
    return lower_bound(ys.begin(), ys.end(), y) - ys.begin();
}

void pushup(int u)
{
    if (tr[u].cnt) tr[u].len = ys[tr[u].r + 1] - ys[tr[u].l];
    else if (tr[u].l != tr[u].r)
    {
        tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
    }
    else tr[u].len = 0;
}

void build(int u, int l, int r)
{
    tr[u] = {l, r, 0, 0};
    if (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 k)
{
    if (tr[u].l >= l && tr[u].r <= r)
    {
        tr[u].cnt += k;
        pushup(u);
    }
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u << 1, l, r, k);
        if (r > mid) modify(u << 1 | 1, l, r, k);
        pushup(u);
    }
}

int main()
{
    int T = 1;
    while (scanf("%d", &n), n)
    {
        ys.clear();
        for (int i = 0, j = 0; i < n; i ++ )
        {
            double x1, y1, x2, y2;
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            seg[j ++ ] = {x1, y1, y2, 1};
            seg[j ++ ] = {x2, y1, y2, -1};
            ys.push_back(y1), ys.push_back(y2);
        }

        sort(ys.begin(), ys.end());
        ys.erase(unique(ys.begin(), ys.end()), ys.end());

        build(1, 0, ys.size() - 2);

        sort(seg, seg + n * 2);

        double res = 0;
        for (int i = 0; i < n * 2; i ++ )
        {
            if (i > 0) res += tr[1].len * (seg[i].x - seg[i - 1].x);
            modify(1, find(seg[i].y1), find(seg[i].y2) - 1, seg[i].k);
        }

        printf("Test case #%d\n", T ++ );
        printf("Total explored area: %.2lf\n\n", res);
    }

    return 0;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/167934/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

线段树学了一天了，加油加油

胡 耀文
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树之扫描线
05-20
自己参考资料整理出来的ppt，讲解还算比较细致，如有不妥之处请批评指正
线段树 单点修改+区间修改和查询 例题+代码
菜鸡成长史
07-03 843
目录 【单点修改，区间查询 例题】 【hdu 1166 敌兵布阵】 【hdu 1754I Hate It 】 【区间修改，区间查询 例题】 【hdu 1698Just a Hook】 【单点修改，区间查询 例题】 1.单点修改、区间查询 - hdu 1166 敌兵布阵 2.单点修改、区间查询最值 - hdu 1754I Hate It 【hdu 1166 敌兵布阵】 ...
线段树 之 扫描线
wangyiyang2的博客
04-21 242
【学习笔记】线段树 之 扫描线 一篇简单易懂的扫描线讲解 I\mathrm{I}I 概况 扫描线就是解决一些在二维平面内处理矩形相交的一系列问题。我们在这里具体地讲两个：矩形面积并以及周长并 若不喜，勿喷。 II\mathrm{II}II 矩形面积并 例题模板 面积并相对周长来说比较简单。 首先我们来大致了解一下扫描线地工作原理：我们每次加入一个矩阵的操作相当于左边那条边+1+1+1，右...
线段树扫描线
cy41的博客
05-02 508
大佬的博客 看了好几天，感觉自己看懂了。 https://blog.csdn.net/riba2534/article/details/76851233这个大佬内部有图，可以手动纸上跟着画一下加深理解 扫描线可以水平扫，也可以垂直扫，这里我说一下垂直扫吧。 题目给出的坐标为浮点数，那么我们将所有的y坐标排序离散化后，假设共有m个不同的坐标值，设为val[1~m]。 那么这m个不同的y值就...
线段树（单点查询+区间求和）无lazy标记
01-20
原理就大概如图所示，线段树的每个节点都是原数组的一段区间和，而叶子节点就是原数组对应 的值 建树代码： void build(int p,int lf,int rt){//建树 ans[p]=0; if(lf==rt) { ans[p]=A[lf]; return ; } int mid...
权值线段树及扫描线学习笔记
最新发布
12-25
权值线段树及扫描线学习笔记
线段树区间更新code
12-22
线段树区间更新代码线段树区间更新代码线段树区间更新代码线段树区间更新代码
pascal区间线段树
11-18
一个讲述线段树的好资料，这里主要是程序部分，希望对广大成员能够有所帮助
线段树之扫描线（HDU-1542）
月巴虫丰博客
05-13 394
线段树之扫描线，主要是为了解决平面矩阵并以及空间立体交的问题。
线段树-扫描线
qq_41046771的博客
05-08 88
作用: 1.计算若干个矩形覆盖的面积 2.普通的线段树区间更新，查询可以将某一段的每个点的权都当成1查询 3.麻烦，不懂了，之后再更新 板板: //6_5-线段树(扫描线) ////////////// int n; typedef double tp; tp xs[maxn * 2];//记录x坐标 int num_x; ...
线段树--扫描线
灰色的人的博客
03-14 101
引入 扫描线一般是用在求图形面积上，由于图形会重合，而数据范围又太大，这时就要用扫描线了。 由于扫描线需要修改区间，所以要使用线段树–lazy标记还有一些小技巧。 例题 题目描述 桌面上放了N个平行于坐标轴的矩形，这N个矩形可能有互相覆盖的部分，求它们组成的图形的面积。 输入 有多组测试数据。 每组测试数据输入第一行为一个数N，表示矩形的数量。 下面N行，每行四个整数，分别表示每个矩形的左下角和右...
线段树 扫描线
Black__wing的博客
08-15 1122
例题HDU-1542-Atlantis： 扫描线的题就是求在一个二维平面上，多个矩形的覆盖面积，那么这个面积如何用线段树来维护呢？ 下面解析请配合代码食用。 我们可以知道，线段树对于区间修改，求和上时间复杂度很低，因此，我们就用线段树来维护，x轴上我们需要的区间长度。 如图我们想要求的三个矩形的坐标 我们将它们画出来是这样的: 那么我们线段树维护的就是1-2,2-3,3-4,4...
线段树 +扫描线
CUCUC1的博客
02-17 345
 关于线段树辅助扫描线的基本思想，已经有很多大佬去详细的解释了，可以去看一下传送门 这里主要说一下线段树辅助扫描线的一些问题以及两种变形 关于数据的离散化，离散化很多时候是为了减小空间消耗，但是我认为在线段树辅助扫描线时，基本都是需要进行离散化的，因为在以x(y)为坐标轴时，维护的是[1, m] (m不确定)，但是显然坐标轴上的区间点坐标不一定是从1开始的，所以要离散出一个区间其范围是 [1, m] 在一般线段树进行区间划分的时候，通常采用下面的方式 mid = l + r >> 1; (操
线段树单点修改，区间查询的模板题
gzcszzx
08-15 388
1547：【 例 1】区间和 （信息学一本通网站） 时间限制: 1000 ms 内存限制: 524288 KB 提交数: 1175 通过数: 318 【题目描述】 给定一数列，规定有两种操作，一是修改某个元素，二是求区间的连续和。 【输入】 输入数据第一行包含两个正整数n,m(n≤100000,m≤500000),以下是m行， 每行有三个正整数k,a,b(k=...
线段树+扫描线
qq_42211531的博客
01-20 506
看了一天才明白了 参考博客：https://blog.csdn.net/otowa/article/details/50695401   看完参考博客在看看我对这个的理解。 我的理解：扫描线是一种想法，方便我们去理解，线段的作用：维护我们所需要的值。 比我们要求上图的面积，我们可以将图形看成上图的形式（同种颜色我们求一次面积，最后相加） 我们所说的扫描线其实说的就是平行于X轴的边（...
线段树单点修改区间查询
08-15
线段树是一种用于解决区间查询问题的数据结构，其中单点修改和区间查询是其中最常见的操作之一。 在线段树中，每个代表一个区间，根节点表示整个给定的区间。每个节点都有一个值，可以是该区间的和、最大值、最小值或其他需要的信息。 对于单点修改操作，我们可以通过递归地更新每个节点来实现。我们从根节点开始，如果当前节点的区间恰好等于要修改的点的位置，则更新该节点的值。否则，我们根据要修改的点的位置将其递归地更新到左子节点或右子节点。 对于区间查询操作，我们可以通过递归地搜索每个节点来实现。我们从根节点开始，如果当前节点的区间完全包含在要查询的区间内，则直接返回该节点的值。如果当前节点的区间与要查询的区间有交集，则分别递归地查询左子节点和右子节点，并将结果合并。 通过这种方式，我们可以高效地进行单点修改和区间查询操作。线段树的构建时间复杂度为 O(nlogn)，其中 n 是给定区间的长度。单点修改和区间查询操作的时间复杂度均为 O(logn)。 希望以上解答能够帮助到您！如有任何疑问，请随时提出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值