【洛谷5月月赛R2】由乃与大母神原型和偶像崇拜（线段树+hash）

题目描述

给你一个序列a

每次两个操作：

1.修改x位置的值为y

2.查询区间l，r是否可以重排为值域上连续的一段

输入输出格式

输入格式：

第一行两个数n，m

第二行n个数表示a[i]

后面m行每行三个数opt x y，或者opt l r，代表操作

输出格式：

如果可以，输出“damushen”

否则输出“yuanxing”

比较容易想的的就是用线段树维护区间最大值和最小值，若最大值与最小值之差与区间长度不符的就肯定不存在。
我们可以想到最大值与最小值确定之后，这个区间就是一定的，那么它们的和就是一定的，然而这个组合与和并不是一一映射的。
那么如何将数列中的这一组数进行hash呢，我们可以发现对于n个数而言，如果它们不存在相同的数，那么它们的平方和是唯一的（你可以随便脑洞一下就可以证明）。
那么这道题就做完了
线段树维护区间最大值，区间最小值和平方和。再用平方和与从minn到maxx的平方和比较，若相等那么便可以重排为值域上连续的一段。
这道题到这里还没完，因为从minn到maxx的累加和不能直接暴力相加，这样子的复杂度与值域相关，显然是会TLE的
实际上有这么一个公式1^2+2^2+3^2+…+n^2=n$*$(n+1)$*$(2n+1)/6，应该在数学课上讲过如何证明这个公式，这里我就不做证明了。
然而在值域为1e9的时候，累加和很容易超出long long的范围，所以取模，再用乘法逆元随便搞一搞，就AC了。

#include<bits/stdc++.h>
#define fer(i,j,n) for(int i=j;i<=n;i++)
#define far(i,j,n) for(int i=j;i>=n;i--)
#define ll long long
const int maxn=500010;
const int INF=1e9+7;
const int mod=1e9+9;
using namespace std;
/*----------------------------------------------------------------------------*/
inline ll read()
{
    char ls;ll x=0,sng=1;
    for(;ls<'0'||ls>'9';ls=getchar())if(ls=='-')sng=-1;
    for(;ls>='0'&&ls<='9';ls=getchar())x=x*10+ls-'0';
    return x*sng;
}
/*----------------------------------------------------------------------------*/
struct kaga
{
    ll maxx,minn,summ,l,r;
}tr[maxn<<2];
int n,m;
ll inv;
void update(int x)
{
    tr[x].maxx=max(tr[x<<1].maxx,tr[x<<1|1].maxx);
    tr[x].minn=min(tr[x<<1].minn,tr[x<<1|1].minn);
    tr[x].summ=tr[x<<1].summ+tr[x<<1|1].summ;
    tr[x].summ%=mod;
}
void build(int x,int l,int r)
{
    tr[x].l=l;tr[x].r=r;
    if(l==r)
    {
        tr[x].maxx=tr[x].minn=tr[x].summ=read();
        tr[x].summ*=tr[x].summ;
        tr[x].summ%=mod;
        return ;    
    }
    int mid=(l+r)>>1;
    build(x<<1,l,mid);
    build(x<<1|1,mid+1,r);
    update(x);
}
int querymin(int x,int L,int R)
{
    int l=tr[x].l,r=tr[x].r,mid=(l+r)>>1;
    if(l>=L&&r<=R)
        return tr[x].minn;
    if(R<=mid)return querymin(x<<1,L,R);
    else if(L>mid)return querymin(x<<1|1,L,R);
    else return min(querymin(x<<1,L,mid),querymin(x<<1|1,mid+1,R));
}
int querymax(int x,int L,int R)
{
    int l=tr[x].l,r=tr[x].r,mid=(l+r)>>1;
    if(l>=L&&r<=R)
        return tr[x].maxx;
    if(R<=mid)return querymax(x<<1,L,R);
    else if(L>mid)return querymax(x<<1|1,L,R);
    else return max(querymax(x<<1,L,mid),querymax(x<<1|1,mid+1,R));
}
ll querysumm(int x,int L,int R)
{
    int l=tr[x].l,r=tr[x].r,mid=(l+r)>>1;
    if(l>=L&&r<=R)
        return tr[x].summ%mod;
    if(R<=mid)return querysumm(x<<1,L,R);
    else if(L>mid)return querysumm(x<<1|1,L,R);
    else return (querysumm(x<<1,L,mid)+querysumm(x<<1|1,mid+1,R))%mod;
}
void change(int x,int p,int v)
{
    int l=tr[x].l,r=tr[x].r,mid=(l+r)>>1;
    if(l==r){tr[x].maxx=v;tr[x].minn=v;tr[x].summ=v*v%mod;return ;}
    if(p<=mid)change(x<<1,p,v);
    else change(x<<1|1,p,v);
    update(x);
}
ll pw(ll x,ll y)
{
    ll t=1;
    for(;y;y>>=1,x=x*x%mod)
        if(y&1)
            t=t*x%mod;
    return t;
}
ll calc(ll x)
{
    return ((x*(x+1)%mod)*(x*2+1)%mod)%mod*inv%mod;
}
bool work(int L,int R)
{
    ll minn=querymin(1,L,R);
    ll maxx=querymax(1,L,R);
    if((maxx-minn)!=(R-L))return false;
    ll ress=((calc(maxx)-calc(minn-1))%mod+mod)%mod;
    ll summ=querysumm(1,L,R)%mod;
    if(summ==ress)return true;
    else return false;
}
int main()
{
    inv=pw(6,mod-2);
    n=read();m=read();
    build(1,1,n);
    fer(i,1,m)
    {
        int x=read(),y=read(),z=read();
        if(x==1)
        {
            change(1,y,z);    
        }
        else
        {
            if(!work(y,z))printf("yuanxing\n");
            else printf("damushen\n");    
        }
    }
}