洛谷 2023 [AHOI2009]维护序列

洛谷 2023 [AHOI2009]维护序列

洛谷原题传送门

这个题也是一道经典的线段树模版（其实洛谷的模版二改一下输入顺序就能AC），其中包括区间乘法修改、区间加法修改、区间查询三个操作。

　线段树的基本操作就不再赘述了，建树，查询，修改，都比较简单，我们可以为两种操作的懒惰标记申请两个变量来记录，这道题的主要难点是down操作和两种修改的优先级问题。

　这两个问题其实就是一回事：首先当我们下推标记时，如果该点加法标记不为0且乘法标记不为1（乘法标记初始化为1），那我们应该先推哪个标记呢？

　实际上我们应该先推位置靠前（也就是比较早输入）的运算，可是运用懒惰标记后，我们是难以判断那个运算输入的更早。

　有一种解决方法就是在每次乘法修改时，将对应位置的加法懒惰标记乘以修改值。这样我们保证了每次下推标记时必然是乘法优先。

if(tree[u].l>=x&&tree[u].r<=y)
    {
        tree[u].w*=c;
        tree[u].w%=mod;
        tree[u].mu=(tree[u].mu*c)%mod;
        tree[u].ad=(tree[u].ad*c)%mod;
        return;
    }

这里的模运算的性质：

((a*b) % p * c)% p = (a * (b*c) % p) % p

(a * b) % p = (b * a) % p

我们可以随时对程序里的标记和值做模运算。

而下推标记时，我们只要保证乘法优先，就可以轻松打出代码：

void down(int u)
{
    tree[u<<].w=(tree[u<<].w*tree[u].mu%mod+tree[u].ad*(tree[u<<].r-tree[u<<].l+)%mod)%mod;
    tree[u<<|].w=(tree[u<<|].w*tree[u].mu%mod+tree[u].ad*(tree[u<<|].r-tree[u<<|].l+)%mod)%mod;
    tree[u<<].mu=tree[u].mu*tree[u<<].mu%mod;
    tree[u<<|].mu=tree[u].mu*tree[u<<|].mu%mod;
    tree[u<<].ad=(tree[u].ad+tree[u<<].ad*tree[u].mu)%mod;   //下推时加法标记也要做乘法运算
    tree[u<<|].ad=(tree[u].ad+tree[u<<|].ad*tree[u].mu)%mod;
    tree[u].ad=;   //清空标记
    tree[u].mu=;
}

下附完整AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=;
typedef long long ll;

struct segtree{
    int l;
    int r;
    ll w;
    ll ad;
    ll mu;
}tree[MAXN<<];

int n,m,q,x,y;

ll mod,c,ans;

ll read()
{
    ll x=;
    int k=;
    char c=getchar();
    while(c>''||c<'')
    {
        if(c=='-') k=-;
        c=getchar();
    }
    while(c<=''&&c>='')
        x=x*+c-'',
        c=getchar();
    return k*x;
}

void build(int u,int l,int r)
{
    tree[u].l=l;
    tree[u].r=r;
    tree[u].ad=;
    tree[u].mu=;
    if(l==r)
    {
        tree[u].w=read()%mod;
        return;
    }
    int mid=(l+r)>>;
    build(u<<,l,mid);
    build(u<<|,mid+,r);
    tree[u].w=(tree[u<<].w+tree[u<<|].w)%mod;
    return;
}

void down(int u)
{
    tree[u<<].w=(tree[u<<].w*tree[u].mu%mod+tree[u].ad*(tree[u<<].r-tree[u<<].l+)%mod)%mod;
    tree[u<<|].w=(tree[u<<|].w*tree[u].mu%mod+tree[u].ad*(tree[u<<|].r-tree[u<<|].l+)%mod)%mod;
    tree[u<<].mu=tree[u].mu*tree[u<<].mu%mod;
    tree[u<<|].mu=tree[u].mu*tree[u<<|].mu%mod;
    tree[u<<].ad=(tree[u].ad+tree[u<<].ad*tree[u].mu)%mod;
    tree[u<<|].ad=(tree[u].ad+tree[u<<|].ad*tree[u].mu)%mod;
    tree[u].ad=;
    tree[u].mu=;
}

void query(int u)
{
    if(tree[u].l>=x&&tree[u].r<=y)
    {
        ans=(ans+tree[u].w)%mod;
        return;
    }
    down(u);
    int mid=(tree[u].l+tree[u].r)>>;
    if(x<=mid) query(u<<);
    if(y>mid) query(u<<|);
    return;
}

void mul(int u)
{
    if(tree[u].l>=x&&tree[u].r<=y)
    {
        tree[u].w*=c;
        tree[u].w%=mod;
        tree[u].mu=(tree[u].mu*c)%mod;
        tree[u].ad=(tree[u].ad*c)%mod;
        return;
    }
    down(u);
    int mid=(tree[u].l+tree[u].r)>>;
    if(x<=mid) mul(u<<);
    if(y>mid) mul(u<<|);
    tree[u].w=(tree[u<<].w+tree[u<<|].w)%mod;
    return;
}

void add(int u)
{
    if(tree[u].l>=x&&tree[u].r<=y)
    {
        tree[u].ad=(tree[u].ad+c)%mod;
        tree[u].w+=(tree[u].r-tree[u].l+)*c;
        tree[u].w%=mod;
        return;
    }
    down(u);
    int mid=(tree[u].l+tree[u].r)>>;
    if(x<=mid) add(u<<);
    if(y>mid) add(u<<|);
    tree[u].w=(tree[u<<].w+tree[u<<|].w)%mod;
    return;
}

int main()
{
    n=read();
    mod=read();
    build(,,n);
    m=read();
    for(int i=;i<=m;++i)
    {
        q=read();
        x=read();
        y=read();
        if(q==)
        {
            c=read();
            mul();
        }
        if(q==)
        {
            c=read();
            add();
        }
        if(q==)
        {
            ans=;
            query();
            printf("%lld\n",ans%mod);
        }
    }
　　 return 0;
}