hdu 5828 2016 Multi-University Training Contest 8 Rikka with Sequence 解题报告

题意：

一个序列，三种操作，每次将$(l,r)$内的每个$a_i$加$x$，每个$a_i$等于$\sqrt{a_i}$，询问$(l,r)$的和

---

---

---

---

---

题解：

先讲一下官方的题解：

大概是说现将序列差分，然后区间加的话，在$l,r$两个位置单点改一下，求和的时候，

$$a_l+a_{l+1}+...+a_r=(b_1+b_2+...+b_{l-1})*(r-l+1)+b_l*(r-l+1)+b_{l+1}*(r-l)+...+b_r*1$$
然后……..就没有然后了………….差分怎么弄开根操作窝不会……………….会的欢迎留言和我探讨

---

好吧，我的做法：
每个区间维护最大值，最小值，和，区间加标记，和一个根号标记(下传不是两个孩子取根号)
然后，区间加和求和操作，正常操作就行了，主要讲一下开根

因为对于两个数$x,y$，

$$\sqrt{x}-\sqrt{y} ≥ \sqrt{x+c} - \sqrt{y+c} (c≥0)$$

所以，一个区间不断执行开根和加值操作，最大值和最小值的差一定越来越小，时间可以视为$log_2n$级别的（雾）。

所以维护区间的$max,min$，当$max-min ≤ 1$时，区间值去根号后可能等于同一个值，这时候可以整体开根号，如果仍然差1也没关系，因为有和，可以处理出最大最小值的数量，仍然可以更新这个区间，然后更新一下区间加的标记，否则就递归下去

然后根号标记是标记一下这个区间整体取过根号，处理到这里时将最大最小值下传一下

（清空标记，改标记和标记下传的顺序还是要注意一下…）

---

---

code：

#include<set>
#include<map>
#include<deque>
#include<queue>
#include<stack>
#include<cmath>
#include<ctime>
#include<vector>
#include<string>
#include<bitset>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<climits>
#include<complex>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;

const int maxn = 310000;

void read( int &x )
{
    char c;
    while( !((c=getchar())>='0' && c<='9') );
    x = c-'0';
    while( (c=getchar())>='0' && c<='9' )
        (x*=10) += c-'0';
}

struct node
{
    bool fq;
    ll mx,mn,sum,flag;
}tr[maxn<<2];
int a[maxn];
int n,m;

ll sq( ll x )
{
    ll l=1,r=x;
    while( l <= r )
    {
        ll mid = ( l+r )>>1;
        if( mid*mid <= x ) l = mid+1;
        else r = mid-1;
    }
    return l-1;
}
void SQ( int x,int l,int r )
{
    if( tr[x].mx - tr[x].mn <= 1 )
    {
        if( tr[x].mx != tr[x].mn )
        {
            int s1,s2;
            s1 = tr[x].sum-tr[x].mn*(r-l+1);
            s2 = r-l+1-s1;
            ll nmx = sq( tr[x].mx );
            ll nmn = sq( tr[x].mn );
            if( nmx == nmn ) tr[x].fq = true;
            else tr[x].flag += nmx-tr[x].mx;
            tr[x].mx = nmx;
            tr[x].mn = nmn;
            tr[x].sum = tr[x].mx*s1 + tr[x].mn*s2;
        }
        else
        {
            tr[x].mx = tr[x].mn = sq( tr[x].mx );
            tr[x].sum = tr[x].mx*(r-l+1);
            tr[x].fq = true;
        }
        return ;
    }
}
void pushdown( int x,int l,int r )
{
    int mid = (l+r)>>1, lc = x<<1, rc = lc|1;
    if( tr[x].fq == true )
    {
        tr[x].fq = false;
        tr[x].flag = 0;
        tr[lc].flag = tr[rc].flag = 0;
        tr[lc].fq = tr[rc].fq = true;
        tr[lc].mx = tr[rc].mx = tr[x].mx;
        tr[lc].mn = tr[rc].mn = tr[x].mn;
        tr[lc].sum = tr[lc].mx*(mid-l+1);
        tr[rc].sum = tr[rc].mx*(r-mid);
    }
    if( tr[x].flag )
    {
        ll temp = tr[x].flag; tr[x].flag = 0;

        tr[lc].flag += temp;
        tr[lc].mx += temp;  tr[lc].mn += temp;
        tr[lc].sum += temp*(mid-l+1);

        tr[rc].flag += temp;
        tr[rc].mx += temp; tr[rc].mn += temp;
        tr[rc].sum += temp*(r-mid);
    }
}
void build_( int x,int l,int r )
{
    tr[x].flag = 0; tr[x].fq = false;
    if( l == r )
    {
        tr[x].mx = tr[x].mn = tr[x].sum = a[l];
        return ;
    }
    int mid = ( l+r )>>1 ,lc = x<<1, rc = lc|1;
    build_( lc,l,mid ); build_( rc,mid+1,r );
    tr[x].mn = tr[lc].mn < tr[rc].mn ? tr[lc].mn : tr[rc].mn;
    tr[x].mx = tr[lc].mx > tr[rc].mx ? tr[lc].mx : tr[rc].mx;
    tr[x].sum = tr[lc].sum + tr[rc].sum;
}
void tsq( int x,int l,int r )
{
    if( tr[x].mx - tr[x].mn <= 1 )
    {
        SQ( x,l,r );
        return ;
    }
    pushdown( x,l,r );
    int mid = ( l+r )>>1, lc = x<<1, rc = lc|1;
    tsq( lc,l,mid ); tsq( rc,mid+1,r );
    tr[x].mn = tr[lc].mn < tr[rc].mn ? tr[lc].mn : tr[rc].mn;
    tr[x].mx = tr[lc].mx > tr[rc].mx ? tr[lc].mx : tr[rc].mx;
    tr[x].sum = tr[lc].sum + tr[rc].sum;
}
void update( int x,int l,int r,int lx,int rx )
{
    if( lx <= l && r <= rx )
    {
        tsq( x,l,r );
        return ;
    }
    pushdown( x,l,r );
    int mid = ( l+r )>>1, lc = x<<1, rc = lc|1;
    if( rx <= mid ) update( lc,l,mid,lx,rx );
    else if( lx > mid ) update( rc,mid+1,r,lx,rx );
    else 
    {
        update( lc,l,mid,lx,mid );
        update( rc,mid+1,r,mid+1,rx );
    }
    tr[x].mn = tr[lc].mn < tr[rc].mn ? tr[lc].mn : tr[rc].mn;
    tr[x].mx = tr[lc].mx > tr[rc].mx ? tr[lc].mx : tr[rc].mx;
    tr[x].sum = tr[lc].sum + tr[rc].sum;
}
void add( int x,int l,int r,int lx,int rx,ll c )
{
    if( l != r ) pushdown( x,l,r );
    if( lx <= l && r <= rx )
    {
        tr[x].mx += c;
        tr[x].mn += c;
        tr[x].sum += c*(r-l+1);
        tr[x].flag += c;
        return ;
    }
    int mid = ( l+r )>>1, lc = x<<1, rc = lc|1;
    if( rx <= mid ) add( lc,l,mid,lx,rx,c );
    else if( lx > mid ) add( rc,mid+1,r,lx,rx,c );
    else
    {
        add( lc,l,mid,lx,mid,c );
        add( rc,mid+1,r,mid+1,rx,c );
    }
    tr[x].mn = tr[lc].mn < tr[rc].mn ? tr[lc].mn : tr[rc].mn;
    tr[x].mx = tr[lc].mx > tr[rc].mx ? tr[lc].mx : tr[rc].mx;
    tr[x].sum = tr[lc].sum + tr[rc].sum;
}
ll Query( int x,int l,int r,int lx,int rx )
{
    if( lx <= l && r <= rx ) return tr[x].sum;
    if( tr[x].mx == tr[x].mn ) return tr[x].mx*(rx-lx+1);
    pushdown( x,l,r );
    int mid = ( l+r )>>1, lc = x<<1, rc = lc|1;
    if( rx <= mid ) return Query( lc,l,mid,lx,rx );
    else if( lx > mid ) return Query( rc,mid+1,r,lx,rx );
    else return Query( lc,l,mid,lx,mid ) + Query( rc,mid+1,r,mid+1,rx );
}

int main()
{
    int t,x,y;
    ll c;
    read(t);
    while( t-- )
    {
        read( n ); read(m);
        for( int i=1;i<=n;i++ )  read( a[i] );
        build_( 1,1,n );
        while( m-- )
        {
            read(x);
            if( x == 1 )
            {
                read(x); read(y); scanf("%I64d",&c);
                add( 1,1,n,x,y,c );
            }
            else if( x == 2 )
            {
                read(x); read(y);
                update( 1,1,n,x,y );
            }
            else
            {
                read(x); read(y);
                printf("%I64d\n",Query( 1,1,n,x,y ));
            }
        }
    }

    return 0;
}