4927 线段树练习5

时间限制: 1 s

 空间限制: 128000 KB

 题目等级 : 黄金 Gold

题解

 查看运行结果

 

 

题目描述 Description

有n个数和5种操作

add a b c：把区间[a,b]内的所有数都增加c

set a b c：把区间[a,b]内的所有数都设为c

sum a b：查询区间[a,b]的区间和

max a b：查询区间[a,b]的最大值

min a b：查询区间[a,b]的最小值

输入描述 Input Description

第一行两个整数n，m，第二行n个整数表示这n个数的初始值

接下来m行操作，同题目描述

输出描述 Output Description

对于所有的sum、max、min询问，一行输出一个答案

样例输入 Sample Input

10 6

3 9 2 8 1 7 5 0 4 6

add 4 9 4

set 2 6 2

add 3 8 2

sum 2 10

max 1 7

min 3 6

 

样例输出 Sample Output

49

11

4

 

数据范围及提示 Data Size & Hint

10%:1<n,m<=10

30%:1<n,m<=10000

100%:1<n,m<=100000

保证中间结果在long long(C/C++)、int64(pascal)范围内

 

PS:由于数据6出错导致某些人只有90分，已于2016.5.13修正。

出题人在此对两位90分的用户表示诚挚的歉意

 

好恶心的一道题

这道题特殊在set操作

对于这个操作，我们需要增加两个变量来维护，一个维护这个区间是否被修改，一个维护被修改成了多少

特别注意不能只维护被修改成了多少（会有0的情况）

 

在下传标记的时候，需要先下传set标记，再下传add标记

因为我们在设置set标记的时候已经把add标记置为0

如果此时add标记不为0，就说明这个标记一定是在set标记设置之后设置的

 

再注意一下细节就可以了

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#define LL long long 
#define ls k<<1
#define rs k<<1|1
using namespace std;
const LL MAXN=400400;
const LL INF =0x7fffff;
inline void read(LL &n)
{
    char c=getchar();n=0;bool flag=0;
    while(c<'0'||c>'9')    c=='-'?flag=1,c=getchar():c=getchar();
    while(c>='0'&&c<='9')    n=n*10+c-48,c=getchar();flag==1?n=-n:n=n;
}
struct node
{
    LL l,r,w,Max,Min,Set,Add;
    bool V;
}tree[MAXN];
LL n,m;
LL ans=0;
inline void update(LL k)
{
    tree[k].w=tree[ls].w+tree[rs].w;
    tree[k].Max=max(tree[ls].Max,tree[rs].Max);
    tree[k].Min=min(tree[ls].Min,tree[rs].Min);
}
void Build_Tree(LL ll,LL rr,LL k)
{
    tree[k].l=ll;tree[k].r=rr;
    if(tree[k].l==tree[k].r)
    {
        read(tree[k].w);
        tree[k].Max=tree[k].w;
        tree[k].Min=tree[k].w;
        return ;
    }
    LL mid=tree[k].l+tree[k].r>>1;
    Build_Tree(ll,mid,ls);
    Build_Tree(mid+1,rr,rs);
    update(k);
}
void down(LL k)
{
    if(tree[k].V)
    {
        tree[ls].Add=0;
        tree[ls].V=1;
        tree[ls].w=(tree[ls].r-tree[ls].l+1)*tree[k].Set;
        tree[ls].Max=tree[ls].Min=tree[ls].Set=tree[k].Set;
        
        tree[rs].Add=0;
        tree[rs].V=1;
        tree[rs].w=(tree[rs].r-tree[rs].l+1)*tree[k].Set;
        tree[rs].Max=tree[rs].Min=tree[rs].Set=tree[k].Set;
        
        tree[k].Set=tree[k].V=0;
    }
    if(tree[k].Add)
    {
        tree[ls].w+=(tree[ls].r-tree[ls].l+1)*tree[k].Add;
        tree[ls].Add+=tree[k].Add;
        tree[ls].Max+=tree[k].Add;
        tree[ls].Min+=tree[k].Add;
        
        tree[rs].w+=(tree[rs].r-tree[rs].l+1)*tree[k].Add;
        tree[rs].Add+=tree[k].Add;
        tree[rs].Max+=tree[k].Add;
        tree[rs].Min+=tree[k].Add;
        tree[k].Add=0;    
    }
    
}
void Interval_Add(LL k,LL ll,LL rr,LL val)
{
    if(ll<=tree[k].l&&tree[k].r<=rr)
    {
        tree[k].w+=(tree[k].r-tree[k].l+1)*val;
        tree[k].Add+=val;
        tree[k].Max+=val;
        tree[k].Min+=val;
        return ;
    }
    if(tree[k].Add||tree[k].V)    down(k);
    LL mid=tree[k].r+tree[k].l>>1;
    if(ll<=mid)    Interval_Add(ls,ll,rr,val);
    if(rr>mid)    Interval_Add(rs,ll,rr,val);
    update(k);
}
void Interval_Change(LL k,LL ll,LL rr,LL val)
{
    if(ll<=tree[k].l&&tree[k].r<=rr)
    {
        tree[k].Max=tree[k].Min=val;
        tree[k].Set=val;tree[k].V=1;
        tree[k].w=(tree[k].r-tree[k].l+1)*val;
        tree[k].Add=0;
        return ;
    }
    if(tree[k].Add||tree[k].V)    down(k);
    LL mid=tree[k].r+tree[k].l>>1;
    if(ll<=mid)    Interval_Change(ls,ll,rr,val);
    if(rr>mid)    Interval_Change(rs,ll,rr,val);
    update(k);
}
void Interval_Sum(LL k,LL ll,LL rr)
{
    if(ll<=tree[k].l&&tree[k].r<=rr)
    {
        ans+=tree[k].w;
        return ;
    }
    if(tree[k].Add||tree[k].V)    down(k);
    LL mid=tree[k].r+tree[k].l>>1;
    if(ll<=mid)    Interval_Sum(ls,ll,rr);
    if(rr>mid)    Interval_Sum(rs,ll,rr);
}
void Interval_Max(LL k,LL ll,LL rr)
{
    if(ll<=tree[k].l&&tree[k].r<=rr)
    {
        ans=max(ans,tree[k].Max);
        return ;
    }
    if(tree[k].Add||tree[k].V)    down(k);
    LL mid=tree[k].r+tree[k].l>>1;
    if(ll<=mid)    Interval_Max(ls,ll,rr);
    if(rr>mid)    Interval_Max(rs,ll,rr);
}
void Interval_Min(LL k,LL ll,LL rr)
{
    if(ll<=tree[k].l&&tree[k].r<=rr)
    {
        ans=min(ans,tree[k].Min);
        return ;
    }
    if(tree[k].Add||tree[k].V)    down(k);
    LL mid=tree[k].r+tree[k].l>>1;
    if(ll<=mid)    Interval_Min(ls,ll,rr);
    if(rr>mid)    Interval_Min(rs,ll,rr);
}
int main()
{
    read(n);read(m);
    Build_Tree(1,n,1);
    for(LL i=1;i<=m;i++)
    {
        char how[5];
        scanf("%s",how);
        if(how[0]=='a')//区间加 
        {
            LL x,y,val;read(x);read(y);read(val);
            Interval_Add(1,x,y,val);
        }
        else if(how[0]=='s'&&how[1]=='e')//区间赋值 
        {
            LL x,y,val;read(x);read(y);read(val);
            Interval_Change(1,x,y,val);
        }
        else if(how[0]=='s'&&how[1]=='u')//区间求和 
        {
            LL x,y;read(x);read(y);ans=0;
            Interval_Sum(1,x,y);
            printf("%lld\n",ans);
        }
        else if(how[0]=='m'&&how[1]=='a')//区间最大值 
        {
            LL x,y;read(x);read(y);ans=0;
            Interval_Max(1,x,y);
            printf("%lld\n",ans);
        }
        else if(how[0]=='m'&&how[1]=='i')// 区间最小值 
        {
            LL x,y;read(x);read(y);ans=INF;
            Interval_Min(1,x,y);
            printf("%lld\n",ans);
        } 
    }
    return 0;
}