线段树特殊懒惰标记hdu3954（hdu4902）

最新推荐文章于 2021-12-24 16:42:10 发布
最新推荐文章于 2021-12-24 16:42:10 发布
阅读量658 收藏 1
点赞数 1
分类专栏： 树状数组/线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010660276/article/details/38360519
版权

F.A.Q
Hand In Hand
Online Acmers
Forum | Discuss
Statistical Charts
Problem Archive
Realtime Judge Status
Authors Ranklist
 
      C/C++/Java Exams     
ACM Steps
Go to Job
Contest LiveCast
ICPC@China
Best Coder beta
VIP | STD Contests
Virtual Contests 
    DIY | Web-DIY beta
Recent Contests

Level up

Time Limit: 10000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3327    Accepted Submission(s): 907


Problem Description
Level up is the task of all online games. It's very boooooooooring. There is only level up in those games, except level up.
In a online game, there are N heroes numbered id from 1 to N, each begins with level 1 and 0 Experience. They need to kill monsters to get Exp and level up.

There are many waves of monsters, each wave, the heroes with id from li to ri will come to kill monsters and those hero with level k will get ei*k Exp. If one hero's Exp reach Needk then the hero level up to level k immediately.
After some waves, I will query the maximum Exp from li to ri.
Now giving the information of each wave and Needk, please tell me the answer of my query.
 

Input
The first line is a number T(1<=T<=30), represents the number of case. The next T blocks follow each indicates a case.
The first line of each case contains three integers N(1<=N<=10000), K(2<=K<=10) and QW(1<=QW<=10000)each represent hero number, the MAX level and querys/waves number.
Then a line with K -1 integers, Need2, Need3...Needk.(1 <= Need2 < Need3 < ... < Needk <= 10000).
Then QW lines follow, each line start with 'W' contains three integers li ri ei (1<=li<=ri<=N , 1<=ei<=10000); each line start with 'Q' contains two integers li ri (1<=li<=ri<=N).
 

Output
For each case, output the number of case in first line.(as shown in the sample output)
For each query, output the maximum Exp from li to ri.
Output a black line after each case.
 

Sample Input 
      
      

       
       2
3 3 5
1 2
W 1 1 1
W 1 2 1
Q 1 3
W 1 3 1
Q 1 3

5 5 8
2 10 15 16 
W 5 5 9
W 3 4 5
W 1 1 2
W 2 3 2
Q 3 5
W 1 3 8
Q 1 2
Q 3 5
 

Sample Output 
      
      

       
       Case 1:
3
6

Case 2:
9
18
25

       
       

        
        

         
         Hint
        
        

Case 1:
At first ,the information of each hero is 0(1),0(1),0(1) [Exp(level)]
After first wave, 1(2),0(1),0(1);
After second wave, 3(3),1(2),0(1);
After third wave, 6(3),3(3),1(2);
Case 2:
The information of each hero finally:
18(5) 18(5) 25(5) 5(2) 9(2)
 

Author
NotOnlySuccess


题意：有N个英雄，每个英雄的初始等级为1，初始经验为0，有K个等级，QW个操作。接下来一行中有K-1个数值，代表升到等级2，等级3……所要达到的经验。接下来的QW行里，每行是一个操作，操作有两类，（1）"l r e"，代表区间[l,r]里的每个英雄将得到e乘以他的等级的经验。（2）"l r"，表示查询区间[l,r]里经验最大值。

思路：线段树维护一个maxv(表示当前段最大值)，level（表示当前段最大的level，用来更新maxv用的），cnt（延迟标记，记录当前段的经验值e），needv（表示到达下一阶段还需要的e）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int maxn=10010;
const int INF=1000000000;
typedef long long LL;

int need[15];
int n,k,q;

struct IntervalTree
{
    LL maxv[maxn<<3];
    LL needv[maxn<<3];
    LL level[maxn<<3];
    LL cnt[maxn<<3];
    void build(int o,int l,int r)
    {
        level[o]=1;
        maxv[o]=cnt[o]=0;
        needv[o]=need[2];
        if(l==r)return ;
        int mid=(l+r)>>1;
        build(o<<1,l,mid);
        build(o<<1|1,mid+1,r);
    }
    void maintain1(int o,int l,int r,int val)
    {
        maxv[o]+=val*level[o];
        LL & now=level[o];
        while(need[now+1]<=maxv[o])now++;
        needv[o]=(need[now+1]-maxv[o])/now+((need[now+1]-maxv[o])%now!=0);
    }

    void maintain2(int o,int val)
    {
        maxv[o]+=level[o]*val;
        needv[o]-=val;
        cnt[o]+=val;
    }
    void pushdown(int o,int l,int r)
    {
        if(cnt[o])
        {
            maintain2(o<<1,cnt[o]);
            maintain2(o<<1|1,cnt[o]);
            cnt[o]=0;
        }
    }
    void pushup(int o,int l,int r)
    {
        if(l>=r)return;
        level[o]=max(level[o<<1],level[o<<1|1]);
        needv[o]=min(needv[o<<1],needv[o<<1|1]);
        maxv[o]=max(maxv[o<<1],maxv[o<<1|1]);
    }

    void update(int o,int l,int r,int q1,int q2,int val)
    {
        if(q1<=l&&r<=q2)
        {
            if(val>=needv[o])
            {
                if(l==r)
                    maintain1(o,l,r,val);
                else
                {
                    pushdown(o,l,r);
                    int mid=(l+r)>>1;
                    if(q1<=mid)update(o<<1,l,mid,q1,q2,val);
                    if(q2>mid)update(o<<1|1,mid+1,r,q1,q2,val);
                    pushup(o,l,r);
                }
            }
            else maintain2(o,val);
            return;
        }
        pushdown(o,l,r);
        int mid=(l+r)>>1;
        if(q1<=mid)update(o<<1,l,mid,q1,q2,val);
        if(q2>mid)update(o<<1|1,mid+1,r,q1,q2,val);
        pushup(o,l,r);
    }

    LL query(int o,int l,int r,int q1,int q2)
    {
        if(q1<=l&&r<=q2)return maxv[o];
        int mid=(l+r)>>1;
        pushdown(o,l,r);
        LL x=0,y=0;
        if(q1<=mid)x=query(o<<1,l,mid,q1,q2);
        if(q2>mid)y=query(o<<1|1,mid+1,r,q1,q2);
        pushup(o,l,r);
        return max(x,y);
    }

}tree;

int main()
{
    int T,cas=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&k,&q);
        for(int i=2;i<=k;i++)scanf("%d",&need[i]);
        need[k+1]=INF;
        char op[5];
        tree.build(1,1,n);
        printf("Case %d:\n",cas++);
        while(q--)
        {
            int l,r,e;
            scanf("%s%d%d",op,&l,&r);
            if(op[0]=='W')
            {
                scanf("%d",&e);
                tree.update(1,1,n,l,r,e);
            }
            else
                cout<<tree.query(1,1,n,l,r)<<endl;
        }
        printf("\n");
    }
    return 0;
}


在今年的多校联合也遇到了一个这样的题hdu4902和hdu4893,4893前面写过了，这里只写hdu4902

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int maxn=100010;
typedef long long LL;
int n,Q;
LL a[maxn];

LL gcd(LL x,LL y)
{
    if(y==0)return x;
    return gcd(y,x%y);
}

struct IntervalTree
{
    int setv[maxn<<3];
    LL minv[maxn<<3];
    LL maxv[maxn<<3];
    void build(int o,int l,int r)
    {
        setv[o]=-1;
        if(l==r)
        {
            minv[o]=maxv[o]=a[l];
            return;
        }
        int mid=(l+r)>>1;
        build(o<<1,l,mid);
        build(o<<1|1,mid+1,r);
        minv[o]=min(minv[o<<1],minv[o<<1|1]);
        maxv[o]=max(maxv[o<<1],maxv[o<<1|1]);
    }
    void pushup(int o)
    {
        minv[o]=min(minv[o<<1],minv[o<<1|1]);
        maxv[o]=max(maxv[o<<1],maxv[o<<1|1]);
    }
    void pushdown(int o,int l,int r)
    {
        if(setv[o]==1)
        {
            setv[o<<1]=setv[o<<1|1]=1;
            minv[o<<1]=minv[o<<1|1]=minv[o];
            maxv[o<<1]=maxv[o<<1|1]=maxv[o];
            setv[o]=-1;
        }

    }
    void update(int o,int l,int r,int q1,int q2,LL val,int t)
    {
        if(q1<=l&&r<=q2)
        {
            if(t==1)
            {
                setv[o]=1;
                minv[o]=maxv[o]=val;
                return;
            }
            else
            {
                if(setv[o]==1)
                {
                    if(maxv[o]>val)
                    {
                        LL tmp=gcd(maxv[o],val);
                        minv[o]=maxv[o]=tmp;
                    }
                    return;
                }
                else if(val>=maxv[o])return;
            }
        }
        if(l==r)
        {
            if(t==2&&val<maxv[o])
            {
                LL tmp=gcd(maxv[o],val);
                maxv[o]=minv[o]=tmp;
            }
            return;
        }
        pushdown(o,l,r);
        int mid=(l+r)>>1;
        if(q1<=mid)update(o<<1,l,mid,q1,q2,val,t);
        if(q2>mid)update(o<<1|1,mid+1,r,q1,q2,val,t);
        pushup(o);
    }
    LL query(int o,int l,int r,int pos)
    {
        if(setv[o]==1)return minv[o];
        if(l==r)return minv[o];
        int mid=(l+r)>>1;
        if(pos<=mid)return query(o<<1,l,mid,pos);
        else return query(o<<1|1,mid+1,r,pos);
    }

}tree;

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;i++)scanf("%I64d",&a[i]);
        tree.build(1,1,n);
        scanf("%d",&Q);
        while(Q--)
        {
            int t,l,r;
            LL x;
            scanf("%d%d%d%I64d",&t,&l,&r,&x);
            tree.update(1,1,n,l,r,x,t);
        }
        for(int i=1;i<=n;i++)
        {
            printf("%I64d ",tree.query(1,1,n,i));
        }
        printf("\n");
    }
    return 0;
}



u010660276
关注
专栏目录
线段树 区间更新区间查询 配题 （HDU 4902）
猫ER
10-30 254
区间更新，可以采用遍历点更新的方式，但是时间复杂度很高，故此引用了lazy，延迟思想： 如果一个线段树的划分区间属于更新区间，可以先将所有的操作“累加”在该区间，不需要在继续向下更新。 如果一个线段树的划分区间属于更新区间并且区间内的数值是一致的，那么可以先将操使用于该区间，而不需要继续向下更新，因为该区间内的所有数值是一致的。 引入两个函数： Push_down函数：当前的线段树划分区间不...
HDU-4578 线段树 懒惰标记的下推顺序（好题）
安得广厦千万间的博客
05-29 1142
链接 点击打开链接Yuanfang is puzzled with the question below: There are n integers, a1, a2, …, an. The initial values of them are 0. There are four kinds of operations.Operation 1: Add c to each number betwee...
线段树下推标记（懒惰标记，延迟标记）
Tong_zhi的博客
09-13 1882
解释： 理论上来说，如果[3, 9]这个区间被修改的话，那么下图中的所有绿色的结点的值都要得到重新计算的： 但是实际上是没有必要这么做的——我们可以引进一种叫做Lazy Tag，即延迟标记的东西——的确对于[3, 9]这样一次修改操作，我可以只去修改如下图中橙色的结点，但是在这个基础上，我要在[3, 9]分解出的4个区间[3, 3], [4, 5], [6, 8], [9, 9]所对应的结...
hdu 4902 Nice boat 2014年多校联合第四场
risker_2013的专栏
07-31 1013
点击打开题目链接 Nice boat Time Limit: 30000/15000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 49    Accepted Submission(s): 17 Problem Description
Just a Hook HDU - 1698（线段树的懒惰标记）
Coldfresh的博客
07-02 528
In the game of DotA, Pudge’s meat hook is actually the most horrible thing for most of the heroes. The hook is made up of several consecutive metallic sticks which are of the same length. Now Pudge wan
线段树（区间修改，单点查询）懒惰标记
JSASL的博客
09-27 356
这是一道模板题。 给定数列 a[1],a[2],…,a[n]你需要依次进行 q 个操作，操作有两类： 1 l r x：给定 l,r,x，对于所有 i∈[l,r]，将 a[i] 加上 x（换言之，将 a[l],a[l+1],…,a[r] 分别加上 x）； 2 l r：给定 l,r求 ∑ri=la[i]的值（换言之，求 a[l]+a[l+1]+⋯+a[r]的值）。 Input 第一行包含 2 个正整数 n,q表示数列长度和询问个数。保证 1≤n,q≤106。 第二行 n个整数 a[1],a[2],…,a[n]表
ACM hdu 线段树题目+源代码
06-19
New 操作时，我们可以从左到右遍历线段树，找到第一个可用的内存单元，分配该单元并更新其懒惰标记。Free 操作时，我们可以找到该内存单元，并将其懒惰标记设置为 0。Get 操作时，我们可以遍历线段树，找到第 x 个...
线段树
lalala445566的博客
04-21 180
本博客同步更新至 https://startcraft.cn 介绍 线段树的应用场景在区间修改和区间查询上，修改和查询的时间复杂度都为O(log n) 线段树如它的名字一样将区间分成一段一段的，如123456789这一串数字，以区间求和为例 {% qnimg seg_tree1.png %} 上图就是构建的线段树，其中结点里的值是该结点表示的区间的和，中括号里的数字代表表示的区间 实现(以区间求...
线段树完整版
12-17
2. **区间加法更新** (`range addition update`): 在某些情况下，我们需要更新某个区间内的元素值，可以通过在线段树上打上标记的方式来快速完成，而不是逐个更新每个元素。 #### 六、总结 线段树是一种非常强大的...
线段树题目
07-16
- **HDU 3074**：简单的线段树题目，要求求解区间乘积。在节点中维护区间乘积信息即可。 - **BZOJ 1798**：涉及到区间乘法和加法的操作，需要求解区间和。在线段树中需要支持这两种操作，并正确处理它们之间的关系...
线段树（懒标记）
SZTU_ZJB的博客
05-22 2847
线段树 基本信息 全称 线段树（Segment Tree） 起源与介绍 线段树是一种二叉树，可视为树状数组的变种，最早出现在2001年，由程式竞赛选手发明。 作用 线段树可以在O(log n) 的时间复杂度内实现单点修改、区间修改、区间查询（区间求和，求区间最大值，求区间最小值）等操作。 基本概念 线段树是一种基于分治思想的二叉树，用于在区间上进行信息的统计。与按照二进制进行区间划分的树状数组相比，线段树是一种更加通用的结构； 线段树的每一个节点都代表一个区间 线段树具有的唯一根节点，代表的区间是整个统计
线段树进阶（懒惰标记）
ReverieZH的博客
09-03 1536
对于朴素线段树，要进行区间更新，如果按照单点更新的方法更新，他的复杂度很高，比数组暴力更新还要慢。 所以我们使用懒惰标记，他走到包含区间就不往下走了，然后就更新区间值，并打上懒惰标记。那走到这不走了，他下面的没更新怎么办，这时候就是懒惰标记的用处了，我打上懒惰标记，那我下次往下走的时候我把这个值加上不就行了（也就是懒惰标记的值） 如更新2到10区间的值，那么我走到绿色勾处就不往下走了，打上懒惰...
线段树及其懒标记
qq_51699436的博客
12-24 750
懒标记基本原则： 1、如果当前区间被完全覆盖在目标区间里，讲这个区间的sum+k*(tree[i].r-tree[i].l+1) 2、如果没有完全覆盖，则先下传懒标记 3、如果这个区间的左儿子和目标区间有交集，那么搜索左儿子 4、如果这个区间的右儿子和目标区间有交集，那么搜索右儿子 代码示例： //洛谷P3372 #include<iostream> #include<queue> #include<string> using namespace std; typede
poj3468 线段树懒惰标记
zht的专栏
03-13 410
如题：http://poj.org/problem?id=3468   A Simple Problem with Integers Time Limit: 5000MS   Memory Limit: 131072K Total Submissions: 68742   Accepted: 21188 Case Time Limit: 2000M
HDU 3275 Light （线段树+懒惰标记）
sxtopc的博客
11-09 277
Light Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Practice HDU 3275 Description Felicia was given a long string of fancy lanterns, but
hdu1698（线段树区间操作，绝对懒惰标记）
林伏案的博客
11-18 400
/* translation: 有一段数列，初始值为1,后来有若干操作，把连续一段的数字改成1,2,3中的某一个。问经过若干操作后 这段数列的和是多少？ solution: 线段树的区间操作。 note: 注意这道题和poj3468的不同是poj3468的操作顺序对结果没有影响，而这道题是有影响的。 所以懒惰标记无论在更新还是查询的时候都要往下面带。 date: 2016.11.18
线段树-懒标记详解
qq_42629399的博客
12-18 4327
首先，我们可以想到用线段树来做这道题。不会告诉你其实我不会树状数组 数据太大就会超时，怎么办？这样就要引出我们的好帮手懒标记了！ 一个支持区间修改的线段树, 就要用到lazy标记. 用到哪一个结点, 有效数据就更新到哪一个结点, 避免浪费更新那些不必要的结点的时间. 从根部向下找一个结点, 一路下来根据lazy的设定进行相关的更新操作, 就能快速完成任务. 下面就示范一组样例： 8 2 3 3 3...
POJ 3667 Hotel 线段树lazy标记 （模板~~）
NeighThorn的博客
08-04 1050
线段树lazy标记
【知识】线段树（懒惰标记下传）
qq_36314344的博客
07-12 458
1、线段树共2n-1个结点。补成满二叉树，结点数或超过2n，故开成4n大小。 2、区间修改时，修改某结点后，要更新该结点的所有信息，且更新其祖先结点的信息。 3、区间查询时，遇到懒惰标记，则传给它的左右儿子，并更新左右儿子的信息，当前的懒惰标记置为0，且其祖先结点信息不用修改。 ...
NotOnlySuccess的线段树完全解析
3. HDU 1394 最小逆序数：此问题需要在线段树中实现单点增减，并进行区间求和。通过线段树，可以在O(n log n)的时间复杂度内预处理初始逆序数，然后以O(1)的时间复杂度递推出其他解。 4. HDU 2795 Billboard：这是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值