线段树+优化（hdu 5828 hdu 4027）

最新推荐文章于 2020-03-20 18:12:10 发布
最新推荐文章于 2020-03-20 18:12:10 发布
阅读量370 收藏
点赞数
分类专栏： ××××××算法学习×××××× 文章标签： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_GSir/article/details/52201009
版权
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=5828

题目意思：对于一组数据，只能进行三种操作：1 对区间[l,r]中的每个数据进行加value操作，2 对区间[l,r]中的每个数据进行开方向下取整操作 3 对于区间[l,r]中的数据进行求和操作

题目思路：开根号操作很快，对于2^64 最多8次会变成1，所以会存在很大一些数据相等的情况，对于加法操作，只需要多用一个lazy进行维护，对于没有用到的底层，只要把加法保留到上一层即可，等到用到了在进行向下更新，没有用到一直累加在上一层，但注意每一次进行add插入之时要进行更新，免得出矛盾，对于sqrt见下注释

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#define N 100050

using namespace std;
long long  sum[N*4],minn[N*4],maxx[N*4],lazy[N*4];//lazy用于记录没有下放的add数据总和，只有需要使用时才下放
void push_up(int root)//每次下层数据更新后，更新当前层数据
{
    sum[root]=sum[root<<1]+sum[root<<1|1];
    minn[root]=min(minn[root<<1],minn[root<<1|1]);
    maxx[root]=max(maxx[root<<1],maxx[root<<1|1]);
}
void push_down(int root,int length)  //每次对之前没有继续下放的数据进行更新
{
    if(lazy[root])//用于更新add没有下放的数据
    {
        lazy[root<<1]+=lazy[root];
        lazy[root<<1|1]+=lazy[root];
        sum[root<<1]+=lazy[root]*(length-length/2);
        sum[root<<1|1]+=lazy[root]*(length/2);
        maxx[root<<1]+=lazy[root];
        maxx[root<<1|1]+=lazy[root];
        minn[root<<1]+=lazy[root];
        minn[root<<1|1]+=lazy[root];
        lazy[root]=0;
    }
    if(minn[root]==maxx[root])//用于更新sqrt没有下放的数据
    {
        minn[root<<1]=minn[root<<1|1]=maxx[root<<1]=maxx[root<<1|1]=minn[root];
        sum[root<<1]=minn[root]*(length-length/2);sum[root<<1|1]=minn[root]*(length/2);
    }
}
void build(int root,int l,int r) //建树
{
    lazy[root]=0;
    if(l==r)
    {
        scanf("%lld",&sum[root]);
        minn[root]=sum[root];
        maxx[root]=sum[root];
        return;
    }
    int mid=(l+r)>>1;
    build(root<<1,l,mid);
    build(root<<1|1,mid+1,r);
    push_up(root);
}
void updateadd(int vl,int vr,int v,int root,int l,int r)//add操作
{
    if(vl<=l && r<=vr)
    {
        sum[root]+=(long long)v*(r-l+1);
        maxx[root]+=v;
        minn[root]+=v;
        lazy[root]+=v;
        return;
    }
    push_down(root,r-l+1);
    int mid=(l+r)>>1;
    if(vr>mid)
    {
        updateadd(vl,vr,v,root<<1|1,mid+1,r);
    }
    if(vl<=mid)
    {
        updateadd(vl,vr,v,root<<1,l,mid);
    }
    push_up(root);
}
void updatesqrt(int vl,int vr,int root,int l,int r)//sqrt操作
{
    if(vl<=l && r<=vr)
    {
        if((int)(sqrt(minn[root]))==(int)(sqrt(maxx[root])))
        {
            minn[root]=maxx[root]=(int)sqrt(minn[root]);
            sum[root]=minn[root]*(r-l+1);
        }
        //只有极差为1的时候才会出现加一个值再开方会出现原序列
             /*
             比如2 3 2 3 2 3然后整体加6然后开根号，又会变回2 3 2 3 2 3相当于不会出现区间数字一样的情况了，
             这样就相当于没剪枝，变成了n^2...后来发现只有极差为1的时候才会出现这种情况，极差>1的话是不可
             能维持原来的序列的，那么就可以维护一个最大值和最小值，如果极差为1的话那么区间开根号其实相当
             于区间减去了x-sqrt(x)
             */
        else if(minn[root]+1==maxx[root])
        {
            int k = maxx[root]-(int)sqrt(maxx[root]);
            updateadd(vl,vr,-k,root,l,r);
        }
        else
        {
            push_down(root,r-l+1);
            int mid = (l+r)>>1;
            if(vl<=mid)updatesqrt(vl,vr,root<<1,l,mid);
            if(vr>mid)updatesqrt(vl,vr,root<<1|1,mid+1,r);
            push_up(root);
        }
        return;
    }
    push_down(root,r-l+1);
    int mid=(l+r)>>1;
    if(vr>mid)
    {
        updatesqrt(vl,vr,root<<1|1,mid+1,r);
    }
    if(vl<=mid)
    {
        updatesqrt(vl,vr,root<<1,l,mid);
    }
    push_up(root);
}
long long query(int vl,int vr,int root,int l,int r)
{
    if(vl<=l && r<=vr)
    {
        return sum[root];
    }
    push_down(root,r-l+1);
    int mid=(l+r)>>1;
    long long ans=0;
    if(vl<=mid)
    {
        ans+=query(vl,vr,root<<1,l,mid);
    }
    if(vr>mid)
    {
        ans+=query(vl,vr,root<<1|1,mid+1,r);
    }
    return ans;
}
int main()
{
    int t;
    int n,m;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&n,&m);
        build(1,1,n);
        for(int i=1;i<=m;i++)
        {
            int l,r,v,op;
            scanf("%d",&op);
            if(op==1)
            {
                scanf("%d %d %d",&l,&r,&v);
                updateadd(l,r,v,1,1,n);
            }
            if(op==2)
            {
                scanf("%d %d",&l,&r);
                updatesqrt(l,r,1,1,n);
            }
            if(op==3)
            {
                scanf("%d %d",&l,&r);
                printf("%lld\n",query(l,r,1,1,n));
            }
        }
    }
    return 0;
}

类似题目： http://acm.hdu.edu.cn/showproblem.php?pid=4027

题目意思：就是上面的1，2操作，去掉了加法

思路：就是上面的思路，代码也是直接上面改的，但要主要每次case结束要空一行，并且l r 不一定满足l<r

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#define N 100050

using namespace std;
long long  sum[N*4],minn[N*4],maxx[N*4],lazy[N*4];
void push_up(int root)
{
    sum[root]=sum[root<<1]+sum[root<<1|1];
    minn[root]=min(minn[root<<1],minn[root<<1|1]);
    maxx[root]=max(maxx[root<<1],maxx[root<<1|1]);
}
void push_down(int root,int length)
{
    if(lazy[root])
    {
        lazy[root<<1]+=lazy[root];
        lazy[root<<1|1]+=lazy[root];
        sum[root<<1]+=lazy[root]*(length-length/2);
        sum[root<<1|1]+=lazy[root]*(length/2);
        maxx[root<<1]+=lazy[root];
        maxx[root<<1|1]+=lazy[root];
        minn[root<<1]+=lazy[root];
        minn[root<<1|1]+=lazy[root];
        lazy[root]=0;
    }
    if(minn[root]==maxx[root])
    {
        minn[root<<1]=minn[root<<1|1]=maxx[root<<1]=maxx[root<<1|1]=minn[root];
        sum[root<<1]=minn[root]*(length-length/2);sum[root<<1|1]=minn[root]*(length/2);
    }
}
void build(int root,int l,int r)
{
    lazy[root]=0;
    if(l==r)
    {
        scanf("%lld",&sum[root]);
        minn[root]=sum[root];
        maxx[root]=sum[root];
        return;
    }
    int mid=(l+r)>>1;
    build(root<<1,l,mid);
    build(root<<1|1,mid+1,r);
    push_up(root);
}
void updateadd(int vl,int vr,int v,int root,int l,int r)
{
    if(vl<=l && r<=vr)
    {
        sum[root]+=(long long)v*(r-l+1);
        maxx[root]+=v;
        minn[root]+=v;
        lazy[root]+=v;
        return;
    }
    push_down(root,r-l+1);
    int mid=(l+r)>>1;
    if(vr>mid)
    {
        updateadd(vl,vr,v,root<<1|1,mid+1,r);
    }
    if(vl<=mid)
    {
        updateadd(vl,vr,v,root<<1,l,mid);
    }
    push_up(root);
}
void updatesqrt(int vl,int vr,int root,int l,int r)
{
    if(vl<=l && r<=vr)
    {
        if((int)(sqrt(minn[root]))==(int)(sqrt(maxx[root])))
        {
            minn[root]=maxx[root]=(int)sqrt(minn[root]);
            sum[root]=minn[root]*(r-l+1);
        }
        //只有极差为1的时候才会出现加一个值再开方会出现原序列
             /*
             比如2 3 2 3 2 3然后整体加6然后开根号，又会变回2 3 2 3 2 3相当于不会出现区间数字一样的情况了，
             这样就相当于没剪枝，变成了n^2...后来发现只有极差为1的时候才会出现这种情况，极差>1的话是不可
             能维持原来的序列的，那么就可以维护一个最大值和最小值，如果极差为1的话那么区间开根号其实相当
             于区间减去了x-sqrt(x)
             */
        else if(minn[root]+1==maxx[root])
        {
            int k = maxx[root]-(int)sqrt(maxx[root]);
            updateadd(vl,vr,-k,root,l,r);
        }
        else
        {
            push_down(root,r-l+1);
            int mid = (l+r)>>1;
            if(vl<=mid)updatesqrt(vl,vr,root<<1,l,mid);
            if(vr>mid)updatesqrt(vl,vr,root<<1|1,mid+1,r);
            push_up(root);
        }
        return;
    }
    push_down(root,r-l+1);
    int mid=(l+r)>>1;
    if(vr>mid)
    {
        updatesqrt(vl,vr,root<<1|1,mid+1,r);
    }
    if(vl<=mid)
    {
        updatesqrt(vl,vr,root<<1,l,mid);
    }
    push_up(root);
}
long long query(int vl,int vr,int root,int l,int r)
{
    if(vl<=l && r<=vr)
    {
        return sum[root];
    }
    push_down(root,r-l+1);
    int mid=(l+r)>>1;
    long long ans=0;
    if(vl<=mid)
    {
        ans+=query(vl,vr,root<<1,l,mid);
    }
    if(vr>mid)
    {
        ans+=query(vl,vr,root<<1|1,mid+1,r);
    }
    return ans;
}
int main()
{
    int t=1;
    int n,m;
    while(scanf("%d",&n)!=EOF)
    {
        printf("Case #%d:\n",t++);
        build(1,1,n);
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            int l,r,v,op;
            scanf("%d",&op);
            /*if(op==3)
            {
                scanf("%d %d %d",&l,&r,&v);
                updateadd(l,r,v,1,1,n);
            }*/
            scanf("%d %d",&l,&r);
            if(l>r){swap(l,r);}
            if(op==0)
            {
                updatesqrt(l,r,1,1,n);
            }
            if(op==1)
            {
                printf("%lld\n",query(l,r,1,1,n));
            }
        }
        printf("\n");
    }
    return 0;
}


M_GSir
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ACM hdu 线段树题目+源代码
06-19
ACM hdu 线段树题目+源代码 线段树是一种非常重要的数据结构，它广泛应用于算法竞赛和实际编程中。今天，我们将通过 ACM hdu 的几个题目来学习和掌握线段树的基本概念和应用。 线段树的基本概念 线段树是一种...
【题解】「HDU1166」敌兵布阵(线段树)
01-20
题面 【题目描述】 有nnn个营地，已知每个营地的人数，有四条命令： (1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj不超过303030） (2)Sub(2)Sub(2)Sub iii jjj ，iii和jjj为正...
HDU5828(线段树好题，区间加，区间求根号，吉老师在51nod直播讲过这道题，相应的还有区间取模)
nucshiyilang的博客
07-22 1076
题解：区间加，区间和不用说。重点在区间取模，首先，就算一个很大的n，几次根号之后就会很小。 我们可以思考一下，如果一个区间内的极差>1的时候，不断地进行整体加某个值然后开方，是没办法保持住这样的序列的（相邻两个极差都>1）。只有整个区间内的极差 #include #include #include #include #include #include #include #include #in
HDU - 5828 Rikka with Sequence
weixin_44059127的博客
03-20 123
题意： 给定一个长度为 nnn 的数组 aaa，再有 mmm 次操作，① 1,l,r,x1, l, r, x1,l,r,x，区间加 xxx；② 2,l,r2, l, r2,l,r，区间开根；③ 3,l,r3, l, r3,l,r，询问区间和。(n,m,ai,x≤105)(n, m, a_i, x \leq 10^5)(n,m,ai​,x≤105) 链接： https://vjudge.net/pr...
HDU 5828 多校第八场 1008 Rikka with Sequence(线段树--数据加强版)
xtttgo的博客
08-11 1689
传送门：http://acm.hdu.edu.cn/showproblem.php?pid=5828题意：三种操作，一种是区间增加，一种是区间开方，一种是区间求和。原思路（数据已加强，这个方法已经过不了）：很快能想到，如果一个100000的数字，最多开方个四五次以后，就变成1了，而且sqrt(1)=1，那么我们就可以在更新的时候想到一个很方便的剪枝，就是，如果这个区间的最大值是1，也就是这个区间全部
Hdu-5828 Rikka with Sequence（线段树）
WZJRJ28
08-11 364
Problem Description As we know, Rikka is poor at math. Yuta is worrying about this situation, so he gives Rikka some math tasks to practice. There is one of them: Yuta has an array A with n number
Hdu5828-Rikka with Sequence(线段树区间开方)
bairui0504的博客
10-22 242
写在前面ldx神犇今讲线段树，然后就涉及到了本题目的一个骚操作。 传送门Solution注意到本题实际上要求的是区间加，区间求和，区间开根号。前两个是常规操作，学了都会，然而怎样开根号？显然我们应该暴力修改开方这个操作本身进行考虑。那么注意到，开一次方，一个序列中的每个数逐步接近其他的数，所以说我们可以考虑这么干：对序列维护一个最大值与最小值，如果说他们开方以后最大值减去最小值的差大于...
hdu acm1166线段树
05-03
hdu 1166线段树代码
线段树入门学习(兼解HDU1754)
04-14
这篇博客“线段树入门学习(兼解HDU1754)”旨在帮助初学者理解线段树的基本概念，并通过解决HDU1754题目来实践其应用。 线段树的核心思想是将一个区间分解成多个子区间，然后对每个子区间进行预处理，存储区间的信息...
hdu 1166线段树
07-02
标题与描述均提到了“hdu 1166线段树”，这表明文章的核心是关于线段树在解决特定问题中的应用。线段树是一种数据结构，主要用于处理区间查询和更新操作，尤其是在大规模数据集上。在本例中，通过分析给定的部分代码...
【HDU 5828】Rikka with Sequence
forever_dreams的博客
10-23 165
算法标签：线段树
hdu 5828
nare123的博客
02-11 273
维护区间和+最大最小值就行了.#include<stdio.h> #include<iostream> #include<algorithm> #include<string> #include<string.h> #include<math.h> using namespace std; #define INF 99999999 #define ll long long struct p{ i
hdu 5828 Rikka with Sequence 【线段树+优化】
Fb_by
08-12 769
链接：http://acm.hdu.edu.cn/showproblem.php?pid=5828 题意：给你n个数，q个操作，操作k，l，r，k=1时 区间[l,r]每个数加x，k=2时，区间[l,r]每个数开平方，k=3时，求区间[l,r]的和。 分析：我们知道一个数多次开平方会变成1，但是这里的1操作会使这个数的值增大，所以直接判断一个区间是否为1肯定超时。 官方题解加了个优化，就是判
HDU 5828（线段树）
aekijekzn484879763的博客
08-11 138
ProblemRikka with Sequence 题目大意 　　维护一个序列，支持三种操作。 　　操作1：区间加。　　操作二：区间开根号（向下取整）。　　操作3：区间求和。 解题分析 　　可以发现经过若干次操作后，整些区间内的数会趋向于相同。 　　可以再开一个标记，表示这个区间内的数是否相同，这样可以优化一下区间开根号的复杂度。 　　然后就卡过去了~~ 　　Push...
省选专练之数据结构HDU5828
dingwufu9301的博客
07-23 118
Rikka with Sequence Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem Description As we know, Rikka is poor at math. Yuta is worry...
HDU 5828 Rikka with Sequence（线段树）
AC_Arthur的专栏
08-11 1089
题目链接：点击打开链接 思路： 对于该题， 由于存在区间加一个值， 那么所有数都可能永远不会变成1， 但是数与数之间的相对值会趋近于相等。  比如1 2 3 4 5， 进行一次根号操作变成1 1 1 2 2， 而一旦如果相等， 那么他们同时加一个数也是相等的。  所以我们增加一个标记bit[rt]表示该区间内的数是否全部相等，如果相等等于什么。 细节参见代码： #include #inc
HDU5828 区间开根加法求和 线段树
HbFS-
09-19 891
先需要想到一个结论： 对于线段树上的一块，进行整体开根和加法（加法不影响结果）的次数越多，区间的最大值与最小值的差越小。 利用这个性质，我们维护一棵线段树，线段树上维护区间最大值、最小值、和、元素个数。 对于建树、区间加法（修改）、区间查询，写法就是朴素的线段树 对于区间开根： 1、若区间最大值和最小值的差为0，即整个区间的所有元素相等。此时开根相当于区间覆盖同一个值。 2、若区间最大
【HDU 5828】Rikka with Sequence（线段树）
ACMer'
08-22 1805
【HDU 5828】Rikka with Sequence（线段树）Rikka with SequenceTime Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 2311    Accepted Submission(s): 391 Problem
『HDU 5828』Rikka with Sequence 【加强版已过】
Gavinjou大笨象的博客
08-12 1368
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5828 转载链接:http://blog.csdn.net/xtttgo/article/details/52184771（数据加强后代码AC） 题意: 线段树基本操作题 给你一个区间 有3个指令 1 l r x:【l,r】+x; 2 l r：【l,r】中的每个元素都得开根号 3 l r :
线段树详解：区间操作与优化
文章中提到的编程风格优化，如节点数量的设定、节点表示、PushUP 和 PushDown 函数的定义，以及线段树问题的分类，旨在提供更高效、简洁的实现方式。" 线段树是一种数据结构，用于高效地处理区间查询和更新问题。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值