线段树 - Interval GCD(区间最大公约数) - AcWing 246

线段树 - Interval GCD(区间最大公约数) - AcWing 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\le 500000,M\le 100000$

输入样例：

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

---

分析：

$操作1：区间修改。可采用差分数组，用线段树维护，进行单点修改。$

$操作2：求gcd(A[l],A[l+1],...,A[r])。$

$由于操作1我们想利用差分数组，故我们可以将操作2转化为求：gcd(A[l],A[l+1]-A[l],...,A[r]-A[r-1])。$

$即:$$$gcd(A[l],A[l+1],...,A[r])=gcd(A[l],A[l+1]-A[l],...,A[r]-A[r-1])$$

证明：

$假设gcd(A[l],A[l+1],...,A[r])=d，则d|A[i]，i\in [l,r]。$

$因为d|A[i+1]且d|A[i]，所以d|(A[i+1]-A[i])，i\in [l,r-1]。$

$从而容易得到gcd(A[l],A[l+1],...,A[r])=d\le gcd(A[l],A[l+1]-A[l],...,A[r]-A[r-1])。$

$假设gcd(A[l],A[l+1]-A[l],...,A[r]-A[r-1])=d，$

$因为d|(A[l+1]-A[l])且d|A[l]，所以d|[(A[l+1]-A[l])+A[l]]，即d|A[l+1]。$

$以此类推，容易得到d|A[i]，i\in [l,r]。$

$所以gcd(A[l],A[l+1]-A[l],...,A[r]-A[r-1])\le gcd(A[l],A[l+1],...,A[r])$

$从而gcd(A[l],A[l+1],...,A[r])=gcd(A[l],A[l+1]-A[l],...,A[r]-A[r-1])=d。$

$这样，我们就能够利用差分数组进行操作2了。$

具体落实：

$用线段树来维护A的差分数组。$

$对操作1：仅需进行单点修改。$

$对操作2：仅对A[l]需要进行区间求和，再和其他节点值求最大公约数。$

$因此，节点结构体中需要存储区间和和区间最大公约数。$

代码:

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>

#define ll long long

using namespace std;

const int N=5e5+10;

struct node
{
    int l,r;
    ll sum,d;
}tr[N*4];

int n,m;
ll A[N];

ll gcd(ll a,ll b)
{
    return b ? gcd(b,a%b) : a;
}

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)
    {
        ll b=A[l]-A[l-1];
        tr[u]={l,r,b,b};
    }
    else
    {
        tr[u]={l,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,ll v)
{
    if(tr[u].l==x&&tr[u].r==x)  //叶子节点，单点修改
    {
        ll 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);
    }
}

node query(int u,int l,int r)
{
    if(l<=tr[u].l&&tr[u].r<=r) return tr[u];
    
    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
    {
        node left=query(u<<1,l,r);
        node right=query(u<<1|1,l,r);
        node res;
        pushup(res,left,right);
        return res;
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%lld",&A[i]);
    build(1,1,n);
    
    char op[2];
    int l,r;
    ll d;
    while(m--)
    {
        scanf("%s%d%d",op,&l,&r);
        if(*op=='Q')
        {
            node Al=query(1,1,l),Ar=query(1,l+1,r);
            printf("%lld\n",abs(gcd(Al.sum,Ar.d)));
        }
        else
        {
            scanf("%lld",&d);
            modify(1,l,d);
            if(r+1<=n) modify(1,r+1,-d);  //避免越界
        }
    }
}