python/TangDou/AcWing/SegmentTree/Gorgeous/BZOJ4695_2.cpp

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long LL;
const int N = 550000;
const int INF = 0x3f3f3f3f;

#define ls u << 1
#define rs u << 1 | 1
//快读
int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 3) + (x << 1) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}

int n, m;

struct Node {
    int l, r;
    int mx, cx;  //最大值，最大值个数
    int sx;      //次大值
    int mi, ci;  //最小值，最小值个数
    int si;      //次小值
    LL sum;      //区间和
    int add1, add2, add3; //最小值增加，最大值增加，普通值增加
} tr[N << 2];

//向上推送统计信息，由左右儿子的统计信息更新父亲u的统计信息
void pushup(int u) {
    tr[u].sum = tr[ls].sum + tr[rs].sum; //区间和
    //更新最大值系列信息 mx,sx,cx
    if (tr[ls].mx == tr[rs].mx) {
        tr[u].mx = tr[ls].mx;
        tr[u].cx = tr[ls].cx + tr[rs].cx;
        tr[u].sx = max(tr[ls].sx, tr[rs].sx);
    } else if (tr[ls].mx > tr[rs].mx) {
        tr[u].mx = tr[ls].mx;
        tr[u].cx = tr[ls].cx;
        tr[u].sx = max(tr[ls].sx, tr[rs].mx);
    } else if (tr[ls].mx < tr[rs].mx) {
        tr[u].mx = tr[rs].mx;
        tr[u].cx = tr[rs].cx;
        tr[u].sx = max(tr[ls].mx, tr[rs].sx);
    }
    //更新最小值系列信息 mi,si,ci
    if (tr[ls].mi == tr[rs].mi) {
        tr[u].mi = tr[ls].mi;
        tr[u].si = min(tr[ls].si, tr[rs].si);
        tr[u].ci = tr[ls].ci + tr[rs].ci;
    } else if (tr[ls].mi > tr[rs].mi) {
        tr[u].mi = tr[rs].mi;
        tr[u].ci = tr[rs].ci;
        tr[u].si = min(tr[ls].mi, tr[rs].si);
    } else if (tr[ls].mi < tr[rs].mi) {
        tr[u].mi = tr[ls].mi;
        tr[u].ci = tr[ls].ci;
        tr[u].si = min(tr[ls].si, tr[rs].mi);
    }
}

/*
  k1:最小值增量,k2:最大值增量,k3:一般值增量
*/
void update(int u, int k1, int k2, int k3) {
    /*
    ① 更新区间和
    如果一个区间的值域很小（比如只有1或2个数），可能会发生一个值既是最大值又是次小值这种情况，也就是发生了数域的重叠.
    这种情况要特判，分辨到底该被哪个标记作用。
    */
    if (tr[u].mi == tr[u].mx) { // 只有一种值时，最大值等于最小值
        // if (k1 == k3) k1 = k2;
        // if (k2 == k3) k2 = k1;

        // 不应被其他值的标记作用
        if (k1 == k3)
            k1 = k2;
        else
            k2 = k1;
        tr[u].sum += (LL)k1 * tr[u].ci;
    } else
        //整体增量=最小值增量*个数+最大值增量*个数+普通值增量*个数
        tr[u].sum += (LL)k1 * tr[u].ci + (LL)k2 * tr[u].cx + (LL)k3 * (tr[u].r - tr[u].l + 1 - tr[u].ci - tr[u].cx);

    //② 更新次小
    if (tr[u].si == tr[u].mx) //次小等于最大
        tr[u].si += k2;
    else if (tr[u].si != INF) //次小存在
        tr[u].si += k3;

    //③ 更新次大
    if (tr[u].sx == tr[u].mi) //次大等于最小
        tr[u].sx += k1;
    else if (tr[u].sx != -INF) //次大存在
        tr[u].sx += k3;

    //④ 更新最小值，最大值
    tr[u].mi += k1, tr[u].mx += k2;

    //⑤ 向左右儿子传递懒标记add1,add2,add3
    tr[u].add1 += k1, tr[u].add2 += k2, tr[u].add3 += k3;
}

//向下传递懒标记，一般是有新的更新操作，或者，有了查询操作时才这样做
void pushdown(int u) {
    int mi = min(tr[ls].mi, tr[rs].mi);
    int mx = max(tr[ls].mx, tr[rs].mx);

    /*
    k1:最小值增量,k2:最大值增量,k3:一般值增量
    有三个lazy add标签，需要注意互相之间的影响关系:
    ① 修改区间最小值时要注意其对最大值、严格次大值的影响
    ② 修改区间最大值时要注意其对最小值、严格次小值的影响
    */
    int k1, k2, k3 = tr[u].add3; //一般值没啥说道，直接传递给左右儿子就行

    tr[ls].mi == mi ? k1 = tr[u].add1 : k1 = tr[u].add3; //左儿子中有最小值，k1=tr[u].add1,否则k1=tr[u].add3
    tr[ls].mx == mx ? k2 = tr[u].add2 : k2 = tr[u].add3; //左儿子中有最大值，k2=tr[u].add2,否则k1=tr[u].add3
    update(ls, k1, k2, k3);                              //标签纠正好了，可以更新左儿子了

    //复读机
    tr[rs].mi == mi ? k1 = tr[u].add1 : k1 = tr[u].add3; //右儿子中有最小值，k1=tr[u].add1,否则k1=tr[u].add3
    tr[rs].mx == mx ? k2 = tr[u].add2 : k2 = tr[u].add3; //右儿子中有最大值，k2=tr[u].add2,否则k1=tr[u].add3
    update(rs, k1, k2, k3);                              //标签纠正好了，可以更新右儿子了

    //传递完了add lzay tag,重置为0，表示没的传了
    tr[u].add1 = tr[u].add2 = tr[u].add3 = 0;
}

//构建线段树
void build(int u, int l, int r) {
    tr[u].l = l, tr[u].r = r;
    if (l == r) {
        tr[u].mx = tr[u].mi = tr[u].sum = read(); //最大值，最小值，区间和
        tr[u].cx = tr[u].ci = 1;                  //最大值个数=最小值个数=1
        tr[u].sx = -INF;                          //没有次大值
        tr[u].si = INF;                           //没有次小值
        return;
    }
    int mid = (l + r) >> 1;
    build(ls, l, mid), build(rs, mid + 1, r);
    pushup(u);
}

//区间加
void modify_add(int u, int l, int r, int v) {
    if (tr[u].l > r || tr[u].r < l) return; //无交集，直接返回
    if (tr[u].l >= l && tr[u].r <= r) {     //区间完整命中
        update(u, v, v, v);                 //更新统计信息,最大值，最小值，一般值 都是一样的需要+v
        return;
    }
    //① 未完全命中，存在部分交集，先将以前的tag传递给左右儿子，再开始递归左右儿子
    pushdown(u);
    //② 分裂处理左右儿子
    modify_add(ls, l, r, v), modify_add(rs, l, r, v);
    //③ 因为子节点信息更新了，需要向上汇集统计信息
    pushup(u);
}

//区间修改最大值
void modify_max(int u, int l, int r, int v) {
    if (tr[u].l > r || tr[u].r < l || v <= tr[u].mi) return; //如果区间无交集，或者，要更新的最大值还没有人家区间的最小值大，没有更新的必要
    if (l <= tr[u].l && tr[u].r <= r && v < tr[u].si) {      //如果区间完全命中，并且，v小于区间次小值，那么只能更新最小值
        update(u, v - tr[u].mi, 0, 0);
        //最小值被更新的大小=为add(v-tr[u].mi),如此，成功将设置为最小值操作转化为加法标签操作
        return;
    }
    //① 未完全命中，存在部分交集，先将以前的tag传递给左右儿子，再开始递归左右儿子
    pushdown(u);
    //② 分裂处理左右儿子
    modify_max(ls, l, r, v), modify_max(rs, l, r, v);
    //③ 因为子节点信息更新了，需要向上汇集统计信息
    pushup(u);
}

//区间修改最小值
void modify_min(int u, int l, int r, int v) {
    if (tr[u].l > r || tr[u].r < l || v >= tr[u].mx) return; //如果区间无交集，或者，要更新的最小值还比人家区间的最大值还大，没有更新的必要
    if (l <= tr[u].l && tr[u].r <= r && v > tr[u].sx) {      //如果区间完全命中，并且，v大于区间次大值，那么只能更新最大值
        update(u, 0, v - tr[u].mx, 0);
        //最大值被更新的大小=为add(v-tr[u].mx),如此，成功将设置为最大值操作转化为加法标签操作
        return;
    }
    //① 未完全命中，存在部分交集，先将以前的tag传递给左右儿子，再开始递归左右儿子
    pushdown(u);
    //② 分裂处理左右儿子
    modify_min(ls, l, r, v), modify_min(rs, l, r, v);
    //③ 因为子节点信息更新了，需要向上汇集统计信息
    pushup(u);
}

//查询区间和
LL query_sum(int u, int l, int r) {
    if (tr[u].l > r || tr[u].r < l) return 0;
    if (l <= tr[u].l && tr[u].r <= r) return tr[u].sum;
    pushdown(u);
    return query_sum(ls, l, r) + query_sum(rs, l, r);
}

//区间最大值
int query_max(int u, int l, int r) {
    if (tr[u].l > r || tr[u].r < l) return -INF;
    if (l <= tr[u].l && tr[u].r <= r) return tr[u].mx;
    pushdown(u);
    return max(query_max(ls, l, r), query_max(rs, l, r));
}

//区间最小值
int query_min(int u, int l, int r) {
    if (tr[u].l > r || tr[u].r < l) return INF;
    if (l <= tr[u].l && tr[u].r <= r) return tr[u].mi;
    pushdown(u);
    return min(query_min(ls, l, r), query_min(rs, l, r));
}

int main() {
//文件输入输出
#ifndef ONLINE_JUDGE
    freopen("BZOJ4695.in", "r", stdin);
#endif
    n = read();
    build(1, 1, n);

    m = read();
    while (m--) {
        int op = read(), l = read(), r = read(), x;
        if (op == 1) x = read(), modify_add(1, l, r, x);   //区间加
        if (op == 2) x = read(), modify_max(1, l, r, x);   //区间修改max运算
        if (op == 3) x = read(), modify_min(1, l, r, x);   //区间修改min运算
        if (op == 4) printf("%lld\n", query_sum(1, l, r)); //查询区间和
        if (op == 5) printf("%d\n", query_max(1, l, r));   //查询区间最大值
        if (op == 6) printf("%d\n", query_min(1, l, r));   //查询区间最小值
    }
    return 0;
}