hdu 4578 Transformation(线段树维护区间次方和)

最新推荐文章于 2024-03-31 15:18:04 发布
最新推荐文章于 2024-03-31 15:18:04 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： 线段树&树状数组 文章标签： ACM c 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bossup/article/details/9933937
版权

Transformation

Time Limit: 15000/8000 MS (Java/Others)    Memory Limit: 65535/65536 K (Java/Others)
Total Submission(s): 1378    Accepted Submission(s): 303

Problem Description
Yuanfang is puzzled with the question below:
There are n integers, a 1, a 2, …, a n. The initial values of them are 0. There are four kinds of operations.
Operation 1: Add c to each number between a x and a y inclusive. In other words, do transformation a k<---a k+c, k = x,x+1,…,y.
Operation 2: Multiply c to each number between a x and a y inclusive. In other words, do transformation a k<---a k×c, k = x,x+1,…,y.
Operation 3: Change the numbers between a x and a y to c, inclusive. In other words, do transformation a k<---c, k = x,x+1,…,y.
Operation 4: Get the sum of p power among the numbers between a x and a y inclusive. In other words, get the result of a x p+a x+1 p+…+a y p.
Yuanfang has no idea of how to do it. So he wants to ask you to help him.
 

Input
There are no more than 10 test cases.
For each case, the first line contains two numbers n and m, meaning that there are n integers and m operations. 1 <= n, m <= 100,000.
Each the following m lines contains an operation. Operation 1 to 3 is in this format: "1 x y c" or "2 x y c" or "3 x y c". Operation 4 is in this format: "4 x y p". (1 <= x <= y <= n, 1 <= c <= 10,000, 1 <= p <= 3)
The input ends with 0 0.
 

Output
For each operation 4, output a single integer in one line representing the result. The answer may be quite large. You just need to calculate the remainder of the answer when divided by 10007.
 

Sample Input 
  
  

   
   5 5
3 3 5 7
1 2 4 4
4 1 5 2
2 2 5 8
4 3 5 3
0 0
 

Sample Output 
  
  

   
   307
7489
 

Source
2013ACM-ICPC杭州赛区全国邀请赛
 

题意：

对区间内的数进行各种操作。

1，把[x,y]区间上的每个数加上c。

2，把[x,y]区间上的每个数乘上c.

3，把[x,y]区间上的数置成c。

4,询问区间[x,y]上的每个数的p次方的和。

思路：

       一看就是线段树。开始被次方和吓到了。以前从来没遇到这种类型的。但是再看p的范围只有1到3。于是想到了每个结点维护三个和即sum[0],sum[1],sum[2]分别表示区间内数1次方2次方3次方的和。但是怎么更新结点这几个值呢？

想到线段树都是从儿子结点获得信息然后跟新父亲结点信息的。考虑对一个区间内的数加上一个数c后对这三个值有什么影响。首先考虑一个数c的情况。一次方就不说了直接加上c*区间长度len就行了。

二次方。一个数开始为a。后来为a+c。则平方后为a*a+2*a*c+c*c。比原来多了2*a*c+c*c。而对于整个区间增加

2*sum[0]*c+len*c*c。三次方增加3*sum[1]*c+3*sum[0]*c*c+len*c*c*c。

根据题目的操作在每个结点加三个标记。

same[k]表示区间内数值是否一样。如果相同在用一个变量value[k]存该值。

addv[k]表示区间内的数加的值。

mul[k]表示区间内的数乘的值。

但是想到这里又卡住了。因为在addv[k]和mul[k]是冲突的。因为当这两个标记时不知道是先加的还是先乘的。于是想到标记递归往下传知道不冲突或到了叶子结点停止。比赛时没敢写。觉得这样可能更新到叶子结点效率太低，结果下来一写2sA了。

只是要注意到取模的问题。因为算次方很容易超的。

详细见代码：

#include <iostream>
#include<string.h>
#include<stdio.h>
using namespace std;

const int maxn=100010,mod=10007;
int addv[maxn<<2],mul[maxn<<2],value[maxn<<2],sum[maxn<<2][3];
bool same[maxn<<2];
int n,m;
void small(int k)//对各sum取模
{
    int i;
    for(i=0;i<3;i++)
        if(sum[k][i]>=mod)
        sum[k][i]%=mod;
}
void btree(int L,int R,int k)//建树
{
    int ls,rs,mid;
    addv[k]=0;
    mul[k]=1;
    same[k]=true;
    value[k]=0;
    sum[k][0]=sum[k][1]=sum[k][2]=0;
    if(L==R)
        return;
    ls=k<<1;
    rs=k<<1|1;
    mid=(L+R)>>1;
    btree(L,mid,ls);
    btree(mid+1,R,rs);
}
void pushdown(int L,int R,int k)//根据是否互斥下传标记
{
    int ls,rs,mid,lenl,lenr;
    ls=k<<1;
    rs=k<<1|1;
    mid=(L+R)>>1;
    lenl=mid-L+1;
    lenr=R-mid;
    if(same[k])
    {
        same[ls]=same[rs]=true;
        value[ls]=value[rs]=value[k]%mod;
        sum[ls][0]=value[ls]*lenl%mod;
        sum[ls][1]=sum[ls][0]*value[ls]%mod;
        sum[ls][2]=sum[ls][1]*value[ls]%mod;
        sum[rs][0]=value[rs]*lenr%mod;
        sum[rs][1]=sum[rs][0]*value[rs]%mod;
        sum[rs][2]=sum[rs][1]*value[rs]%mod;
        small(ls);
        small(rs);
        addv[ls]=addv[rs]=0;
        mul[ls]=mul[rs]=1;
        same[k]=false;
    }
    if(addv[k]!=0)
    {
        if(same[ls])
        {
            value[ls]+=addv[k]%mod;
            value[ls]%=mod;
            sum[ls][0]=value[ls]*lenl%mod;
            sum[ls][1]=sum[ls][0]*value[ls]%mod;
            sum[ls][2]=sum[ls][1]*value[ls]%mod;
            small(ls);
        }
        else if(mul[ls]!=1)
        {
            pushdown(L,mid,ls);
            mul[ls]=1;
            addv[ls]=addv[k]%mod;
            sum[ls][2]+=3*sum[ls][1]%mod*addv[k]%mod+3*sum[ls][0]%mod*addv[k]%mod*addv[k]%mod+lenl%mod*addv[k]%mod*addv[k]%mod*addv[k]%mod;
            sum[ls][1]+=lenl%mod*addv[k]%mod*addv[k]%mod+2*sum[ls][0]%mod*addv[k]%mod;
            sum[ls][0]+=lenl%mod*addv[k]%mod;
            small(ls);
        }
        else
        {
            addv[ls]+=addv[k]%mod;
            addv[ls]%=mod;
            sum[ls][2]+=3*sum[ls][1]%mod*addv[k]%mod+3*sum[ls][0]%mod*addv[k]%mod*addv[k]%mod+lenl%mod*addv[k]%mod*addv[k]%mod*addv[k]%mod;
            sum[ls][1]+=lenl%mod*addv[k]%mod*addv[k]%mod+2*sum[ls][0]%mod*addv[k]%mod;
            sum[ls][0]+=lenl%mod*addv[k]%mod;
            small(ls);
        }
        if(same[rs])
        {
            value[rs]+=addv[k]%mod;
            value[rs]%=mod;
            sum[rs][0]=value[rs]*lenr%mod;
            sum[rs][1]=sum[rs][0]*value[rs]%mod;
            sum[rs][2]=sum[rs][1]*value[rs]%mod;
            small(rs);
        }
        else if(mul[rs]!=1)
        {
            pushdown(mid+1,R,rs);
            mul[rs]=1;
            addv[rs]=addv[k]%mod;
            sum[rs][2]+=3*sum[rs][1]%mod*addv[k]%mod+3*sum[rs][0]%mod*addv[k]%mod*addv[k]%mod+lenr%mod*addv[k]%mod*addv[k]%mod*addv[k]%mod;
            sum[rs][1]+=lenr%mod*addv[k]%mod*addv[k]%mod+2*sum[rs][0]%mod*addv[k]%mod;
            sum[rs][0]+=lenr*addv[k]%mod;
            small(rs);
        }
        else
        {
            addv[rs]+=addv[k]%mod;
            addv[rs]%=mod;
            sum[rs][2]+=3*sum[rs][1]%mod*addv[k]%mod+3*sum[rs][0]%mod*addv[k]%mod*addv[k]%mod+lenr%mod*addv[k]%mod*addv[k]%mod*addv[k]%mod;
            sum[rs][1]+=lenr%mod*addv[k]%mod*addv[k]%mod+2*sum[rs][0]%mod*addv[k]%mod;
            sum[rs][0]+=lenr*addv[k]%mod;
            small(rs);
        }
        addv[k]=0;
    }
    else if(mul[k]!=1)
    {
        if(same[ls])
        {
            value[ls]*=mul[k]%mod;
            value[ls]%=mod;
            sum[ls][0]=lenl%mod*value[ls]%mod;
            sum[ls][1]=sum[ls][0]*value[ls]%mod;
            sum[ls][2]=sum[ls][1]*value[ls]%mod;
            small(ls);
        }
        else if(addv[ls]!=0)
        {
            pushdown(L,mid,ls);
            mul[ls]=mul[k]%mod;
            sum[ls][0]*=mul[k]%mod;
            sum[ls][1]*=mul[k]%mod*mul[k]%mod;
            sum[ls][2]*=mul[k]%mod*mul[k]%mod*mul[k]%mod;
            small(ls);
        }
        else
        {
            mul[ls]*=mul[k]%mod;
            mul[ls]%=mod;
            sum[ls][0]*=mul[k]%mod;
            sum[ls][1]*=mul[k]%mod*mul[k]%mod;
            sum[ls][2]*=mul[k]%mod*mul[k]%mod*mul[k]%mod;
            small(ls);
        }
        if(same[rs])
        {
            value[rs]*=mul[k]%mod;
            value[rs]%=mod;
            sum[rs][0]=lenr%mod*value[rs]%mod;
            sum[rs][1]=sum[rs][0]*value[rs]%mod;
            sum[rs][2]=sum[rs][1]*value[rs]%mod;
            small(rs);
        }
        else if(addv[rs]!=0)
        {
            pushdown(mid+1,R,rs);
            mul[rs]=mul[k]%mod;
            sum[rs][0]*=mul[k]%mod;
            sum[rs][1]*=mul[k]%mod*mul[k]%mod;
            sum[rs][2]*=mul[k]%mod*mul[k]%mod*mul[k]%mod;
            small(rs);
        }
        else
        {
            mul[rs]*=mul[k]%mod;
            mul[rs]%=mod;
            sum[rs][0]*=mul[k]%mod;
            sum[rs][1]*=mul[k]%mod*mul[k]%mod;
            sum[rs][2]*=mul[k]%mod*mul[k]%mod*mul[k]%mod;
            small(rs);
        }
        mul[k]=1;
    }
}
void update(int L,int R,int l,int r,int k,int op,int c)//更新
{
    int ls,rs,mid,len;

    len=R-L+1;
    c%=mod;
    len%=mod;
    if(l==L&&r==R)
    {
        if(op==1)
        {
            if(same[k])
            {
                value[k]+=c;
                value[k]%=mod;
                sum[k][0]=len*value[k]%mod;
                sum[k][1]=sum[k][0]*value[k]%mod;
                sum[k][2]=sum[k][1]*value[k]%mod;
            }
            else if(mul[k]!=1)
            {
                pushdown(L,R,k);
                addv[k]=c;
                sum[k][2]+=3*sum[k][1]%mod*c%mod+3*sum[k][0]%mod*c%mod*c%mod+len*c%mod*c%mod*c%mod;
                sum[k][1]+=len*c%mod*c%mod+2*sum[k][0]%mod*c%mod;
                sum[k][0]+=len*c%mod;
            }
            else
            {
                addv[k]+=c;
                addv[k]%=mod;
                sum[k][2]+=3*sum[k][1]%mod*c%mod+3*sum[k][0]%mod*c%mod*c%mod+len*c%mod*c%mod*c%mod;
                sum[k][1]+=len*c%mod*c%mod+2*sum[k][0]%mod*c%mod;
                sum[k][0]+=len*c%mod;
            }
        }
        else if(op==2)
        {
            if(same[k])
            {
                value[k]*=c;
                value[k]%=mod;
                sum[k][0]=value[k]*len%mod;
                sum[k][1]=sum[k][0]*value[k]%mod;
                sum[k][2]=sum[k][1]*value[k]%mod;
            }
            else if(addv[k]!=0)
            {
                pushdown(L,R,k);
                mul[k]=c;
                sum[k][0]*=c;
                sum[k][1]*=c*c%mod;
                sum[k][2]*=c*c%mod*c%mod;
            }
            else
            {
                mul[k]*=c%mod;
                mul[k]%=mod;
                sum[k][0]*=c%mod;
                sum[k][1]*=c%mod*c%mod;
                sum[k][2]*=c%mod*c%mod*c%mod;
            }
        }
        else if(op==3)
        {
            same[k]=true;
            value[k]=c;
            addv[k]=0;
            mul[k]=1;
            sum[k][0]=len*c%mod;
            sum[k][1]=sum[k][0]*c%mod;
            sum[k][2]=sum[k][1]*c%mod;
        }
        small(k);
        return;
    }
    ls=k<<1;
    rs=k<<1|1;
    mid=(L+R)>>1;
    pushdown(L,R,k);
    if(l>mid)
        update(mid+1,R,l,r,rs,op,c);
    else if(r<=mid)
        update(L,mid,l,r,ls,op,c);
    else
    {
        update(L,mid,l,mid,ls,op,c);
        update(mid+1,R,mid+1,r,rs,op,c);
    }
    sum[k][0]=sum[ls][0]+sum[rs][0];
    sum[k][1]=sum[ls][1]+sum[rs][1];
    sum[k][2]=sum[ls][2]+sum[rs][2];
    small(k);
    //printf("%d->%d %d %d %d\n",L,R,sum[k][0],sum[k][1],sum[k][2]);
}
int qu(int L,int R,int l,int r,int k,int p)
{
    int ls,rs,mid;
    if(l==L&&r==R)
       return sum[k][p];
    ls=k<<1;
    rs=k<<1|1;
    mid=(L+R)>>1;
    pushdown(L,R,k);
    if(l>mid)
        return qu(mid+1,R,l,r,rs,p);
    else if(r<=mid)
        return qu(L,mid,l,r,ls,p);
    else
        return (qu(L,mid,l,mid,ls,p)+qu(mid+1,R,mid+1,r,rs,p))%mod;
}
int main()
{
    int com,i,x,y,c;

    while(scanf("%d%d",&n,&m),n||m)
    {
        btree(1,n,1);
        for(i=1; i<=m; i++)
        {
            scanf("%d%d%d%d",&com,&x,&y,&c);
            if(com!=4)
               update(1,n,x,y,1,com,c);
            else
               printf("%d\n",qu(1,n,x,y,1,c-1));
        }
    }
    return 0;
}

哎。。。长的我自己都不想看了。。。尴尬

下传标记应该有更高效的方法的。有空再研究。。。

疯狂的橡树
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hdu acm1166线段树
05-03
hdu 1166线段树代码
E - Yet Another Data Structure Problem ZOJ - 3998（线段树维护区间乘积,k次方）
tomjobs的博客
10-14 302
题意： 3种询问。 1 l r v，代表[l,r]区间每个数乘以v 2 l r v，代表[l,r]区间每个数变成v次方 3 l r，求[l,r]区间乘积 思路： 裸的线段树维护区间次幂和区间乘积。lazy1表示子区间还需要乘以lazy1，lazy2表示子区间要变成lazy2次方。 注意维护次幂的时候要模(mod-1)（欧拉降幂），且要先维护lazy2，再维护lazy1。 #include <cstdio> #include <cstring> #include <algorit
HDU4578 线段树维护区间平方和立方和
Strezia的博客
10-18 253
题目链接 参考blog1 参考blog2 // Decline is inevitable, // Romance will last forever. //#include <bits/stdc++.h> #include <iostream> #include <cmath> #include <cstring> #include <string> #include <cstdio> #include <algorit
题目：区间次方和（蓝桥OJ 3382）
2203_75582171的博客
11-03 290
先创建全部次方的数组（二维数组存放），再进行前缀和运算。最后按题目要求进行区间和运算。
蓝桥杯-区间次方和
最新发布
weixin_60193316的博客
03-31 135
【代码】蓝桥杯-区间次方和。
数据结构：线段树——求区间N次方和
qq_43597227的博客
07-26 568
/* 将某区间每一个数乘上 x 将某区间每一个数加上 x 求出某区间每一个数的和 假设区间一次方和为Sum1 现在要求区间二次方和和三次方...n次方和 设区间一次方和Sum1 = a+b+c+d+... 则区间二次方和为Sum2 = a^2+b^2+c^2+d^2+... 区间每个值增加x后：Sum2=(a+x)^2+(b+x)^2+(c+x)^2+... = (a^2+b^2+c^2+...) + (2*(a+b+c...)*x) + 2*n*(x)^2 =Sum2 + 2*S
【HDU 4027】线段树维护区间和
YG爱木木
04-30 313
1.题目链接。题意简洁，就是两种操作，区间整体开方，区间求和。类似于区间修改操作但是我们没必要再加上懒惰标记，因为开方开多了这个点就会变成1，所以其实连续对区间操作，没有几次就不用进行修改了，我们特判一下区间都是1的情况，这样就直接修改不加懒惰标记也是可以的。 #include<bits/stdc++.h> #include<stdio.h> #include<i...
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
【题解】「HDU1166」敌兵布阵(线段树)
01-20
(1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj不超过303030） (2)Sub(2)Sub(2)Sub iii jjj ，iii和jjj为正整数,表示第iii个营地减少jjj个人（jjj不超过303030）; (3)Query(3)...
ACM hdu 线段树题目+源代码
06-19
线段树的主要应用是解决区间问题，例如区间和、区间最大值、区间最小值等。线段树可以将这些问题的时间复杂度从 O(n) 降低到 O(logn)。 Hdu 2871 Memory Control Hdu 2871 Memory Control 是一个典型的线段树...
hdu4578 线段树 三次方，二次方，一次方的值
weixin_30349597的博客
09-17 198
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 between ax...
线段树详解 （原理，实现与应用）
热门推荐
岩之痕
09-09 14万+
线段树详解 By 岩之痕 一：综述 线段树是一种可以快速进行区间修改和区间查询的数据结构。点修改，区间修改和区间查询的复杂度都是O(log2(n)) 并且，线段树可以维护很多种类的信息。说到线段树就不得不提一下树状数组，树状数组维护的信息必须满足区间减法，因为树状数组只是维护1到X的信息，通过相减来得到区间信息，代码简单而且速度快，占用空间又少于线段树，所以一般情况下可以用树状数组的地方就
Transformation HDU - 4578（线段树多种操作）
仰望蓝天的博客
05-28 217
三个数组分别是lazadd lazmul lazc 记录加数，乘数，和设定的数，lazc1 表示一次方之和lazc2 lazc3 以此类推，其中最要注意的就是乘操作和加操作顺序不同答案是不同的，所以假如设定乘法为先，那么下推函数就要把乘法标记下推放在加法前面，而且更新函数里面，如果在更新乘法的时候碰到此处标记有加法标记存在，先把加数乘了，在更新子树，就可以保证既是顺序不一样答案是一样的，就...
hdu4578线段树维护平方和,立方和(加,乘,赋值)
qq_39707359的博客
11-12 549
#include<bits/stdc++.h> #define ll unsigned long long using namespace std; const ll INFINITE = INT_MAX; const ll MAXNUM = 100005*4; ll mod=10007; struct segNode { ll p1,p2,p3; ll l,r; ...
hdoj 4578 Transformation 【线段树 区间加、乘、修改、幂次求和】
世界很大
01-09 2089
Transformation Time Limit: 15000/8000 MS (Java/Others)    Memory Limit: 65535/65536 K (Java/Others) Total Submission(s): 3869    Accepted Submission(s): 956 Problem Description Yuanfang is
1551：维护序列
叶上初阳_285557的博客
08-17 932
【题目描述】 原题来自：AHOI 2009 老师交给小可可一个维护数列的任务，现在小可可希望你来帮他完成。 有长为 n 的数列，不妨设为 a1,a2,⋯,an 。有如下三种操作形式： 把数列中的一段数全部乘一个值； 把数列中的一段数全部加一个值； 询问数列中的一段数的和，由于答案可能很大，你只需输出这个数模 P 的值。 【输入】 第一行两个整数 n 和 P； 第二行含有 n 个非负整数，从左到右依...
hdu-4578-Transformation-线段树（区间更新区间求和，多lazy,绝世好题）
weixin_30449239的博客
06-01 152
Time limit 8000 msMemory limit 65536 kB Yuanfang is puzzled with the question below: There are n integers, a 1, a 2, …, a n. The ini...
SPOJ GSS4 (区间开根号 + 区间查询) (线段树)
ShadowGhostH的博客
08-14 1106
题目 这个题目camp里面有讲过，用到的是BOZJ 3211 题意 对于给定的，n个数的序列，我们定义两个操作，分别是区间开根号以及区间求和。共有m次查询 其中n,m≤1e5,∑ni=1ai≤1e18n,m≤1e5,∑i=1nai≤1e18n ,\; m\leq 1e5,\; \sum_{i=1}^n a_i \leq1e18 思路 我们可以简单的计算一下，一个1e181e181e...
牛客算法周周练15D - 树上求和（DFS序 + 线段树维护平方和）
在读NLP硕士
07-15 279
题目大意： 输入n q 表示树有 n 个节点和 q 次操作，然后输入n个数，表示 n 个节点的权值，之后输入 n - 1 条边，再输入 q 次操作，1 x y表示给 x 所在的子树权值 + y，2 x 则输出 x所在子树的所有节点的平方和。 解题思路： 树上问题的模板题，遇到树，而且是在子树上进行操作，先跑一遍dfs序将这棵树线性化，因为dfs序跑完以后，子数部分一定是连续的，而且可以求出该节点所在子树的起始时间戳和终止时间戳，然后子树上的问题就转化为对区间进行操作的问题了，维护一个平方和，愉快的使用线段.
线段树详解：区间操作与优化
每个节点有两个子节点，分别代表左子区间和右子区间。在进行区间操作时，线段树通过分治策略将问题分解到各个节点，然后自底向上地合并结果。这使得线段树在常数时间内完成查询和更新操作成为可能。 描述中的编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值