CCPC 2018 吉林 H "LOVERS" （线段树）

---恢复内容开始---

传送门

参考资料：

　　[1]:https://blog.csdn.net/mmk27_word/article/details/89788448

题目描述：
    The Fool comes to a cross-road, filled with energy, confidence and purpose, knowing exactly where he wants to go and what he wants to do.
    But he comes to a dead stop. A flowering tree marks the path he wants to take, the one he's been planning on taking. But standing before a fruit tree marking the other path is a woman.
    The Fool has met and had relationships with women before, some far more beautiful and alluring.
    But she is different. Seeing her, he feels as though he's just been shot in the heart with cupid's arrow.
（以上全是废话，与题意毫无关系）

There are n empty strings:
s1,s2,...,sn.
You are required to perform two kinds of operations:
·wrap l r d : change si to dsid for all l <= i <= r,where d is a digit character;
·query l r : query ∑value(si)(mod 1e9+) (for all l <= i <= r),where value(s) is the number that string s represents.

Note that the value of an empty string is .

输入
    The first line contains one integer T, which denote the number of cases.
    For each case, the first line contains two integer n and m where n is the number of strings and m is the number of operations.
    Each line of the following m lines contains an operation with format (wrap l r d) or (query l r).

输出
    For each case, you should output "Case i:" in a line, where i is the case number starting from .
    Then for each query operation in that case, output a line that contains a single integer that representing the answer for that query operation.

题目描述

样例输入：

wrap
query  

wrap
wrap
query
query  

样例输出
Case :

Case :

样例输入输出

所有思路均来自参考资料，下面只是谈谈本蒟蒻的进一步理解：

　　定义 f(s) = strlen(s);

　　对串 s₁ 执行 swap 操作，可得到新串 ds₁d，转换成数字就是 10*d*10^f(s₁)+s₁*10+d;

　　那么，对于区间[L,R]执行 swap 操作，其中的每个串 s_i 都会变成上述的形式；

　　∑(s_i) = 10*d*10^f(s_L)+s_L*10+d + 10*d*10^f(s_L+1)+s_L+1*10+d +..........+ 10*d*10^f(s_R)+s_R*10+d

　　　　  = 10*d*( 10^f(s_L)+10^f(s_L+1)+..........10^f(s_R) )+10*(s_L+s_L+1+.......+s_R)+(R-L+1)*d;

　　得出这个表达式后，就可以用线段树进行区间维护了；

　　线段树中定义的变量 :

 struct Seg
 {
     int l,r;
     ll f;
     ll sum;
     int mid(){return l+((r-l)>>);}
     int len(){return r-l+;};
 }seg[maxn<<];

　　（f = 10^f(s_l)+10^f(s_l+1)+..........10^f(s_r)  , sum=∑(s_i) for all l  i ≤ r）

　　那么，对于修改的区间[l,r]，更新f,sum操作如下（假设当前要修改的节点为pos）：

 seg[pos].sum=*d*seg[pos].f+*seg[pos].sum+seg[pos].len()*d;
 seg[pos].f=seg[pos].f*;

　　线段树处理区间修改问题一定要用到懒惰标记，如何标记呢？

 struct Seg
 {
     ll lazyLen;
     ll lazyL;
     ll lazyR;
     int mid(){return l+((r-l)>>);}
     int len(){return r-l+;};
 }seg[maxn<<];

　　（lazyL : 左边懒惰的值 , lazyR : 右侧懒惰的值 , lazyLen : 懒惰的长度）　　

　　令 val = seg[pos].sum;

　　假设 pos 节点依次懒惰了 d₁,d₂,d₃，那么 lazyL = d₃d₂d₁ , lazyR = d₁d₂d₃ , lazyLen = 1000(10³,共懒惰了三位);

　　pushDown(pos)向下传递懒惰标记函数如下：

 void F(int son,int f)
 {
     seg[son].sum=(seg[f].lazyL*seg[f].lazyLen%mod*seg[son].f%mod+
                  seg[son].sum*seg[f].lazyLen%mod+
                  seg[son].len()*seg[f].lazyR%mod)%mod;
     seg[son].f=seg[son].f*seg[f].lazyLen%mod*seg[f].lazyLen%mod;

     seg[son].lazyL=(seg[f].lazyL*seg[son].lazyLen%mod+seg[son].lazyL)%mod;
     seg[son].lazyR=(seg[son].lazyR*seg[f].lazyLen%mod+seg[f].lazyR)%mod;
     seg[son].lazyLen=seg[son].lazyLen*seg[f].lazyLen%mod;
 }
 void pushDown(int pos)
 {
     Seg &tmp=seg[pos];
     if(tmp.lazyLen <= )
         return ;

     F(ls(pos),pos);
     F(rs(pos),pos);

     tmp.lazyLen=;
     tmp.lazyL=tmp.lazyR=;
 }

 AC代码：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 #define ls(x) (x<<1)
 #define rs(x) (x<<1|1)
 #define ll long long
 const int mod=1e9+;
 const int maxn=1e5+;

 int n,m;
 struct Seg
 {
     int l,r;
     ll f;///10的幂和
     ll sum;///区间和
     ll lazyLen;
     ll lazyL;///左侧懒惰的数
     ll lazyR;///右侧懒惰的数
     int mid(){return l+((r-l)>>);}
     int len(){return r-l+;};
 }seg[maxn<<];

 void pushUp(int pos)
 {
     seg[pos].f=(seg[ls(pos)].f+seg[rs(pos)].f)%mod;
     seg[pos].sum=(seg[ls(pos)].sum+seg[rs(pos)].sum)%mod;
 }
 void F(int son,int f)///向下传递懒惰标记
 {
     seg[son].sum=(seg[f].lazyL*seg[f].lazyLen%mod*seg[son].f%mod+
                  seg[son].sum*seg[f].lazyLen%mod+
                  seg[son].len()*seg[f].lazyR%mod)%mod;
     seg[son].f=seg[son].f*seg[f].lazyLen%mod*seg[f].lazyLen%mod;

     seg[son].lazyL=(seg[f].lazyL*seg[son].lazyLen%mod+seg[son].lazyL)%mod;
     seg[son].lazyR=(seg[son].lazyR*seg[f].lazyLen%mod+seg[f].lazyR)%mod;
     seg[son].lazyLen=seg[son].lazyLen*seg[f].lazyLen%mod;
 }
 void pushDown(int pos)
 {
     Seg &tmp=seg[pos];
     if(tmp.lazyLen <= )
         return ;

     F(ls(pos),pos);
     F(rs(pos),pos);

     tmp.lazyLen=;
     tmp.lazyL=tmp.lazyR=;
 }
 void buildSegTree(int l,int r,int pos)
 {
     seg[pos].l=l;
     seg[pos].r=r;
     seg[pos].lazyLen=;
     seg[pos].lazyL=seg[pos].lazyR=;
     if(l == r)
     {
         seg[pos].f=;///初始为10^0
         seg[pos].sum=;
         return ;
     }
     int mid=l+((r-l)>>);
     buildSegTree(l,mid,ls(pos));
     buildSegTree(mid+,r,rs(pos));

     pushUp(pos);
 }
 void Update(int l,int r,int pos,int d)
 {
     if(seg[pos].l == l && seg[pos].r == r)
     {
         seg[pos].sum=(*d*seg[pos].f%mod+*seg[pos].sum%mod+seg[pos].len()*d%mod)%mod;
         seg[pos].f=seg[pos].f*%mod;

         seg[pos].lazyL=(d*seg[pos].lazyLen%mod+seg[pos].lazyL)%mod;
         seg[pos].lazyR=(seg[pos].lazyR*+d)%mod;
         seg[pos].lazyLen=seg[pos].lazyLen*%mod;

         return ;
     }
     pushDown(pos);

     int mid=seg[pos].mid();
     if(r <= mid)
         Update(l,r,ls(pos),d);
     else if(l > mid)
         Update(l,r,rs(pos),d);
     else
     {
         Update(l,mid,ls(pos),d);
         Update(mid+,r,rs(pos),d);
     }
     pushUp(pos);
 }
 ll Query(int l,int r,int pos)
 {
     if(seg[pos].l == l && seg[pos].r == r)
         return seg[pos].sum;

     pushDown(pos);

     int mid=seg[pos].mid();
     if(r <= mid)
         return Query(l,r,ls(pos))%mod;///返回结果要取模
     else if(l > mid)
         return Query(l,r,rs(pos))%mod;
     else
         return (Query(l,mid,ls(pos))+Query(mid+,r,rs(pos)))%mod;
 }
 void Solve()
 {
     buildSegTree(,n,);

     for(int i=;i <= m;++i)
     {
         char order[];
         int l,r,d;
         scanf("%s%d%d",order,&l,&r);
         if(order[] == 'w')
         {
             scanf("%d",&d);
             Update(l,r,,d);
         }
         else
             printf("%d\n",Query(l,r,));
     }
 }
 int main()
 {
     int test;
     scanf("%d",&test);
     for(int kase=;kase <= test;++kase)
     {
         scanf("%d%d",&n,&m);

         printf("Case %d:\n",kase);
         Solve();
     }
     return ;
 }

刚开始，我的lazyLen记录的就是懒惰的长度，每次更新的时候都用个 quickPower(10,lazyLen)，超时了..........

调用quickPower()的次数太多了，每次 wrap 操作都要用到好多个quickPower()；