BZOJ 3878: [Ahoi2014]奇怪的计算器

标签（空格分隔）： OI-BZOJ OI-线段树

Time Limit: 10 Sec

Memory Limit: 256 MB

Description

【故事背景】

JYY有个奇怪的计算器，有一天这个计算器坏了，JYY希望你能帮助他写

一个程序来模拟这个计算器的运算。

【问题描述】

JYY的计算器可以执行N条预设好的指令。每次JYY向计算器输入一个正

整数X，计算器就会以X作为初始值，接着依次执行预设的N条指令，最后把

最终得出的结果返回给JYY。

每一条指令可以是以下四种指令之一：（这里a表示一个正整数。）

1、+a：表示将当前的结果加上a；

2、-a：表示将当前的结果减去a；

3、a：表示将当前的结果乘以a；

4、@a：表示将当前的结果加上aX（X是一开始JYY输入的数）。

计算器用于记录运算结果的变量的存储范围是有限的，所以每次运算结束之

后会有计算结果溢出的问题。

JYY的计算器中，存储每计算结果的变量只能存储L到R之间的正整数，

如果一次指令执行过后，计算结果超过了R，那么计算器就会自动把结果变成R，然后再以R作为当前结果继续进行之后的计算。同理，如果运算结果小于L，计算器也会把结果变成L，再接着计算。

比如，假设计算器可以存储1到6之间的值，如果当前的计算结果是2，那

么在执行+5操作之后，存储结果的变量中的值将会是6。虽然2+5的实际结

果是7，但是由于7超过了存储范围的上界，所以结果就被自动更正成了上界的大小，也就是6。

JYY一共想在计算器上输入Q个值，他想知道这Q个值输入计算器之后，

分别会得到什么结果呢？

Input

输入文件的第一行包含三个正整数，N，L和R；

第接下来N行，每行一个指令，每个指令如题述，由一个字符和一个正整

数组成，字符和正整数中间有一个空格隔开；

第N+2行包含一个整数Q，表示JYY希望输入的数的数量；

第接下来Q行每行一个正整数，第k个正整数Xk表示JYY在第k次输入的

整数。

Output

输出Q行每行一个正整数，第k行的整数表示输入Xk后，依次经过N个指

令进行计算所得到的结果。

Sample Input

5 1 6

@ 2

Sample Output

6

HINT

【样例说明】

当JYY输入2时，计算器会进行5次运算，每一次运算之后得到的结果分

别是6（实际计算结果为7但是超过了上界），3，6，1（实际结果为-1但是低于了下界）和5（由于一开始输入的是2，所以这一次计算为1+2×2）。

1<=N,Q<=10^{5,1<=L<=Xk<=R<=10}9,1<=a<=10^9

Solution####

线段树

tag可以用$s1*X+s2$表示，写成数对(s1,s2)

记录a,b,c表示：$(()*a+b,()*a+c)$

标记合并$((()*a+b)*a'+b',(()*a+c)*a'+c')$

$a=a*a',b=b*a'+b',c=c*a'+c'$

+ num :$a=1,b=0,c=num$

- num :$a=1,b=0,c=num$

* num :$a=num,b=0,c=0$

@ num :$a=1,b=sum,c=0$

对$X_i$排序

线段树上每个点维护根到区间左右端点的tag标记以及当前点的lazytag标记。

若区间左端点为R，那么打标记全部标记成R:$a=0,b=0,c=R$；L同理。

复杂度$O(nlog_2n)$

Code####



#include<iostream>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<math.h>

#include<algorithm>

#include<queue>

#include<set>

#include<map>

#include<bitset>

#include<vector>

using namespace std;

#define PA pair<int,int>

int read()

{

 	int s=0,f=1;char ch=getchar();

	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}

	while(ch>='0'&&ch<='9'){s=(s<<1)+(s<<3)+ch-'0';ch=getchar();}

	return s*f;

}

//smile please

int n,m,h[100005];

long long SL,SR,L,R,s[100005],xx[100005];

int p[100005];

bool cmp(int a,int b)

{return xx[a]<xx[b];}

struct tag

{

	long long a,b,c;

	void clear(){a=1,b=c=0;}

	void operator+=(tag o)

	   {a=a*o.a,b=b*o.a+o.b,c=c*o.a+o.c;}

	long long calc(long long x)

	   {return min(max(L,x*(a+b)+c),R);}

};

struct tree

{

	tag l,r,la;

	tree(){l.clear(),r.clear(),la.clear();}

}t[1<<19];

void down(int x,int l,int r)

{

	if(l>=r)return;

	t[x*2].la+=t[x].la,t[x*2].l+=t[x].la,t[x*2].r+=t[x].la;

	t[x*2+1].la+=t[x].la,t[x*2+1].l+=t[x].la,t[x*2+1].r+=t[x].la;

	t[x].la.clear();

}

void solve(int x,int l,int r)

{

	if(t[x].r.calc(xx[h[r]])!=R&&t[x].l.calc(xx[h[l]])!=L)return;

	down(x,l,r);

	if(t[x].l.calc(xx[h[l]])==R){t[x].l=t[x].r=t[x].la=(tag){0,0,R};return;}

	if(t[x].r.calc(xx[h[r]])==L){t[x].l=t[x].r=t[x].la=(tag){0,0,L};return;}

	solve(x*2,l,l+r>>1);

	solve(x*2+1,(l+r>>1)+1,r);

	t[x].l=t[x*2].l;

	t[x].r=t[x*2+1].r;

}

void solve2(int x,int l,int r)

{

	down(x,l,r);

	if(l!=r)

	  solve2(x*2,l,l+r>>1),

	  solve2(x*2+1,(l+r>>1)+1,r);

	else

	  xx[h[l]]=t[x].l.calc(xx[h[l]]);

}

int main()

{

	n=read(),L=read(),R=read();

	for(int i=1;i<=n;i++)

	   {char z[3];

	    scanf("%s",z);

	    s[i]=read();

	    if(z[0]=='+')p[i]=1;

	    if(z[0]=='-')p[i]=2;

	    if(z[0]=='*')p[i]=3;

	    if(z[0]=='@')p[i]=4;

	   }

	m=read();

	for(int i=1;i<=m;i++)

	    xx[i]=read(),h[i]=i;

	sort(&h[1],&h[m+1],cmp);

	for(int i=1;i<=n;i++)

	   {tag v;

	    if(p[i]==1)v=(tag){1,0,s[i]};

	    if(p[i]==2)v=(tag){1,0,-s[i]};

	    if(p[i]==3)v=(tag){s[i],0,0};

	    if(p[i]==4)v=(tag){1,s[i],0};

		t[1].la+=v,t[1].l+=v,t[1].r+=v;

	    solve(1,1,m);

	   }

	solve2(1,1,m);

	for(int i=1;i<=m;i++)

	    printf("%d\n",(int)xx[i]);

	return 0;

}