[BZOJ4373]算术天才⑨与等差数列

思路：

构造等差数列的条件：
1、区间内所有数差分的$gcd=x$
2、区间内$max-min=(r-l)*k$
3、区间内数字不相同
线段树维护最大值，最小值以及差分。
对于每次询问判断上述三种情况，如果满足则说明可以构成等差数列。

需要特判的情况：
1、$k=0$，此时条件3不需要满足
2、$l=r$，此时数列（单个数字）一定能构成等差数列
然而由于数据比较水，所以条件3不判断也没关系。
实测加上条件3判断8936ms，不判断2836ms。
另外有一种hash的做法。
Rank1在hash的基础上还用了zkw线段树，只跑了740ms。

#include<set>
#include<map>
#include<cmath>
#include<cstdio>
#include<cctype>
#include<utility>
#include<algorithm>
inline int getint() {
    char ch;
    while(!isdigit(ch=getchar()));
    int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int N=300001,inf=0x7fffffff;
int a[N]={0};
class SegmentTreeM {
    #define _left <<1
    #define _right <<1|1
    private:
        int max[N<<2],min[N<<2];
        void push_up(const int p) {
            max[p]=std::max(max[p _left],max[p _right]);
            min[p]=std::min(min[p _left],min[p _right]);
        }
    public:
        void build(const int p,const int b,const int e) {
            if(b==e) {
                max[p]=min[p]=a[b];
                return;
            }
            int mid=(b+e)>>1;
            build(p _left,b,mid);
            build(p _right,mid+1,e);
            push_up(p);
        }
        void modify(const int p,const int b,const int e,const int x) {
            if(b==e) {
                max[p]=min[p]=a[x];
                return;
            }
            int mid=(b+e)>>1;
            if(x<=mid) modify(p _left,b,mid,x);
            if(x>mid) modify(p _right,mid+1,e,x);
            push_up(p);
        }
        std::pair<int,int> query(const int p,const int b,const int e,const int l,const int r) {
            if((l==b)&&(e==r)) return std::make_pair(max[p],min[p]);
            int mid=(b+e)>>1;
            std::pair<int,int> ans=std::make_pair(0,inf);
            if(l<=mid) {
                std::pair<int,int> s=query(p _left,b,mid,l,std::min(mid,r));
                ans=std::make_pair(std::max(ans.first,s.first),std::min(ans.second,s.second));
            }
            if(r>mid) {
                std::pair<int,int> s=query(p _right,mid+1,e,std::max(mid+1,l),r);
                ans=std::make_pair(std::max(ans.first,s.first),std::min(ans.second,s.second));
            }
            return ans;
        }
        bool check(const int n,const int l,const int r,const int k) {
            std::pair<int,int> t=query(1,1,n,l,r);
            return t.first-t.second==(r-l)*k;
        }
};
SegmentTreeM m_t;
int d[N]={0};
class SegmentTreeGCD {
    #define _left <<1
    #define _right <<1|1
    private:
        int val[N<<2];
        int gcd(const int x,const int y) {
            if(!x&&!y) return 0;
            return y?gcd(y,x%y):x;
        }
        void push_up(const int p) {
            val[p]=gcd(val[p _left],val[p _right]);
        }
    public:
        void build(const int p,const int b,const int e) {
            if(b==e) {
                val[p]=d[b];
                return;
            }
            int mid=(b+e)>>1;
            build(p _left,b,mid);
            build(p _right,mid+1,e);
            push_up(p);
        }
        void modify(const int p,const int b,const int e,const int x) {
            if(b==e) {
                val[p]=d[x];
                return;
            }
            int mid=(b+e)>>1;
            if(x<=mid) modify(p _left,b,mid,x);
            if(x>mid) modify(p _right,mid+1,e,x);
            push_up(p);
        }
        void modify(const int p,const int b,const int e,const int x,const int y) {
            int mid=(b+e)>>1;
            if(y<=mid) modify(p _left,b,mid,x,y);
            if(x>mid) modify(p _right,mid+1,e,x,y);
            if((x==mid)&&(y==mid+1)) modify(p _left,b,mid,x),modify(p _right,mid+1,e,y);
            push_up(p);
        }
        int query(const int p,const int b,const int e,const int l,const int r) {
            if((l==b)&&(e==r)) return val[p];
            int ans=0;
            int mid=(b+e)>>1;
            if(l<=mid) ans=gcd(ans,query(p _left,b,mid,l,std::min(mid,r)));
            if(r>mid) ans=gcd(ans,query(p _right,mid+1,e,std::max(mid+1,l),r));
            return ans;
        }
        bool check(const int n,const int l,const int r,const int k) {
            return query(1,1,n-1,l,r-1)==k;
        }
};
SegmentTreeGCD gcd_t;
/*class Sets {
    private:
        std::map<int,std::set<int> > pre;
    public:
        void erase(const int x) {
            pre[a[x]].erase(x);
        }
        void insert(const int x) {
            pre[a[x]].insert(x);
        }
        bool check(const int l,const int r) {
            for(int i=l;i<=r;i++) {
                std::set<int>::iterator p=pre[a[i]].find(i);
                if(p==pre[a[i]].end()||p==pre[a[i]].begin()) continue;
                if(*--p>=l) return false;
            }
            return true;
        }
};
Sets s;*/
inline bool check(const int n,const int l,const int r,const int k) {
    if(l==r) return true;
    if(!k) return m_t.check(n,l,r,k)&&gcd_t.check(n,l,r,k);
    return m_t.check(n,l,r,k)&&gcd_t.check(n,l,r,k)/*&&s.check(l,r)*/;
}
int main() {
    int n=getint(),m=getint();
    for(int i=1;i<=n;i++) {
        a[i]=getint();
        if(i>1) d[i-1]=abs(a[i]-a[i-1]);
        //s.insert(i);
    }
    m_t.build(1,1,n);
    gcd_t.build(1,1,n-1);
    int count=0;
    while(m--) {
        int op=getint();
        if(op==1) {
            int x=getint()^count;
            //s.erase(x);
            a[x]=getint()^count;
            //s.insert(x);
            m_t.modify(1,1,n,x);
            if(x!=n) d[x]=abs(a[x+1]-a[x]);
            if(x>1) d[x-1]=abs(a[x]-a[x-1]);
            if(x==n) gcd_t.modify(1,1,n-1,x-1);
            if(x<=1) gcd_t.modify(1,1,n-1,x);
            if((x>1)&&(x!=n)) gcd_t.modify(1,1,n-1,x-1,x);
        }
        if(op==2) {
            int l=getint()^count,r=getint()^count,k=getint()^count;
            if(check(n,l,r,k)) {
                puts("Yes");
                count++;
            }
            else {
                puts("No");
            }
        }
    }
    return 0;
}