246. 区间最大公约数

给定一个长度为 N 的数列 A，以及 M 条指令，每条指令可能是以下两种之一：

1. C l r d，表示把 A[l],A[l+1],…,A[r]都加上 d。
2. Q l r，表示询问 A[l],A[l+1],…,A[r] 的最大公约数(GCD)。

对于每个询问，输出一个整数表示答案。

输入格式

第一行两个整数 N,M。

第二行 N个整数 A[i]。

接下来 M 行表示 M 条指令，每条指令的格式如题目描述所示。

输出格式

对于每个询问，输出一个整数表示答案。

每个答案占一行。

数据范围

N≤500000,M≤100000,
1≤A[i]≤1018,
|d|≤1018,
保证数据在计算过程中不会超过 long long 范围。

输入样例：

5 5
1 3 5 7 9
Q 1 5
C 1 5 1
Q 1 5
C 3 3 6
Q 2 4

输出样例：

1
2
4

代码：

/*
区间修改 区间查询
我们把区间修改和单点查询经过差分转化，让它变成单点修改和区间查询。
这里我们需要知道gcd{a,b}=gcd{a,a−b}，变化一下这个柿子，发现gcd{a,b,c}就是gcd{gcd{a,b},gcd{b,c}}
，也就是gcd{a,b−a,c−a}。相信细心的同学们已经发现，一下规律：gcd{a1,a2,…,an}=gcd{a1,a2−a1,…,an−an−1}
要注意，代码中第i个数的d是指ai−ai−1，所以当我们查询[l,r]的区间最大公约数时，我们要用[l+1,r]的gcd和al求最大公约数。
*/
#include<bits/stdc++.h>
using namespace std;

#define x first
#define y second
#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(false); cin.tie(0);cout.tie(0);
typedef unsigned long long ull;
typedef pair<int, int> PII;

int lowbit(int x) { return x & (- x); }
int  gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
const int mod = 1e9 + 7;
const int N = 500010;

int n, m;
int w[N];
struct Node
{
    int l, r;
    int sum, d;
} tr[N * 4];

void pushup(Node& u, Node& l, Node& r)
{
    u.sum = l.sum + r.sum;
    u.d = gcd(l.d, r.d);
}

void pushup(int u)
{
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

void build(int u, int l, int r)
{
    if (l == r)
    {
        int b = w[r] - w[r - 1];
        tr[u] = {l, r, b, b};
    }
    else
    {
        tr[u].l = l, tr[u].r = r;
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int x, int v)
{
    if (tr[u].l == x && tr[u].r == x)
    {
        int b = tr[u].sum + v;
        tr[u] = {x, x, b, b};
    }
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;

        if ( x <= mid)modify(u << 1, x, v);
        else modify(u << 1 | 1, x, v);

        pushup(u);
    }
}


/*
query是分四种情况还是分两种情况应该是根据query的返回类型来判断的，一般返回一个sum值的时候就只用分两种情况加起来就可以了，返回值是一个Node对象的时候就需要分四种情况了。

具体区别应该在于当整个lr区间在mid的左边或者mid的右边的时候，如果返回值只是一个sum值，那么把左边或者右边的值加到res里面去，这时如果lr被mid分开，那么左右的值也是同样的加到res里面去，所以返回值是sum的时候，只用判断左右有没有区间，有就加上就可以了。

但是当返回值是Node的时候，当lr区间在mid两侧的时候，就应该直接返回一个query函数，而当lr区间在mid两边时就需要返回pushup(query(左区间）,query(右区间)），所以需要分四种情况来递归。
*/

Node query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r)
        return tr[u];
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;

        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else
        {
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            Node res;
            pushup(res, left, right);
            return res;
        }
    }
}


signed main()
{
    IOS;
    cin >> n >> m;

    for (int i = 1 ; i <= n ; i++)
        cin >> w[i];

    build(1, 1, n);
    int l , r;
    int d;
    char op[2];

    while (m--)
    {
        cin >> op >> l >> r;

        if (op[0] == 'Q')
        {
            auto left = query(1, 1, l);
            Node right({0, 0, 0, 0});

            if ( l + 1 <= r)
                right = query(1, l + 1, r);

            cout <<  abs(gcd(left.sum, right.d)) << endl;
        }
        else
        {
            cin >> d;
            modify(1, l, d);

            if ( r + 1 <= n)
                modify(1, r + 1, -d);
        }
    }

    return 0;
}