CF914D Bash and a Tough Math Puzzle

Bash and a Tough Math Puzzle

写发博客证明自己还活着QwQ

题目描述

Bash likes playing with arrays. He has an array $a_1,a_2,...a_n$ 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 $q$ queries of one of the following forms:

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

Note: The array is $1$ -indexed.

题目大意

给你一个序列，要求支持单点修改，查询一个区间是否满足至多修改一个数使得这个区间的$GCD$为$x$。

Solution

• 很显然的线段树，用线段树维护区间$GCD$，单点修改的问题就解决了。
• 至于查询的时候，因为只要有超过两个数字不满足条件，就可以结束判断了；所以我们选择在线段树上二分，去找不满足条件的数字，如果一个区间的$GCD$不等于$x$，就说明这个区间里有不满足条件的数字，到这个区间里面找就行了，单次复杂度$O(logn)$。
• 总复杂度$O(nlo{g}^{2}n)$

#include<cstdio>

const int maxn = 5e5 + 7;

class SegmentTree{
private :
    struct Node{
        Node *child[2];
        int left, right, val;

        Node (int left = 0, int right = 0) :
            left(left),
            right(right) {
            child[0] = NULL;
            child[1] = NULL;
        }
    };
    Node *root;
    int sum;

    int Gcd(int x, int y) {
        if (!x) {
            return y;
        }
        return Gcd(y % x, x);
    }

    void BuildTree(Node *now, int *a) {
        if (now->left == now->right) {
            now->val = a[now->left];
            return;
        }
        int mid = now->left + now->right >> 1;
        now->child[0] = new Node(now->left, mid);
        now->child[1] = new Node(mid + 1, now->right);
        BuildTree(now->child[0], a), BuildTree(now->child[1], a);
        Update(now);
    }

    void Update(Node *now) {
        now->val = Gcd(now->child[0]->val, now->child[1]->val);
    }

    void Change(Node *now, int pos, int x) {
        if (now->left == now->right) {
            now->val = x;
            return;
        }
        int mid = now->left + now->right >> 1;
        if (pos <= mid) {
            Change(now->child[0], pos, x);
        } else {
            Change(now->child[1], pos, x);
        }
        Update(now);
    }

    void Query(Node *now, int x, int l, int r) {
        if (sum > 1) {
            return;
        }
        if (now->left == now->right) {
            if (now->val % x != 0) {
                sum++;
            }
            return;
        }
        if (now->left >= l && now->right <= r) {
            if (now->val % x != 0) {
                Query(now->child[0], x, l, r);
                Query(now->child[1], x, l, r);
            }
            return;
        }
        int mid = now->left + now->right >> 1;
        if (r <= mid) {
            Query(now->child[0], x, l, r);
        } else if (l > mid) {
            Query(now->child[1], x, l, r);
        } else {
            Query(now->child[0], x, l, r), Query(now->child[1], x, l, r);
        }
    }

public :
    void Init(int n, int *a) {
        root = new Node(1, n);
        BuildTree(root, a);
    }

    void Change(int pos, int x) {
        Change(root, pos, x);
    }

    bool Query(int l, int r, int x) {
        sum = 0;
        Query(root, x, l, r);
        return sum <= 1;
    }
};

class Solution{
private :
    int n, m, a[maxn];
    SegmentTree tree;
    
public :
    Solution() {
        Get();
        Solve();
    }

    void Get() {
        scanf("%d", &n);
        for (register int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
        }
        tree.Init(n, a);
    }

    void Solve() {
        scanf("%d", &m);
        for (register int i = 1; i <= m; i++) {
            int op, l, r, x, y;
            scanf("%d", &op);
            if (op == 1) {
                scanf("%d %d %d", &l, &r, &x);
                if (tree.Query(l, r, x)) {
                    printf("YES\n");
                } else {
                    printf("NO\n");
                }
            } else {
                scanf("%d %d", &x, &y);
                tree.Change(x, y);
            }
        }
    }
};
Solution sol;

int main() {}