线段树 （区间修改 区间查询 延迟标记）

最新推荐文章于 2024-08-21 19:41:42 发布
最新推荐文章于 2024-08-21 19:41:42 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： ACM->数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013514722/article/details/47205155
版权
hdu 1698 Just a Hook
题意：
 给你一链子，这天链子由金银铜三种钩子组成，每种钩子都有自己的价值；
 起初，这条钩子全部由铜钩子组成，给你两个数n（钩子的个数），Q（操作的个数）每次操作就是将给定区间里的数变成某种钩子；
 求这条链子的总价值。
分析：
  线段树模版题，处理好延迟标记即可。
代码：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<vector>
#include<stack>
#include<cstdlib>
#pragma comment(linker, "/STACK:1024000000")
//#define LL __int64
#define LL long long
#define pi acos(-1.0)
#define PB push_back()
#define MP make_pair()
#define BG begin()
#define ED end()
#define clr(a,b)  memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
#define Mod  1e9+7
#define root  1,n,1
#define lson  l,mid,rt<<1
#define rson  mid+1,r,rt<<1|1
using namespace std;
const int maxn=100005;
int A[maxn];
int sum[maxn<<2];
int lazy[maxn<<2];


void PushUp(int rt)
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}

void PushDown(int rt,int len)
{
    if(lazy[rt])
    {
        lazy[rt<<1]=lazy[rt<<1|1]=lazy[rt];
        sum[rt<<1]=(len-(len>>1))*lazy[rt];
        sum[rt<<1|1]=(len>>1)*lazy[rt];
        lazy[rt]=0;
    }
}

void Build(int l,int r,int rt)
{
    sum[rt]=1;
    lazy[rt]=0;
    if(l==r)  return ;
    int mid=l+r>>1;
    Build(lson);
    Build(rson);
    PushUp(rt);
}

void Update(int ll,int rr,int c,int l,int r ,int rt)
{
    if(ll<=l&&rr>=r)
    {
        lazy[rt]=c;
        sum[rt]=(r-l+1)*c;
        return ;
    }
    PushDown(rt,r-l+1);
    int mid=l+r>>1;
    if(ll<=mid)  Update(ll,rr,c,lson);
    if(rr>mid)   Update(ll,rr,c,rson);
    PushUp(rt);
}
int main()
{
      #ifndef ONLINE_JUDGE
    freopen("in.cpp","r",stdin);
    #endif // ONLINE_JUDGE
    int T,i;
    cin>>T;
  for(i=1;i<=T;i++)
    {
        int n;
        scanf("%d",&n);
        Build(root);
        int Q;
        scanf("%d",&Q);
        while(Q--)
        {
            int l, r, z;
            scanf("%d%d%d",&l,&r,&z);
            Update(l,r,z,root);
        }
        printf("Case %d: The total value of the hook is %d.\n",i,sum[1]);
    }
    return 0;

}

poj 3468 A Simple Problem with Integers

题意比较简单，直接上代码；
代码：
#define root  1,n,1
#define lson  l,mid,rt<<1
#define rson  mid+1,r,rt<<1|1
const int maxn=100115;
LL sum[maxn<<2];
LL lazy[maxn<<2];

void PushUp(int rt)
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
void PushDown(int rt,int len)
{
    if(lazy[rt])
    {
        lazy[rt<<1]+=lazy[rt];
        lazy[rt<<1|1]+=lazy[rt];
        sum[rt<<1]+=(len-(len>>1))*lazy[rt];
        sum[rt<<1|1]+=(len>>1)*lazy[rt];
        lazy[rt]=0;
    }
}
void Build(int l,int r,int rt)
{
    lazy[rt]=0;
    if(l==r){
      scanf("%I64d",&sum[rt]);
        return ;
    }
    int mid=l+r>>1;
    Build(lson);
    Build(rson);
    PushUp(rt);
}

void Update(int ll,int rr,int c,int l,int r,int rt)
{
    if(ll<=l&&rr>=r)
    {
        sum[rt]+=(LL)(r-l+1)*c;
        lazy[rt]+=c;
        return ;
    }
    PushDown(rt,r-l+1);
    int mid=l+r>>1;
    if(ll<=mid)  Update(ll,rr,c,lson);
    if(rr>mid)   Update(ll,rr,c,rson);
    PushUp(rt);
}

LL  Query(int ll,int rr,int l,int r,int rt)
{
    if(ll<=l&&rr>=r)
        return sum[rt];
    PushDown(rt,r-l+1);
    int mid=l+r>>1;
    LL cnt=0;
    if(ll<=mid) cnt+=Query(ll,rr,lson);
    if(rr>mid)  cnt+=Query(ll,rr,rson);
    return cnt;
}
char ty[10];
int main()
{
      #ifndef ONLINE_JUDGE
    freopen("in.cpp","r",stdin);
    #endif // ONLINE_JUDGE
    int n,q;
    while(~scanf("%d%d",&n,&q))
    {
        Build(root);
        while(q--)
        {
            int a,b,z;
            scanf("%s",ty);
            if(ty[0]=='Q')  {
                scanf("%d%d",&a,&b);
                printf("%I64d\n",Query(a,b,root));
            }
            else if(ty[0]=='C'){
                scanf("%d%d%d",&a,&b,&z);
                Update(a,b,z,root);
            }
        }
    }
    return 0;

}

hdu 4902 nice boat

题意：
 对一个数列进行两个操作：
 1 l r x :  将l~~r 之间所有数改为x；
 2 l r x :  对于l~~r之间>x的数改为GCD（a[i], x)；
 求： 最后的数列。
代码：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<vector>
#include<stack>
#include<cstdlib>
#pragma comment(linker, "/STACK:1024000000")
//#define LL __int64
#define LL long long
#define pi acos(-1.0)
#define PB push_back()
#define MP make_pair()
#define BG begin()
#define ED end()
#define clr(a,b)  memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
#define Mod  1e9+7
#define root 1, n, 1
#define lson l, mid, rt<<1
#define rson mid+1, r, rt<<1|1
using namespace std;
const int maxn=100005;
int num[maxn<<2];
int lazy[maxn<<2];

int Gcd(int x,int y)
{
   return  y==0?x:Gcd(y,x%y);
}

void PushUp(int rt)
{
    if(num[rt<<1]==num[rt<<1|1])
        num[rt]=num[rt<<1];
    else
        num[rt]=-1;
}

void Pushdown(int rt)
{
    if(lazy[rt])
    {
        lazy[rt<<1]=lazy[rt<<1|1]=1;
        num[rt<<1]=num[rt<<1|1]=num[rt];
        lazy[rt]=0;
    }
}
void Build(int l,int r,int rt)
{
    lazy[rt]=0;
    if(l==r){
        scanf("%d",&num[rt]);
        return ;
    }
    int mid=l+r>>1;
    Build(lson);
    Build(rson);
    PushUp(rt);
}

void Update1(int ll,int rr,int c,int l,int r, int rt)
{
    if(ll<=l&&rr>=r){
         num[rt]=c;
         lazy[rt]=1;
         return ;
    }
    Pushdown(rt);
    int mid=l+r>>1;
    if(ll<=mid)  Update1(ll,rr,c,lson);
    if(rr>mid)   Update1(ll,rr,c,rson);
    PushUp(rt);
}

void Update2(int ll,int rr,int c,int l,int r,int rt)
{
     if(ll<=l&&rr>=r&&num[rt]!=-1){
          if(num[rt]>c){
              num[rt]=Gcd(num[rt],c);
              lazy[rt]=1;
          }
          return ;
    }
    Pushdown(rt);
    int mid=l+r>>1;
    if(ll<=mid)  Update2(ll,rr,c,lson);
    if(rr>mid)   Update2(ll,rr,c,rson);
    PushUp(rt);
}

void Query(int l,int r,int rt)
{
    if(l==r)
    {
       printf("%d ",num[rt]);
       return ;
    }
    Pushdown(rt);
    int mid=l+r>>1;
    Query(lson);
    Query(rson);
}
int main() {
     #ifndef ONLINE_JUDGE
      freopen("in.cpp","r",stdin);
     #endif // ONLINE_JUDGE
     int T,Q;
     cin>>T;
     while(T--)
     {
         int n;
         scanf("%d",&n);
         Build(root);
         scanf("%d",&Q);
         int l,r,z,ty;
         while(Q--)
         {
             scanf("%d%d%d%d",&ty,&l,&r,&z);
             if(ty==1)
                 Update1(l,r,z,root);
             else if(ty==2)
                Update2(l,r,z,root);
         }
          Query(root);
          printf("\n");
     }
    return 0;
}

hdu 4027 Can you answer these queries?

题意：
给你一个数列，给你两中操作：
 (0 l,r) :  将区间的数变成自己的开方：
 （1 l,r) :   询问区间和：
分析：
由于2^63最多只需要6~7次就会变为一；
那么每次对sum 为1 进行标记，每次更新到叶子节点或sum为1的点。
询问也如此。
代码：
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<vector>
#include<stack>
#include<cstdlib>
#pragma comment(linker, "/STACK:1024000000")
#define LL __int64
//#define LL long long
#define pi acos(-1.0)
#define PB push_back()
#define MP make_pair()
#define BG begin()
#define ED end()
#define clr(a,b)  memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
#define Mod  1e9+7
#define root 1, n, 1
#define lson l, mid, rt<<1
#define rson mid+1, r, rt<<1|1
using namespace std;
const int maxn=100005;
LL sum[maxn<<2];
int Mark[maxn<<2];

void PushUp(int rt)
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
    Mark[rt]=Mark[rt<<1]&&Mark[rt<<1|1];
}

void Build(int l,int r,int rt)
{
    Mark[rt]=0;
    if(l==r){
        scanf("%I64d",&sum[rt]);
        if(sum[rt]<=1)  Mark[rt]=1;
        return ;
    }
    int mid=l+r>>1;
    Build(lson);
    Build(rson);
    PushUp(rt);
}

void Update1(int ll,int rr,int l,int r, int rt)
{
    if(Mark[rt])  return ;
    if(l==r){
          sum[rt]=(LL)sqrt(sum[rt]);
          if(sum[rt]<=1)  Mark[rt]=1;
        return ;
    }
    int mid=l+r>>1;
    if(ll<=mid)  Update1(ll,rr,lson);
    if(rr>mid)   Update1(ll,rr,rson);
    PushUp(rt);
}

LL Query(int ll,int rr,int l,int r,int rt)
{
    if(ll<=l&&rr>=r)  return sum[rt];
    int mid=l+r>>1;
    LL cnt=0;
    if(ll<=mid) cnt+=Query(ll,rr,lson);
    if(rr>mid)  cnt+=Query(ll,rr,rson);
    return cnt;
}
int main() {
     #ifndef ONLINE_JUDGE
      freopen("in.cpp","r",stdin);
     #endif // ONLINE_JUDGE
     int T,Q;
     int n;
     int cas=0;
     while(scanf("%d",&n)!=EOF)
     {
         printf("Case #%d:\n",++cas);
         Build(root);
         scanf("%d",&Q);
         int l,r,z,ty;
         while(Q--)
         {
             scanf("%d%d%d",&ty,&l,&r);
             if(l>r)  swap(l,r);
             if(ty==0)
                 Update1(l,r,root);
             else if(ty==1)
              printf("%I64d\n",Query(l,r,root));
         }
         printf("\n");
     }
    return 0;
}
OnlyTyou
关注
专栏目录
[高级数据结构C++] 线段树（区间和的查询与修改）
qq_73928885的博客
09-10 305
`线段树` 和 `树状数组` 都是很适合解决**区间问题**的数据结构。
C++线段树区间加法&区间查询代码详解（超详细）
Andysun06的博客
08-11 610
#include <bits/stdc++.h> #define MAXN 100005 using namespace std; typedef long long ll; inline ll read() { //快读 ll ans = 0; char c = getchar(); while (!isdigit(c)) c = getchar(); while (isdigit(c)) { ans = ans * 10 + c - '0'; c = getchar
线段树区间修改
Mr.Amazing的博客
05-08 1163
区间修改区间查询里面用到了一个lazytag方法 具体的意思就是：要修改某区间（L,R）的值时，不修改到底，而是修改到L<=begin&&R>=end时，直接对begin到end区间的和进行修改，修改后在次节点做一个标记add[node]=x（x为修改值），如果add[node]不为零，说明我并没有将此节点的更改向下延伸到叶子节点。至于什么时候向下更新到叶子结点，则是到下一次更新到此节点或者是区间查询查询到此节点时进行更新。 #include <iostream&..
线段树延迟标记精讲
哆啦AC梦的专栏
12-03 1045
一 概述 线段树，类似区间树，是一个完全二叉树，它在各个节点保存一条线段（数组中的一段子数组），主要用于高效解决连续区间的动态查询问题，由于二叉结构的特性，它基本能保持每个操作的复杂度为O(logn)。 线段树的每个节点表示一个区间，子节点则分别表示父节点的左右半区间，例如父亲的区间是[a,b]，那么(c=(a+b)/2)左儿子的区间是[a,c]，右儿子的区间是[c+1,b]。
线段树：区间修改与区间查询
最新发布
yingjingxu的博客
08-21 941
线段树。
浅析__线段树延迟标记
07-31 3077
浅析__线段树延迟标记
线段树的区间修改
m0_63729880的博客
09-28 766
线段树之区间修改
线段树 区间修改区间查询
glorious_dream的博客
02-17 843
维护序列的二叉树 树上每个点对应序列上一段连续的区间 ls/rs：k的左/右儿子 Mid=(l+r)/2 若点x对应[l,r]，则ls对应[l,mid],rs对应[mid+1,r] 根节点对应整个序列[1,n] 叶节点对应的区间为[l,l]，即序列上一个点 1.区间加法 考虑用lazy数组标记，当我们需要对点k所对应的区间加v时，我们不递归k的左右子树更新其内部值，而是选择lazy[k]+=v，代表这段区间已经加过v了。当我们在查询和修改中遇到一个有懒标记的点k时，由于其子树内部的值还未被更
线段树 区间修改
TC2617的博客
01-16 771
我们对于线段树的区间修改你可以用一个最傻的办法循环进行单点修改（时间复杂度太高十分麻瓜）所以，我们要用一个聪明的做法** 延迟标记**（LAZY） 在限度拿书的“区间查询”指令中，每当遇到被询问区间[l,r]完全覆盖的节点时，可以立即把该节点上存储的信息作为候选答案返回。已经有大佬证明，被询问区间[l,r]在线段树上会被分成O(logN)个小区间(节点)从而在O(logN)的时间内求出答案。...
线段树区间修改单点查新
10-04
对于区间修改操作，线段树通常使用懒惰标记（lazy propagation）的技术来延迟更新。当需要修改某个区间时，只会在该区间的祖先节点上打上一个标记，并在进行查询操作时将这个标记向下传递和更新，以保证查询结果的...
线段树区间更新
liuyanfeier的专栏
08-12 930
线段树成段更新延迟标记理解区间更新是指每次更新的时候更新的是一个区间里面的所有值，例如将区间[l,r]内的所有点都加或者减去一个数，或者替换成一个数字等等.因为区间更新每次更新的不止一个叶子节点，而叶子节点的值的更新肯定会影响到他的一系列的节点，所以假如每次都按照单点更新的思路将每一个叶子节点以及他的父节点都更新的话，那么工作量太大了并且时间肯定不会是log(n)会超时的。例如线段树总区间为[1,
C#学习笔记：线段树的区间修改
NS
11-15 691
题目1 : 线段树的区间修改 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 对于小Ho表现出的对线段树的理解，小Hi表示挺满意的，但是满意就够了么？于是小Hi将问题改了改，又出给了小Ho： 假设货架上从左到右摆放了N种商品，并且依次标号为1到N，其中标号为i的商品的价格为Pi。小Hi的每次操作分为两种可能，第一种是
线段树(区间修改，区间查询)
weixin_46657636的博客
01-24 220
You have N integers, A1, A2, … , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval. Input The first line c
线段树（区间修改，区间查询）
orz
04-23 1481
模板 #include <bits/stdc++.h> using namespace std; #define lw pos << 1 #define rw pos << 1 | 1 #define int long long /* --------------- fast io --------------- */ // begin namespace Fread { const int SIZE = 1 << 21; char buf
线段树区间修改-延迟标记
帅比王的博客
04-15 470
延迟标记 在线段树中，单点修改时，我们是将信息从叶节点向上依次更新它的父节点，直到根节点。如果在区间修改仍然按照这个策略，那么修改的时间复杂度为O(N)。 为了降低时间复杂度，我们可以在更新时只更新大区间，不向下更新到叶子节点，等查询时再更新。举个例子：我们将1-5的位置上每个数+100，重复10000次上述操作。我们加10000次100和直接+1000000是相等的效果，但是一个执行了10000...
区间修改，区间查询（线段树）
weixin_40895249的博客
11-23 833
试想我们在线段树上修改区间[l,r]中的每一个元素的值，而且该区间覆盖了节点node代表的区间[node.l, node.r], 我们当然可以逐一更新子树node中的所有元素，但这个逐一更新的操作是不必要的，因为后续的询问指令可能没有用到[l,r]的子区间。修改时，在节点区间被待修改目标区间完全覆盖时立即返回，回溯时向当前节点累计一个延迟标记，标记其子节点尚未更新。延迟是设计算法和解决问题的重要思路之一，可以减少徒劳的操作，有效降低时间复杂度。Q l r，表示询问数列中第 l∼r个数的和。
线段树（区间修改）
HT008的Blog
08-06 258
题目区间修改有乘法和加法并存，开两个lazy标记，注意两个lazy标记的下放方式（在注释中）#include <cstdio> #include <iostream> #define ll long long using namespace std; const int maxn=120000; int p; struct tree{ ll adx,adi;//adx为乘法标记,adi为加
线段树详解：动态数据结构与区间查询
此外，线段树在处理区间更新时可能会遇到重叠区间的问题，需要特别注意处理方式，例如懒惰标记法就是一种常见的优化手段，用于延迟处理某些更新。 总结来说，线段树是一种强大的数据结构，它在处理区间查询和修改...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值