bzoj 1798: [Ahoi2009]Seq 维护序列seq &&luogu 223

1798: [Ahoi2009]Seq 维护序列seq

Time Limit: 30 Sec   Memory Limit: 64 MB
Submit: 7037   Solved: 2532
[ 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

Source

Day1

线段树打两个标记

下传时先传乘法，再传加法

注意乘法标记要初始化为1

并且下传的条件是mul !=1(之前我写>1错了)

#include<cstdio>
#include<cstring>
#define lson ro<<1
#define rson ro<<1|1
const int N=1e5+7;
struct node
{
	node()
	{
		mul=1;
	}
	int l,r,sum;
	int lazy,mul;
}e[N*4];
int mod;
inline void pushup(int ro)
{
	e[ro].sum=(e[lson].sum+e[rson].sum)%mod;
}
inline int read()
{
	int ans=0,f=1;char t=getchar();
	while(t<'0'||t>'9')	f=(t=='-'?-1:1),t=getchar();
	while(t>='0'&&t<='9')	ans=ans*10+t-'0',t=getchar();
	return ans*f;
}
void build(int ro,int l,int r)
{
	e[ro].l=l,e[ro].r=r;
	if(l==r)
	{
		e[ro].sum=read()%mod;
		return;
	}
	int mid=(l+r)>>1;
	build(lson,l,mid);build(rson,mid+1,r);
	pushup(ro);
}
inline void pushdown(int ro)
{
	if(e[ro].mul!=1)
	{
		e[lson].sum=(long long)e[lson].sum*e[ro].mul%mod;
		e[lson].mul=(long long)e[lson].mul*e[ro].mul%mod;
		e[lson].lazy=(long long)e[lson].lazy*e[ro].mul%mod;
		
		e[rson].sum=(long long)e[rson].sum*e[ro].mul%mod;
		e[rson].mul=(long long)e[rson].mul*e[ro].mul%mod;
		e[rson].lazy=(long long)e[rson].lazy*e[ro].mul%mod;
		e[ro].mul=1;
	}
	if(e[ro].lazy)
	{
		e[lson].sum=( e[lson].sum + (long long) (e[lson].r-e[lson].l+1)*e[ro].lazy%mod )%mod;
		e[lson].lazy=( e[lson].lazy+e[ro].lazy )%mod;
		
		e[rson].sum=( e[rson].sum + (long long) (e[rson].r-e[rson].l+1)*e[ro].lazy%mod )%mod;
		e[rson].lazy=( e[rson].lazy+e[ro].lazy )%mod;
		e[ro].lazy=0;
	}
}
void add(int ro,int l,int r,int num)
{
	if(l<=e[ro].l&&e[ro].r<=r)
	{
		e[ro].sum=(e[ro].sum+ (long long ) (e[ro].r-e[ro].l+1)*num % mod )%mod;
		e[ro].lazy=(e[ro].lazy+num)%mod;
		return;
	}
	pushdown(ro);
	int mid=(e[ro].l+e[ro].r)>>1;
	if(l<=mid)	add(lson,l,r,num);
	if(r>mid)	add(rson,l,r,num);
	pushup(ro);
}
void time(int ro,int l,int r,int num)
{
	if(l<=e[ro].l&&e[ro].r<=r)
	{
		e[ro].sum=(long long)e[ro].sum*num%mod;
		e[ro].mul=(long long)e[ro].mul*num%mod;
		e[ro].lazy=(long long)e[ro].lazy*num%mod;
		return;
	}
	pushdown(ro);
	int mid=(e[ro].l+e[ro].r)>>1;
	if(l<=mid)	time(lson,l,r,num);
	if(r>mid)	time(rson,l,r,num);
	pushup(ro);
}
int query(int ro,int l,int r)
{
	if(l<=e[ro].l&&e[ro].r<=r)		return e[ro].sum; 
	pushdown(ro);
	int mid=(e[ro].l+e[ro].r)>>1,ans=0;
	if(l<=mid)	ans+=query(lson,l,r);
	if(r>mid)	ans=( ans+query(rson,l,r) )%mod;
	return ans;
}
int main()
{
	int n=read();
	mod=read();
	build(1,1,n);
	int m=read();
	int u,v,c,opt;
	for(int i=1;i<=m;i++)
	{
		opt=read();
		if(opt==1)	u=read(),v=read(),c=read()%mod,time(1,u,v,c);
		else if(opt==2)	u=read(),v=read(),c=read()%mod,add(1,u,v,c);
		else u=read(),v=read(),printf("%d\n",query(1,u,v) );
	}
	return 0;
}