[+ 트리 라인 번호 이론 + 펜윅 트리] 간격 간격 GCD 최대 공약수를 찾는

간격 최대 공약수

원래의 질문에 링크 : 간격 최대 공약수

효과에 따라

그리고 영업 부문의 나무가 거의 당신에게 리터를 제공, R은 D를 추가 할 수 있도록, 또는 당신에게 최대 공약수의 L, R의 부탁

문제에 대한 주제 솔루션

절대로, 초등 번호 이론은 많은 고통을 배운 적이 표준을 추가해야합니다 복근 후, 아침 썼다 ::

따르면 우리가 아는 예술, 감소 \ (GCD (X 축의 y 축) = GCD (X 축의 y-- X 축)을 \) 다음 케이스의 세 번째 확장 할 수 있습니다 \ (GCD (X, Y, (Z) = GCD를 X, YX, ZY) \) 이 사실이다

우리는 길이 구축 할 수 있기 때문에 (\ N-) \를 열 B의 새로운 번호를, B는이 시퀀스에서의 차이이다. 유지 최대 공약수 시퀀스 세그먼트 트리 B 구간 (이상 동일한 결론)

그 결과, 우리가 직접 질의 (L + 1, R), (1 요청하는 [1]) GCD 해결 (왜 생각해? 상기 유도 식 봐)

, 다음은 B의 단일 지점 보존 할 필요에 수정 분명하다 수정, 당신은 값의 나무와 같은 배열을 유지할 수 있습니다

다음 코드는

//#define fre yes

#include <cmath>
#include <cstdio>
#include <iostream>
#define int long long

const int N = 500005;
struct Node {
    int l, r;
    long long ans;
} tree[N << 2];
int a[N], b[N], c[N];

long long cnt;

long long gcd(long long x, long long y) {
    return y ? gcd(y, x % y) : x;
}

namespace SegmentTree {
    inline void build(int rt, int l, int r) {
        tree[rt].l = l, tree[rt].r = r;
        if(l == r) {
            tree[rt].ans = b[l];
            return ;
        }
        
        int mid = (l + r) >> 1;
        build(rt * 2, l, mid);
        build(rt * 2 + 1, mid + 1, r);
        tree[rt].ans = gcd(tree[rt * 2].ans, tree[rt * 2 + 1].ans);
    }
    
    inline void change_point(int rt, int x, int k) {
        if(tree[rt].l == tree[rt].r) {
            tree[rt].ans += k;
            return ;
        }
        
        int mid = (tree[rt].l + tree[rt].r) >> 1;
        if(mid >= x) change_point(rt * 2, x, k);
        else change_point(rt * 2 + 1, x, k);
        tree[rt].ans = gcd(tree[rt * 2].ans, tree[rt * 2 + 1].ans);
    }
    
    inline void ask(int rt, int l, int r) {
        if(tree[rt].l >= l && tree[rt].r <= r) {
            cnt = gcd(cnt, tree[rt].ans);
            return ;
        }
        
        int mid = (tree[rt].l + tree[rt].r) >> 1;
        if(l <= mid) ask(rt * 2, l, r);
        if(r > mid) ask(rt * 2 + 1, l, r);
    }
}

int n;
namespace BIT {
    int lowbit(int x) {
        return x & (-x);
    }
    
    inline void add(int x, int k) {
        while(x <= n) {
            c[x] += k;
            x += lowbit(x);
        }
    }
    
    int ask(int x) {
        long long res = 0;
        while(x) {
            res += c[x];
            x -= lowbit(x);
        } return res;
    }
}

signed main() {
    static int m;
    scanf("%lld %lld", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
        b[i] = a[i] - a[i - 1];
    } SegmentTree::build(1, 1, n);
    
    char c[3];
    for (int i = 1; i <= m; i++) {
        scanf("%s", c + 1);
        if(c[1] == 'C') {
            int l, r, d;
            scanf("%lld %lld %lld", &l, &r, &d);
            SegmentTree::change_point(1, l, d);
            BIT::add(l, d);
            if(r + 1 <= n) {
                SegmentTree::change_point(1, r + 1, -d);
                BIT::add(r + 1, -d);
            }
        } else {
            cnt = 0; int l, r;
            scanf("%lld %lld", &l, &r);
            SegmentTree::ask(1, l + 1, r);
            printf("%lld\n", gcd(a[l] + BIT::ask(l), std::abs(cnt)));
        }
    } return 0;
}