CodeForces 914DBash and a Tough Math Puzzle(线段树的骚操作)

D. Bash and a Tough Math Puzzle

time limit per test

2.5 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Bash likes playing with arrays. He has an array a1, a2, ... an of n integers. He likes to guess the greatest common divisor (gcd) of different segments of the array. Of course, sometimes the guess is not correct. However, Bash will be satisfied if his guess is almost correct.

Suppose he guesses that the gcd of the elements in the range [l, r] of a is x. He considers the guess to be almost correct if he can change at most one element in the segment such that the gcd of the segment is x after making the change. Note that when he guesses, he doesn't actually change the array — he just wonders if the gcd of the segment can be made x. Apart from this, he also sometimes makes changes to the array itself.

Since he can't figure it out himself, Bash wants you to tell him which of his guesses are almost correct. Formally, you have to process qqueries of one of the following forms:

• 1 l r x — Bash guesses that the gcd of the range [l, r] is x. Report if this guess is almost correct.
• 2 i y — Bash sets ai to y.

Note: The array is 1-indexed.

Input

The first line contains an integer n (1 ≤ n ≤ 5·105)  — the size of the array.

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109)  — the elements of the array.

The third line contains an integer q (1 ≤ q ≤ 4·105)  — the number of queries.

The next q lines describe the queries and may have one of the following forms:

• 1 l r x (1 ≤ l ≤ r ≤ n, 1 ≤ x ≤ 109).
• 2 i y (1 ≤ i ≤ n, 1 ≤ y ≤ 109).

Guaranteed, that there is at least one query of first type.

Output

For each query of first type, output "YES" (without quotes) if Bash's guess is almost correct and "NO" (without quotes) otherwise.

Examples

input

3
2 6 3
4
1 1 2 2
1 1 3 3
2 1 9
1 1 3 2

output

YES
YES
NO

input

5
1 2 3 4 5
6
1 1 4 2
2 3 6
1 1 4 2
1 1 5 2
2 5 10
1 1 5 2

output

NO
YES
NO
YES

Note

In the first sample, the array initially is {2, 6, 3}.

For query 1, the first two numbers already have their gcd as 2.

For query 2, we can achieve a gcd of 3 by changing the first element of the array to 3. Note that the changes made during queries of type 1are temporary and do not get reflected in the array.

After query 3, the array is now {9, 6, 3}.

For query 4, no matter which element you change, you cannot get the gcd of the range to be 2.

题意：给出一段序列，两个操作

操作1 给出l，r，x

求区间l-r的gcd，如果至多能改掉区间内的一个数，使gcd是x的倍数，那么输出YES，否则输出NO

操作2 给出pos，x

将序列中pos位置上的数字改为x

题解：我一开始看到这道题，没看到可以修改一个数，然后觉得是一道智障线段树，十分钟不到就写完了，结果非常GG地发现被题意杀了，完了，不会做

后面想了一下，对于返回的一个块，如果他的gcd不是x的倍数，那么这个区间肯定是要改数的，如果这样的区间有两个及以上，那么肯定输出NO

但是我们没法保证如果只有一个块的gcd非x的倍数时，这个块一定只用改一个值

再来考虑，每个块肯定会被分成左块和右块，如果左右两块都不是x的倍数就又GG了

如果只有一个块不是x的倍数，那么就按照上面的思路继续二分这个块

直到二分到只剩下一个数字，此时肯定输出yes

然后就搞定啦~其实还是不难的~

代码如下

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define lson root<<1
#define rson root<<1|1
using namespace std;

int gcd(int a,int b)
{
    if(b>a)
    {
        swap(a,b);
    }
    if(b)
    {
        return gcd(b,a%b);
    }
    else
    {
        return a;
    }
}

int nowson,x,cnt,n,m;

struct node
{
    int l,r,g;
}tr[];

void push(int root)
{
    tr[root].g=gcd(tr[rson].g,tr[lson].g);
}

void build(int root,int l,int r)
{
    if(l==r)
    {
        tr[root].l=l;
        tr[root].r=r;
        scanf("%d",&tr[root].g);
        return ;
    }
    int mid=(l+r)>>;
    tr[root].l=l;
    tr[root].r=r;
    build(lson,l,mid);
    build(rson,mid+,r);
    push(root);
}

void update(int root,int pos,int v)
{
    if(tr[root].l==pos&&tr[root].r==pos)
    {
        tr[root].g=v;
        return ;
    }
    int mid=(tr[root].l+tr[root].r)>>;
    if(mid>=pos)
    {
        update(lson,pos,v);
    }
    else
    {
        update(rson,pos,v);
    }
    push(root);
}

int query(int root,int l,int r)
{
    if(tr[root].l==l&&tr[root].r==r)
    {
        if(tr[root].g%x!=)
        {
            cnt--;
            nowson=root;
        }
        return tr[root].g;
    }
    int mid=(tr[root].l+tr[root].r)>>;
    if(l>mid)
    {
        return query(rson,l,r);
    }
    else
    {
        if(r<=mid)
        {
            return query(lson,l,r);
        }
        else
        {
            return gcd(query(lson,l,mid),query(rson,mid+,r));
        }
    }
}

int check(int root)
{
    if(tr[root].l==tr[root].r)
    {
        return ;
    }
    if(tr[lson].g%x!=&&tr[rson].g%x!=)
    {
        return ;
    }
    if(tr[lson].g%x==)
    {
        return check(rson);
    }
    else
    {
        return check(lson);
    }
}

int main()
{
    int n,m;
    scanf("%d",&n);
    build(,,n);
    scanf("%d",&m);
    for(int i=;i<=m;i++)
    {
        int kd,l,r;
        scanf("%d",&kd);
        if(kd==)
        {
            cnt=;
            scanf("%d%d%d",&l,&r,&x);
            int tmp=query(,l,r);
            if(x==tmp)
            {
                puts("YES");
            }
            else
            {
                if((!cnt)&&check(nowson))
                {
                    puts("YES");
                }
                else
                {
                    puts("NO");
                }
            }
        }
        else
        {
            scanf("%d%d",&l,&r);
            update(,l,r);
        }
    }
}