BZOJ 4373: 算术天才⑨与等差数列

最新推荐文章于 2022-02-27 21:41:52 发布

ypxrain

最新推荐文章于 2022-02-27 21:41:52 发布

阅读量315

点赞数

分类专栏：线段树平衡树 STL hash

本文链接：https://blog.csdn.net/ypxrain/article/details/70746838

版权

线段树同时被 3 个专栏收录

19 篇文章 0 订阅

订阅专栏

平衡树

7 篇文章 0 订阅

订阅专栏

hash

4 篇文章 0 订阅

订阅专栏

Description

算术天才⑨非常喜欢和等差数列玩耍。
有一天，他给了你一个长度为n的序列，其中第i个数为a[i]。
他想考考你，每次他会给出询问l,r,k，问区间[l,r]内的数从小到大排序后能否形成公差为k的等差数列。
当然，他还会不断修改其中的某一项。
为了不被他鄙视，你必须要快速并正确地回答完所有问题。
注意：只有一个数的数列也是等差数列。

Input

第一行包含两个正整数n,m(1<=n,m<=300000)，分别表示序列的长度和操作的次数。
第二行包含n个整数，依次表示序列中的每个数ai。
接下来m行，每行一开始为一个数op，
若op=1，则接下来两个整数x,y(1<=x<=n，0<=y<=10^9)，表示把a[x]修改为y。
若op=2，则接下来三个整数l,r,k(1<=l<=r<=n，0<=k<=10^9)，表示一个询问。
在本题中，x,y,l,r,k都是经过加密的，都需要异或你之前输出的Yes的个数来进行解密。

Output

输出若干行，对于每个询问，如果可以形成等差数列，那么输出Yes，否则输出No。

Sample Input

5 3

1 3 2 5 6

2 1 5 1

1 5 4

2 1 5 1

Sample Output

Yes

分析

我们先考虑正解考虑如何约束等差数列这个条件，如果k=0，就是[最大值=最小值]；否则就是区间中[相邻两数差的绝对值的gcd=k][(最大值-最小值)/(r-l)=k][区间中没有相同元素]。

gcd可以用线段树求，这个东西看起来是 $O(log^2n)$ 的，但是其实是 $O(logn)$ 的，因为考虑一次修改，从下往上gcd必然是不增的，而且考虑欧几里得算法求gcd的时候，每一次运算必然会至少除2，所以一次修改的 $O(logn)$ 次欧几里得算法是均摊 $O(logA)$ (A是权值最大值）的。

所以问题就在于怎么确定区间中没有相同元素。

显然，如果记每个位置下一个和它权值相同的位置在哪，那就转化成了求区间最小值的问题。而这个玩意儿其实就是求后继。显然可以用set乱玩。

好吧其实我们还可以用水解，我们首先考虑构造一个满足条件的等差数列，显然这就是子序列问题，考虑哈希，我们不难发现直接求和是不行的//所以我们考虑平方和的形式，对于每一个等差数列，我们设首项为 $a[1]$ ，末项为 $a[n]$ ，项数为 $n$ ，公差为 $k$ 的话，我们设它的hash值为：

n * a [1] * a [n] + n ( n - 1 ) ( 2 n - 2 ) k 2 6

$n*a[1]*a[n]+ \frac {n(n-1)(2n-2)k^2}{6}$

然后就很神奇的水过了//

代码

正解：

#include <bits/stdc++.h>

#define id it->second

using namespace std;

const int maxn=300005,maxt=1048578,maxm=600005;

typedef long long LL;

int n,m,cnt,Min[maxt],Max[maxt],a[maxn],Max_pre[maxt],pre[maxn],next[maxn],Gcd[maxt],tot,l,r;

int mininum,maxinum,G;

bool flag;

char c;

map <int,int> num;

set <int> tree[maxm];

int read()
{
    for (c=getchar();c<'0' || c>'9';c=getchar());
    int x=c-48;
    for (c=getchar();c>='0' && c<='9';c=getchar()) x=x*10+c-48;
    return x;
}

int gcd(int x,int y)
{
    if (x==0) return y;
    if (y==0) return x;
    return gcd(y,x%y);
}

void init(int l,int r,int x)
{
    if (l==r)
    {
        Min[x]=Max[x]=a[l]; Max_pre[x]=pre[l];
        if (l<n) Gcd[x]=abs(a[l]-a[l+1]);else Gcd[x]=1;
        return;
    }
    int mid=l+r>>1;
    init(l,mid,x<<1); init(mid+1,r,x<<1|1);
    Min[x]=min(Min[x<<1],Min[x<<1|1]);
    Max[x]=max(Max[x<<1],Max[x<<1|1]);
    Max_pre[x]=max(Max_pre[x<<1],Max_pre[x<<1|1]);
    Gcd[x]=gcd(Gcd[x<<1],Gcd[x<<1|1]);
}

void change_pre(int l,int r,int g,int New,int x)
{
    if (l==r)
    {
        Max_pre[x]=pre[l]=New;
        return;
    }
    int mid=l+r>>1;
    if (g<=mid) change_pre(l,mid,g,New,x<<1);else change_pre(mid+1,r,g,New,x<<1|1);
    Max_pre[x]=max(Max_pre[x<<1],Max_pre[x<<1|1]);
}

void change_a(int l,int r,int g,int x)
{
    if (l==r)
    {
        Min[x]=Max[x]=a[l];
        return;
    }
    int mid=l+r>>1;
    if (g<=mid) change_a(l,mid,g,x<<1);else change_a(mid+1,r,g,x<<1|1);
    Min[x]=min(Min[x<<1],Min[x<<1|1]);
    Max[x]=max(Max[x<<1],Max[x<<1|1]);
    Max_pre[x]=max(Max_pre[x<<1],Max_pre[x<<1|1]);
}

void change_gcd(int l,int r,int g,int x)
{
    if (l==r)
    {
        Gcd[x]=abs(a[l]-a[l+1]);
        return;
    }
    int mid=l+r>>1;
    if (g<=mid) change_gcd(l,mid,g,x<<1);else change_gcd(mid+1,r,g,x<<1|1);
    Gcd[x]=gcd(Gcd[x<<1],Gcd[x<<1|1]);
}

void query(int l,int r,int a,int b,int x)
{
    if (l==a && r==b)
    {
        if (Max_pre[x]>=l) flag=1;
        if (Min[x]<mininum) mininum=Min[x];
        if (Max[x]>maxinum) maxinum=Max[x];
        return;
    }
    int mid=l+r>>1;
    if (b<=mid) query(l,mid,a,b,x<<1);
    else if (a>mid) query(mid+1,r,a,b,x<<1|1);
    else
    {
        query(l,mid,a,mid,x<<1); query(mid+1,r,mid+1,b,x<<1|1);
    }
}

void query_gcd(int l,int r,int a,int b,int x)
{
    if (l==a && r==b)
    {
        G=gcd(G,Gcd[x]);
        return;
    }
    int mid=l+r>>1;
    if (b<=mid) query_gcd(l,mid,a,b,x<<1);else
    if (a>mid) query_gcd(mid+1,r,a,b,x<<1|1);else
    {
        query_gcd(l,mid,a,mid,x<<1); query_gcd(mid+1,r,mid+1,b,x<<1|1);
    }
}

int main()
{
    n=read(); m=read();
    for (int i=1;i<=n;i++)
    {
        a[i]=read();
        map <int,int> ::iterator it=num.find(a[i]);
        if (it==num.end())
        {
            num.insert(make_pair(a[i],++tot));
            tree[tot].insert(i);
            pre[i]=0;
        }else
        {
            tree[id].insert(i);
            set <int> ::iterator ii=tree[id].find(i); ii--;
            pre[i]=*ii; next[*ii]=i;
        }
    }
    init(1,n,1);
    while (m--)
    {
        int op=read();
        if (op==1)
        {
            int x=read()^cnt,y=read()^cnt;
            if (a[x]==y) continue;
            map <int,int> ::iterator it=num.find(a[x]);
            set <int> ::iterator ii=tree[id].find(x);
            if (pre[x]>0)
            {
                next[pre[x]]=next[x];
                if (next[x]>0) change_pre(1,n,next[x],pre[x],1);
            }else if (next[x]>0) change_pre(1,n,next[x],0,1);
            tree[id].erase(ii);
            it=num.find(y);
            if (it==num.end())
            {
                num.insert(make_pair(y,++tot));
                tree[tot].insert(x);
                pre[x]=next[x]=0;
            }else
            {
                tree[id].insert(x);
                ii=tree[id].find(x);
                if (ii!=tree[id].begin())
                {
                    ii--;
                    next[x]=next[*ii];
                    if (next[x]>0) change_pre(1,n,next[x],x,1);
                    next[*ii]=x;
                    pre[x]=*ii;
                }
            }
            a[x]=y;
            change_a(1,n,x,1);
            if (x>1) change_gcd(1,n,x-1,1);
            if (x<n) change_gcd(1,n,x,1);
        }else
        {
            l=read()^cnt; r=read()^cnt; int k=read()^cnt;
            if (l==r)
            {
                printf("Yes\n"); cnt++; continue;
            }
            mininum=(int)1e9; maxinum=flag=0;
            query(1,n,l,r,1);
            if (!k)
            {
                if (mininum==maxinum)
                {
                    printf("Yes\n"); cnt++;
                }else printf("No\n");
                continue;
            }
            G=k;
            query_gcd(1,n,l,r-1,1);
            if (flag || mininum+(LL)k*(r-l)!=maxinum || G<k)
            {
                printf("No\n");
            }else
            {
                printf("Yes\n"); cnt++;
            }
        }
    }
    return 0;
}

水解

#include <bits/stdc++.h>

using namespace std;  
typedef long long LL;  
typedef pair<int, int>PII;  

const int MX = 3e5 + 5;  
const int mod = 1e9 + 9;  
const int INF = 0x3f3f3f3f;  
#define lson l,m,rt<<1  
#define rson m+1,r,rt<<1|1  

LL A[MX], inv;  
LL s1[MX << 2], s2[MX << 2], MIN[MX << 2];  

LL power(LL a, LL b) 
{  
    LL ret = 1;  
    while(b) 
    {  
        if(b & 1) ret = ret * a % mod;  
        a = a * a % mod;  
        b >>= 1;  
    }  
    return ret;  
}  

void push_up(int rt) 
{  
    s1[rt] = s1[rt << 1] + s1[rt << 1 | 1];  
    s2[rt] = (s2[rt << 1] + s2[rt << 1 | 1]) % mod;  
    MIN[rt] = min(MIN[rt << 1], MIN[rt << 1 | 1]);  
}

void build(int l, int r, int rt) 
{  
    if(l == r) 
    {  
        s1[rt] = MIN[rt] = A[l];  
        s2[rt] = A[l] * A[l] % mod;  
        return;  
    }  

    int m = (l + r) >> 1;  
    build(lson); build(rson);  
    push_up(rt);  
}  

LL query(int id, int L, int R, int l, int r, int rt) 
{  
    if(L <= l && r <= R) 
    {  
        if(id == 1) return s1[rt];  
        if(id == 2) return s2[rt];  
    }  
    int m = (l + r) >> 1; LL ret = 0;  
    if(L <= m) ret += query(id, L, R, lson);  
    if(R > m) ret += query(id, L, R, rson);  
    if(id == 2) ret %= mod;  
    return ret;  
}  

void update(int pos, LL val, int l, int r, int rt) 
{  
    if(l == r) 
    {  
        s1[rt] = MIN[rt] = val;  
        s2[rt] = val * val % mod;  
        return;  
    }  
    int m = (l + r) >> 1;  
    if(pos <= m) update(pos, val, lson);  
    else update(pos, val, rson);  
    push_up(rt);  
}  

LL query_min(int L, int R, int l, int r, int rt) 
{  
    if(L <= l && r <= R) 
    {  
        return MIN[rt];  
    }  
    int m = (l + r) >> 1; LL ret = INF;  
    if(L <= m) ret = min(ret, query_min(L, R, lson));  
    if(R > m) ret = min(ret, query_min(L, R, rson));  
    return ret;  
}  

LL gets1(LL a, LL l, LL k) 
{  
    return a * l + (l - 1) * l / 2 * k;  
}

LL gets2(LL a, LL l, LL k) 
{  
    LL ret = a * a % mod * l % mod;  
    ret = (ret + (l - 1) * l % mod * k % mod * a % mod) % mod;  
    ret += l * (l - 1) % mod * (2 * l - 1) % mod * k % mod * k % mod * inv % mod;  
    return ret % mod;  
}  

int main() 
{  
    int n, m;   
    while(~scanf("%d%d", &n, &m)) 
    {  
        inv = power(6, mod - 2);  
        for(int i = 1; i <= n; i++) 
        {  
            scanf("%lld", &A[i]);  
        }  
        build(1, n, 1);  

        int cnt = 0;  
        for(int i = 1; i <= m; i++) 
        {  
            int op, a, b, c;  
            scanf("%d%d%d", &op, &a, &b);  
            a ^= cnt; b ^= cnt;  
            if(op == 1) update(a, b, 1, n, 1);  
            else 
            {  
                bool sign = true;  
                scanf("%d", &c); c ^= cnt;  
                int Min = query_min(a, b, 1, n, 1);  
                LL s = gets1(Min, b - a + 1, c);  
                if(s != query(1, a, b, 1, n, 1)) sign = false;  
                if(sign && gets2(Min, b - a + 1, c) != query(2, a, b, 1, n, 1)) sign = false;  
                if(sign) cnt++, printf("Yes\n");  
                else printf("No\n");  
            }  
        }  
    }  
    return 0;  
}

ypxrain

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
BZOJ 4373: 算术天才⑨与等差数列

Description算术天才⑨非常喜欢和等差数列玩耍。有一天，他给了你一个长度为n的序列，其中第i个数为a[i]。他想考考你，每次他会给出询问l,r,k，问区间[l,r]内的数从小到大排序后能否形成公差为k的等差数列。当然，他还会不断修改其中的某一项。为了不被他鄙视，你必须要快速并正确地回答完所有问题。注意：只有一个数的数列也是等差数列。Input第一行包含两个正整数n,m(1
复制链接

扫一扫