題目描述

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

• 5

• 3

• 2

• 7

@ 2

3

2

1

5

Sample Output

5

3

6

HINT

【樣例說明】

當JYY輸入2時，計算器會進行5次運算，每一次運算之後得到的結果分

別是6（實際計算結果為7但是超過了上界），3，6，1（實際結果為-1但是低於了下界）和5（由於一開始輸入的是2，所以這一次計算為1+2×2）。
1≤N,Q≤105,1≤L≤Xk≤R≤109,1≤a≤109

題目分析

我們可以發現因為0≤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;
}