Luogu 3616 富金森林公园

刚看到此题的时候：sb分块？？?
Rorshach dalao甩手一句看题
于是回去看题……果然是题读错了……

[思路]
对权值离散化后（要先读入所有输入里的权值一起离散化……所以一共有4e4个数据（~~当然你也可以不读入 hehe~~~~）） 建立一颗线段树， 线段树单点维护每一个海拔下的答案
好了问题来了， 怎么算答案呢？
我们从前到后开始扫描， 假设当前扫描到i， 离散化后的权值是now， 设它前一个离散化后的权值是pre， 那么假如（pre < now） 这一个点对答案的贡献值就是[pre + 1, now] 这个区间加一， 当然if不成立的话是不会产生贡献的
好了画样例理解一下， 我认为正确性比较显然

那么如何处理修改的操作呢？
只要先判断一下是否产生贡献， 如果有贡献就通过区间-1消去， 然后再进行重新更新即可

Code：

#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 4e5 + ;
const int inf =  << ;

int n, m, tot = , maxn =, a[N], in[N];

struct Query {
    int op, pos, val;
} qn[N];

struct SegmentTree {
    int s[N << ], tag[N << ];

    #define lc p << 1
    #define rc p << 1 | 1
    #define mid (l + r) / 2

    inline void up(int p) {
        s[p] = s[lc] + s[rc];
    }

    inline void down(int p, int l, int r) {
        if(!tag[p]) return;
        s[lc] += (mid - l + ) * tag[p];
        s[rc] += (r - mid) * tag[p];
        tag[lc] += tag[p], tag[rc] += tag[p];
        tag[p] = ;
    }

    void modify(int p, int l, int r, int x, int y, int v) {
        if(x <= l && y >= r) {
            s[p] += (r - l + ) * v;
            tag[p] += v;
            return;
        }

        down(p, l, r);
        if(x <= mid) modify(lc, l, mid, x, y, v);
        if(y > mid) modify(rc, mid + , r, x, y, v);
        up(p);
    }

    int query(int p, int l, int r, int x) {
        if(l == x && x == r) return s[p];
        down(p, l, r);
        int res = ;
        if(x <= mid) res = query(lc, l, mid, x);
        else res = query(rc, mid + , r, x);
        return res;
    }

} seg;

inline void read(int &X) {
    X = ;
    char ch = ;
    int op = ;
    for(; ch > '' || ch < ''; ch = getchar())
        if(ch == '-') op = -;
    for(; ch >= '' && ch <= ''; ch = getchar())
        X = (X << ) + (X << ) + ch - ;
    X *= op;
}

inline void discrete() {
    in[] = -inf;
    sort(in + , in +  + tot);
    for(int i = ; i <= tot; i++) {
        if(in[i] != in[i - ]) maxn++;
        in[maxn] = in[i];
    }
}

inline int getVal(int v) {
    int ln = , rn = maxn, midn;
    for(; ln <= rn; ) {
        midn = (ln + rn) / ;
        if(in[midn] == v) return midn;
        if(in[midn] < v) ln = midn + ;
        else rn = midn - ;
    }
    return -;
}

inline void init() {
    int now, pre = ;
    for(int i = ; i <= n; i++, pre = now) {
        now = getVal(a[i]);
        if(now > pre) seg.modify(, , maxn, pre + , now, );
    }
}

inline void solve() {
    for(int i = ; i <= m; i++) {
        int v = getVal(qn[i].val);
        if(qn[i].op == ) {
            if(qn[i].val == ) puts("");
            else printf("%d\n", seg.query(, , maxn, v));
        } else {
            int pre = getVal(a[qn[i].pos - ]), now = getVal(a[qn[i].pos]), nxt = getVal(a[qn[i].pos + ]);
            if(pre < now) seg.modify(, , maxn, pre + , now, -);
            if(now < nxt) seg.modify(, , maxn, now + , nxt, -);
            now = getVal(a[qn[i].pos] = qn[i].val);
            if(pre < now) seg.modify(, , maxn, pre + , now, );
            if(now < nxt) seg.modify(, , maxn, now + , nxt, );
        }
    }
}

int main() {
    read(n), read(m);
    for(int i = ; i <= n; i++) {
        read(a[i]);
        in[++tot] = a[i];
    }
    for(int i = ; i <= m; i++) {
        read(qn[i].op);
        if(qn[i].op == ) {
            read(qn[i].val);
            in[++tot] = qn[i].val;
        } else {
            read(qn[i].pos), read(qn[i].val);
            in[++tot] = qn[i].val;
        }
    }

    discrete();
    init();
    solve();

    return ;
}