bzoj 维护序列seq(双标记线段树)

Seq 维护序列seq

Time Limit: 30 Sec  Memory Limit: 64 MB
Submit: 4184  Solved: 1518
[Submit][Status][Discuss]

Description

老师交给小可可一个维护数列的任务，现在小可可希望你来帮他完成。 有长为N的数列，不妨设为a1,a2,…,aN 。有如下三种操作形式： (1)把数列中的一段数全部乘一个值; (2)把数列中的一段数全部加一个值; (3)询问数列中的一段数的和，由于答案可能很大，你只需输出这个数模P的值。

Input

第一行两个整数N和P(1≤P≤1000000000）。第二行含有N个非负整数,从左到右依次为a1,a2,…,aN, (0≤ai≤1000000000,1≤i≤N)。第三行有一个整数M，表示操作总数。从第四行开始每行描述一个操作，输入的操作有以下三种形式： 操作1：“1 t g c”(不含双引号)。表示把所有满足t≤i≤g的ai改为ai×c (1≤t≤g≤N,0≤c≤1000000000)。 操作2：“2 t g c”(不含双引号)。表示把所有满足t≤i≤g的ai改为ai+c (1≤t≤g≤N,0≤c≤1000000000)。 操作3：“3 t g”(不含双引号)。询问所有满足t≤i≤g的ai的和模P的值 (1≤t≤g≤N)。 同一行相邻两数之间用一个空格隔开，每行开头和末尾没有多余空格。

Output

对每个操作3，按照它在输入中出现的顺序，依次输出一行一个整数表示询问结果。

Sample Input

7 43
1 2 3 4 5 6 7
5
1 2 5 5
3 2 4
2 3 7 9
3 1 3
3 4 7

Sample Output

2
35
8

HINT

【样例说明】

初始时数列为(1,2,3,4,5,6,7)。
经过第1次操作后，数列为(1,10,15,20,25,6,7)。
对第2次操作，和为10+15+20=45，模43的结果是2。
经过第3次操作后，数列为(1,10,24,29,34,15,16}
对第4次操作，和为1+10+24=35，模43的结果是35。
对第5次操作，和为29+34+15+16=94,模43的结果是8。

测试数据规模如下表所示

数据编号 1 2 3 4 5 6 7 8 9 10
N= 10 1000 1000 10000 60000 70000 80000 90000 100000 100000
M= 10 1000 1000 10000 60000 70000 80000 90000 100000 100000

题解：给两个操作，操作1，把l,r数字乘以c，操作2：把l,r数字都加上c；

直接开两个标记去存储，样例过了，但是无限wa；

我有几点没考虑完全：

1：对于第一个操作，每次标记应该都是乘以c；而我弄成加了，因为假设第一次乘以5，第二次再乘以5，就是25

了；

2：对于第二种操作，没有考虑到第一种操作可以影响第二种操作，如果执行第一种操作，里面的元素编程5倍了，此时标记2也应当乘以相应倍数；加上5+2，5乘以5了，2也应当乘以5；

总结：考虑问题还是不太全面，不能完全驾驭题目；

代码：

 extern "C++"{
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<cassert>
 #include<cstdlib>
 using namespace  std;
 typedef long long LL;
 typedef unsigned u;
 typedef unsigned long long ull;
 #define mem(x,y) memset(x,y,sizeof(x))
 void SI(double &x){scanf("%lf",&x);}
 void SI(int &x){scanf("%d",&x);}
 void SI(LL &x){scanf("%lld",&x);}
 void SI(u &x){scanf("%u",&x);}
 void SI(ull &x){scanf("%llu",&x);}
 void SI(char *s){scanf("%s",s);}

 void PI(int x){printf("%d",x);}
 void PI(double x){printf("%lf",x);}
 void PI(LL x){printf("%lld",x);}
 void PI(u x){printf("%u",x);}
 void PI(ull x){printf("%llu",x);}
 void PI(char *s){printf("%s",s);}

 #define NL puts("");
 #define ll root<<1
 #define rr root<<1|1
 #define lson ll,l,mid
 #define rson rr,mid+1,r
 const int INF=0x3f3f3f3f;
 const int MAXN=;
 LL tree[MAXN << ];
 LL lazy[MAXN << ];
 LL lazy2[MAXN << ];
 LL P;
 }
 void pushup(int root){
     tree[root] = tree[ll] + tree[rr];
     tree[root] %= P;
 }
 void pushdown(int root,int x){
     if(lazy[root] != ){
         lazy[ll] *= lazy[root];
         lazy[rr] *= lazy[root];

         lazy2[ll] *= lazy[root];
         lazy2[rr] *= lazy[root];
     //    tree[ll]=lazy[root]*(mid-l+1);
     //    tree[rr]=lazy[root]*(r-mid);
         tree[ll] *= lazy[root];
         tree[rr] *= lazy[root];

         lazy[ll] %= P;
         lazy[rr] %= P;
         tree[ll] %= P;
         tree[rr] %= P;
         lazy2[ll] %= P;
         lazy2[rr] %= P;

         lazy[root] = ;
     }
     if(lazy2[root]){
         lazy2[ll] += lazy2[root];
         lazy2[rr] += lazy2[root];

         lazy2[ll] %= P;
         lazy2[rr] %= P;

         tree[ll] += lazy2[root] * (x - (x >> ) ) % P;
         tree[rr] += lazy2[root] * (x >> ) % P;

         tree[ll] %= P;
         tree[rr] %= P;

         lazy2[root] = ;
     }
 }
 void build(int root,int l,int r){
     int mid = (l + r) >> ;
     lazy[root] = ;
     lazy2[root] = ;
     if(l == r){
         SI(tree[root]);
         return ;
     }
     build(lson);
     build(rson);
     pushup(root);
 }
 void update(int root,int l,int r,int L,int R,int C,int t){
     if(l >= L && r <= R){
          if(t == ){
              lazy[root] *= C;
              tree[root] *= C;
              lazy2[root] *= C;
              lazy2[root] %= P;
              lazy[root] %= P;
              tree[root] %= P;
          }
         else if(t == ){
             lazy2[root] += C % P;
             tree[root] += C * (r - l +) % P;
             lazy2[root] %= P;
              tree[root] %= P;
         }
         return ;
     }
     int mid = (l + r) >> ;
     pushdown(root,r - l + );
     if(mid >= L)
         update(lson,L,R,C,t);
     if(mid < R)
         update(rson,L,R,C,t);
     pushup(root);
 }
 LL query(int root,int l,int r,int L,int R){
     int mid = (l + r) >> ;
     if(l >= L && r <= R){
         return tree[root];
     }
     pushdown(root,r - l + );
     LL ans = ;
     if(mid >= L)
         ans += query(lson,L,R);
     if(mid < R)
         ans += query(rson,L,R);
     return ans;
 }
 int main(){
 //    assert(true);
     int N,M;
     while(~scanf("%d%lld",&N,&P)){
         build(,,N);
         SI(M);
         int a,l,r,c;
         while(M--){
             SI(a);SI(l);SI(r);
             if(a == ){
                 printf("%lld\n",query(,,N,l,r) % P);
             }
             else{
                 SI(c);
                 update(,,N,l,r,c,a);
             }
         }
     }
     return ;
 }