【线段树】[BZOJ3787][AHOI2014]奇怪的计算器

最新推荐文章于 2019-10-28 22:15:18 发布

JeremyGJY

最新推荐文章于 2019-10-28 22:15:18 发布

阅读量772

点赞数

分类专栏：图论——线段树图论文章标签：线段树合并玄学 AHOI2014

本文链接：https://blog.csdn.net/JeremyGJY/article/details/51057472

版权

图论同时被 2 个专栏收录

35 篇文章 0 订阅

订阅专栏

图论——线段树

8 篇文章 0 订阅

订阅专栏

题目描述

Description

【故事背景】

JYY有个奇怪的计算器，有一天这个计算器坏了，JYY希望你能帮助他写
一个程序来模拟这个计算器的运算。
【问题描述】
JYY的计算器可以执行N条预设好的指令。每次JYY向计算器输入一个正
整数X，计算器就会以X作为初始值，接着依次执行预设的N条指令，最后把
最终得出的结果返回给JYY。
每一条指令可以是以下四种指令之一：（这里a表示一个正整数。）
1、+a：表示将当前的结果加上a；
2、-a：表示将当前的结果减去a；
3、*a：表示将当前的结果乘以a；
4、@a：表示将当前的结果加上a*X（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

HINT

【样例说明】

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

别是6（实际计算结果为7但是超过了上界），3，6，1（实际结果为-1但是低于了下界）和5（由于一开始输入的是2，所以这一次计算为1+2×2）。
$1\leq N,Q \leq 10^5,1\leq L\leq X_k\leq R\leq 10^9,1\leq a\leq 10^9$

题目分析

我们可以发现因为 $0\leq a$ 那么我们无论怎么进行运算任意两个数字之间的大小关系是不变的，在这里我们可以发现其实这道题目很像原来的另一个题目http://blog.csdn.net/jeremygjy/article/details/50701005>Siano，首先我们把所有的数字排序然后放到线段树上面，然后可以用一个三维的标记来维护线段树，同时结合这道题目的标记合并的方法我们就可以在这样的玄学算法AC本题目。

代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN = 1e5;
long long L, R;
int N, Q;
struct node{
    long long Min, Max;
    int a, b, c;
}tree[MAXN*4+10];
long long v[MAXN+10];
char s[MAXN+10][3];
struct Number{
    long long y;
    int id, val;
}nums[MAXN+10];
bool cmpbyid(Number a, Number b){
    return a.id < b.id;
}
bool cmpbyval(Number a, Number b){
    return a.y < b.y;
}
void push_up(int u){
    tree[u].Min = tree[u*2].Min;
    tree[u].Max = tree[u*2+1].Max;
}
void push_down(int u, int l, int mid, int r){
    if(tree[u].a == 0){
        tree[u*2].a = tree[u*2+1].a = 0;
        tree[u*2].b = tree[u*2+1].b = tree[u].b;
        tree[u*2].c = tree[u*2+1].c = tree[u].c;
        tree[u*2].Min = tree[u].b * nums[l].y + tree[u].c;
        tree[u*2].Max = tree[u].b * nums[mid].y + tree[u].c;
        tree[u*2+1].Min = tree[u].b * nums[mid+1].y + tree[u].c;
        tree[u*2+1].Max = tree[u].b * nums[r].y + tree[u].c;
    }else{
        tree[u*2].a *= tree[u].a; tree[u*2].b *= tree[u].a; tree[u*2].c *= tree[u].a;
        tree[u*2].b += tree[u].b; tree[u*2].c += tree[u].c;
        tree[u*2].Min = tree[u*2].Min * tree[u].a + nums[l].y * tree[u].b + tree[u].c;
        tree[u*2].Max = tree[u*2].Max * tree[u].a + nums[mid].y * tree[u].b + tree[u].c;
        tree[u*2+1].a *= tree[u].a; tree[u*2+1].b *= tree[u].a; tree[u*2+1].c *= tree[u].a;
        tree[u*2+1].b += tree[u].b; tree[u*2+1].c += tree[u].c;
        tree[u*2+1].Min = tree[u*2+1].Min * tree[u].a + nums[mid+1].y * tree[u].b + tree[u].c;
        tree[u*2+1].Max = tree[u*2+1].Max * tree[u].a + nums[r].y * tree[u].b + tree[u].c;
    }
    tree[u].a = 1;
    tree[u].b = 0;
    tree[u].c = 0;
}
void build(int u, int l, int r){
    tree[u].a = 1;
    tree[u].b = tree[u].c = 0;
    if(l == r){
        tree[u].Min = tree[u].Max = nums[l].y;
        return ;
    }
    int mid = (l + r)>>1;
    build(u*2, l, mid);
    build(u*2+1, mid+1, r);
    push_up(u);
}
void reset_Min_val(int u, int l, int r){
    if(tree[u].Min >= L) return ;
    if(tree[u].Max < L){
        tree[u].a = 0;
        tree[u].b = 0;
        tree[u].c = L;
        tree[u].Min = tree[u].Max = L;
        return ;
    }
    if(l == r){
        tree[u].Min = tree[u].Max = L;
        tree[u].a = 1, tree[u].b = tree[u].c = 0;
        return ;
    }
    int mid = (l + r) >> 1;
    push_down(u, l, mid, r);
    reset_Min_val(u*2, l, mid);
    if(tree[u*2+1].Min < L) reset_Min_val(u*2+1, mid+1, r);
    push_up(u);
}
void reset_Max_val(int u, int l, int r){
    if(tree[u].Max <= R) return ;
    if(tree[u].Min > R){
        tree[u].a = 0;
        tree[u].b = 0;
        tree[u].c = R;
        tree[u].Min = tree[u].Max = R;
        return ;
    }
    if(l == r){
        tree[u].Min = tree[u].Max = R;
        tree[u].a = 1, tree[u].b = tree[u].c = 0;
        return ;
    }
    int mid = (l + r) >> 1;
    push_down(u, l, mid, r);
    reset_Max_val(u*2+1, mid+1, r);
    if(tree[u*2].Max > R) reset_Max_val(u*2, l, mid);
    push_up(u);
}
inline void Add(int val){
    tree[1].Max += val;
    tree[1].Min += val;
    tree[1].c += val;
}
inline void Mul(int val){
    tree[1].Max *= val;
    tree[1].Min *= val;
    tree[1].a *= val;
    tree[1].b *= val;
    tree[1].c *= val;
}
inline void At(int val){
    tree[1].Max += nums[Q].y * val;
    tree[1].Min += nums[1].y * val;
    tree[1].b += val;
}
void reset_val(int u, int l, int r){
    if(l == r){
        nums[l].val = tree[u].Min;
        return ;
    }
    int mid = (l + r) >> 1;
    push_down(u, l, mid, r);
    reset_val(u*2, l, mid);
    reset_val(u*2+1, mid+1, r);
}
int main(){
    cin>>N>>L>>R;
    for(int i=1;i<=N;i++){
        scanf("%s", s[i]);
        cin>>v[i];
    }
    scanf("%d", &Q);
    for(int i=1;i<=Q;i++){
        cin>>nums[i].y;
        nums[i].id = i;
    }
    sort(nums+1, nums+1+Q, cmpbyval);
    build(1, 1, Q);
    for(int i=1;i<=N;i++){
        switch(s[i][0]){
        case '+': Add(v[i]);
            break;
        case '-': Add(-v[i]);
            break;
        case '*': Mul(v[i]);
            break;
        case '@': At(v[i]);
            break;
        }
        reset_Max_val(1, 1, Q);
        reset_Min_val(1, 1, Q);
    }
    reset_val(1, 1, Q);
    sort(nums+1, nums+1+Q, cmpbyid);
    for(int i=1;i<=Q;i++)
        printf("%d\n", nums[i].val);

    return 0;
}