hdu 5306 Gorgeous Sequence

http://www.shuizilong.com/house/archives/hdu-5306-gorgeous-sequence/

这道题目岛神解释的非常到位，我再加上一点自己的感受吧，毕竟这道题目看了这么长的时间~
因为我们知道每个区间对应有多少个节点，那么每次更新操作的时候，我们只需要将sum加上节点数乘这个新值就ok了，但是我们不知道有多少个节点的值要比这个更新的值小，也就是应该抛掉这些点，那么我们就可以加上参量cv，表示这个区间中有多少个节点标记小于待更新的值，然后在我们更新求值之前，我们需要将这个区间中大于待更新的标记都删掉，同时将那些标记的树的sum和max和cv都赋为0，然后我们才可以按照刚刚的思想去进行求值运算~然后在消除标记的过程中，我们利用了max值这个条件进行了合理的减枝（在下放标记的时候我们就把max值都请清为0了），这样就把最终的复杂度降低到了（n*log（n））！！

#include<map>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
#include<bitset>
#include<climits>
#include<list>
#include<iomanip>
#include<stack>
#include<set>
using namespace std;
typedef long long ll;
/************Read**********/  
char *ch, *ch1, buf[40*1024000+5], buf1[40*1024000+5];  

void read(int &x)  
{  
    for (++ch; *ch <= 32; ++ch);  
    for (x = 0; '0' <= *ch; ch++)    x = x * 10 + *ch - '0';  
}  
/**************************/  
struct Tree
{
    int l,r,num,mx,flag;
    //这个结点当前管控num个数，这是用来快速求和用的
    //mx:这个结点的最大值
    //flag:这个结点的修改值 
    ll sum;
    //sum:这个结点的和 
}tree[1000000<<2];
void makeflag(int k,int flag)
{
    if(tree[k].flag!=0&&tree[k].flag<=flag)
        return;
    tree[k].flag=flag;
    tree[k].sum+=ll(tree[k].r-tree[k].l+1-tree[k].num)*flag;
    //num发挥求和的作用，若管控不了这个结点的所有数，则会加上修改值 
    if(tree[k].num<tree[k].r-tree[k].l+1)
        tree[k].mx=flag;
    tree[k].num=tree[k].r-tree[k].l+1;
    //修改完毕后，已经管控了这个结点所有数 
}
void pushdown(int k)//更新k的儿子 
{
    if(tree[k].flag==0)
        return;
    makeflag(k<<1,tree[k].flag);
    makeflag(k<<1|1,tree[k].flag);  
}
void pushup(int k)//用儿子更新k 
{
    tree[k].mx=max(tree[k<<1].mx,tree[k<<1|1].mx);
    tree[k].num=tree[k<<1].num+tree[k<<1|1].num;
    tree[k].sum=tree[k<<1].sum+tree[k<<1|1].sum;
}
void build(int l,int r,int k)
{
    tree[k].l=l;
    tree[k].r=r;
    tree[k].flag=0;
    if(l==r)
    {
        read(tree[k].flag);
        tree[k].num=1;
        tree[k].mx=tree[k].sum=tree[k].flag;
        return;
    }
    int m=l+r>>1;
    build(l,m,k<<1);
    build(m+1,r,k<<1|1);
    pushup(k);
}
void dfs(int k,int flag)
{
    if(tree[k].mx<=flag)
        return;
    if(tree[k].flag>=flag)
        tree[k].flag=0;
    if(tree[k].l==tree[k].r)
    {
        tree[k].mx=tree[k].sum=tree[k].flag;
        tree[k].num=tree[k].flag!=0;
        return;
    }
    pushdown(k);
    dfs(k<<1,flag);
    dfs(k<<1|1,flag);
    pushup(k);
}
void update(int l,int r,int flag,int k)
{
    if(tree[k].mx<=flag)
        return;
    if(l==tree[k].l&&r==tree[k].r)
    {
        dfs(k,flag);//消除这个点子树中大于flag的标记
        makeflag(k,flag);//更新这个结点，求和 
        return;
    }
    int m=tree[k].l+tree[k].r>>1;
    pushdown(k);
    if(r<=m)
        update(l,r,flag,k<<1);
    else if(l>m)
        update(l,r,flag,k<<1|1);
    else
    {
        update(l,m,flag,k<<1);
        update(m+1,r,flag,k<<1|1);
    }
    pushup(k);
}
Tree seek(int l,int r,int k)
{
    if(l==tree[k].l&&r==tree[k].r)
        return tree[k];
    int m=tree[k].l+tree[k].r>>1;
    pushdown(k);
    if(r<=m)
        return seek(l,r,k<<1);
    if(l>m)
        return seek(l,r,k<<1|1);
    Tree t1=seek(l,m,k<<1);
    Tree t2=seek(m+1,r,k<<1|1);
    t1.mx=max(t1.mx,t2.mx);
    t1.sum+=t2.sum;
    return t1;
}
int main()
{
    ch = buf - 1;  
    ch1 = buf1 - 1;  
    fread(buf, 1, 1000 * 35 * 1024, stdin);  
    int T;
    read(T);
    while(T--)
    {
        int n,m;
        read(n);read(m);
        build(1,n,1);
        while(m--)
        {
            int x,l,r;
            read(x);read(l);read(r);
            if(x==0)
            {
                read(x);
                update(l,r,x,1);
            }
            else
            {
                if(x==1)
                    printf("%d\n",seek(l,r,1).mx);
                else
                    printf("%I64d\n",seek(l,r,1).sum);
            }
        }
    }
}

小感悟：这道题刚开始就没有往这个解法上面靠，总是在纠结那个求和的位置，哪知道他是先清0后再往上加，也没有仔细思考下放标记的意义，也没有仔细看初始化等等，要更认真一点~~~