洛谷P3373 【模板】线段树 2 && P2023 [AHOI2009]维护序列——题解

题目传送： P3373 【模板】线段树 2  P2023 [AHOI2009]维护序列

该题较传统线段树模板相比多了一个区间乘的操作。一提到线段树的区间维护问题，就自然想到了“懒标记”：为了降低时间复杂度，我们只需将要要查询的区间的真实值更新出来，而不至于一直细分到区间的每个单元，并给更新真实值的区间附加一个“懒标记”，表示他的后代们还没有被更新。但是题中既有区间加，又有区间乘，一个懒标记难以轻松地同时把加和乘表示，怎么办呢？用两个懒标记不就好了嘛。设lzsum[i]、lzmul[i]分别为i节点表示加的懒标记和表示乘的懒标记。

接下来如何下传懒标记呢？这就看我们要怎么用懒标记由标记前的状态表示标记后的状态了。因为只有加和乘，我们考虑先加还是先乘。

　　先加的话，用懒标记更新状态的方程即为tree[son]=(tree[son]+lzsum[father])*lzmul[father]。这个式子一看就让人摸不到维护lzsum和lzmul的头绪，很难适用于编程实现，看看另一种情况吧；

　　先乘的话，用懒标记更新状态的方程即为tree[son]=tree[son]*lzmul[father]+lzsum[father]*区间长度。分析一下这个式子，设想当再乘一个数k时，tree[son]直接*=k就OK了，这样不就相当于原式中的lzmul[father]乘上个kk且lzsum[father]也乘上个k吗（乘法分配律）？如果再加一个数k的话，只需让式子中的lzsum[father]+k就行了。这样我们就找到了一个下传的策略：先乘再加。同时我们还分析出了更新lzsum和lzmul的方法。

　　看到这里，不难发现懒标记的实际意义就是目前区间的每个元素较他自己有懒标记前的值在一顿区间加区间乘操作后等效于要乘几倍后再加几。由此知，当懒标记由父节点下传、去更新儿子的真实值时，父亲懒标记代表的“要乘几倍后再加几”，就是儿子“要乘几倍后再加几”。

　　题中提到数据太大、输出取模后的结果，那就在算式里多模几下就行了。

上AC代码！：

 #include<iostream>
 #include<cstdio>
 #include<cctype>
 #include<cstring>
 #include<stack>
 #include<cmath>
 using namespace std;
 long long tree[],mod,a[],lzsum[],lzmul[];
 long long ans;
 char ch;
 long long read()
 {
     ans=;
     ch=getchar();
     while(!isdigit(ch)) ch=getchar();
     while(isdigit(ch)) ans=(ans<<)+(ans<<)+ch-'',ch=getchar();
     return ans;
 }
 void build(int t,int l,int r)//线段树的初始化
 {
     if(l==r) tree[t]=a[l];
     else
     {
         int mid=(l+r)/,ls=t*,rs=ls+;
         build(ls,l,mid);
         build(rs,mid+,r);
         tree[t]=(tree[ls]+tree[rs])%mod;
     }
     lzmul[t]=;
 }
 stack<char>pri;
 void print(long long a)//输出优化，显效甚微，嫌麻烦用scanf就行。
 {
     if(!a)//写这样的输出优化别忘了在判断a=0的时候。（因为下文默认a>0。如果开头不特判的话，
           //当a=0时程序会直接跳过两个while，只会输出一个回车）
     {
         putchar('');
         putchar('\n');
         return;
     }
     while(a>)
     {
         pri.push(a%+'');
         a/=;
     }
     while(!pri.empty())
     {
         putchar(pri.top());
         pri.pop();
     }
     putchar('\n');
 }
 void down(int t,int l,int r)//懒标记的下传
 {
     if(lzsum[t]==&&lzmul[t]==) return;
     int ls=t*,rs=ls+;
     tree[ls]=(tree[ls]*lzmul[t]+lzsum[t]*((r-l+)/))%mod;
     tree[rs]=(tree[rs]*lzmul[t]+lzsum[t]*((r-l+)/))%mod;
     lzmul[ls]=(lzmul[ls]*lzmul[t])%mod;
     lzmul[rs]=(lzmul[rs]*lzmul[t])%mod;
     lzsum[ls]=(lzsum[ls]*lzmul[t]+lzsum[t])%mod;
     lzsum[rs]=(lzsum[rs]*lzmul[t]+lzsum[t])%mod;
     lzsum[t]=;
     lzmul[t]=;//注意lzmul的初始状态应该为一,因为一个数乘1才等于它本身
 }
 void mul(int t,int l,int r,int ll,int rr,int k)
 {
     if(ll<=l&&r<=rr)
     {
         tree[t]=(tree[t]*k)%mod;
         lzmul[t]=(lzmul[t]*k)%mod;
         lzsum[t]=(lzsum[t]*k)%mod;
         return;
     }
     down(t,l,r);
     int mid=(l+r)/,ls=t*,rs=ls+;
     if(ll<=mid) mul(ls,l,mid,ll,rr,k);
     if(rr>mid) mul(rs,mid+,r,ll,rr,k);
     tree[t]=(tree[ls]+tree[rs])%mod;//儿子更新可不能忘了爹啊
 }
 void sum(int t,int l,int r,int ll,int rr,int k)
 {
     if(ll<=l&&r<=rr)
     {
         tree[t]=(tree[t]+k*(r-l+))%mod;
         lzsum[t]=(lzsum[t]+k)%mod;
         return;
     }
     down(t,l,r);
     int ls=t*,rs=ls+,mid=(l+r)/;
     if(ll<=mid) sum(ls,l,mid,ll,rr,k);
     if(rr>mid) sum(rs,mid+,r,ll,rr,k);
     tree[t]=(tree[ls]+tree[rs])%mod;
 }
 void fin(int t,int l,int r,int ll,int rr)
 {
     if(ll<=l&&r<=rr)
     {
         ans=(ans+tree[t])%mod;
         return;
     }
     down(t,l,r);
     int ls=t*,rs=ls+,mid=(l+r)/;
     if(ll<=mid) fin(ls,l,mid,ll,rr);
     if(rr>mid) fin(rs,mid+,r,ll,rr);
 }
 int main()
 {
     int n=read(),m;
     mod=read();
     for(int i=;i<=n;i++)
         a[i]=read();
     build(,,n);
     m=read();
     int order,l,r,k;
     for(int i=;i<=m;i++)
     {
         order=read();
         if(order==)
         {
             l=read(),r=read(),k=read();
             mul(,,n,l,r,k);
         }
         if(order==)
         {
             l=read(),r=read(),k=read();
             sum(,,n,l,r,k);
         }
         if(order==)
         {
             l=read(),r=read();
             ans=;
             fin(,,n,l,r);
             print(ans);
         }
     }
     return ;
 }