题目链接

题目

链接：https://ac.nowcoder.com/acm/problem/54586
来源：牛客网

题目描述

小翔爱玩泰拉瑞亚 。
一天，他碰到了一幅地图。这幅地图可以分为 \(n\) 列，第 \(i\) 列的高度为 \(H_i\) ，他认为这个地图不好看，决定对它进行改造。
小翔又学会了 \(m\) 个魔法，实施第 \(i\) 个魔法可以使地图的第 \(L_i\) 列到第 \(R_i\) 列每一列的高度减少 \(W_i\) ，每个魔法只能实施一次，魔法的区间可能相交或包含。
小翔认为，一幅地图中最高的一列与最低的一列的高度差越大，这幅地图就越美观。

小翔可以选择 \(m\) 个魔法中的任意一些魔法来实施，使得地图尽量美观。但是他不知道该如何选择魔法，于是他找到了你。请你求出所有可行方案中，高度差的最大值。

对于 \(100\%\) 的数据，满足 \(1≤n,m≤200000,-10^9≤H_i≤10_9,1≤W_i≤10^9,1≤L_i≤R_i≤n\) 。

输入描述

输入文件的第一行包含两个整数 \(n,m\) 。
输入的第二行包含 \(n\) 个整数，相邻两数间用一个空格隔开，第 \(i\) 个整数为 \(H_i\) 。
接下来的 \(m\) 行，每行包含 \(3\) 个整数，分别是 \(L_i,R_i,W_i\) ，相邻两数间用一个空格隔开。

输出描述

一行一个整数，表示高度差的最大值。

示例1

输入

3 3
7 -2 -10
1 3 4
3 3 4
1 2 8

输出

21

题解

知识点：线段树，枚举，贪心。

注意到，魔法只会使值降低，因此考虑用在产生最小值点。

我们从左到右枚举每个点作为最小值点，将覆盖到这个点的魔法都用上，显然如果最大值点和最小值点在同一个区间，答案不变；如果不在同一个区间，答案会更优。

同时在离开时，将所有以这个点为右端点的魔法都撤销，因为对将来没有用。

用线段树维护区间加减即可。

时间复杂度 \(O((n+m) \log n)\)

空间复杂度 \(O(n+m)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

template<class T, class F>
class SegmentTreeLazy {
    int n;
    vector<T> node;
    vector<F> lazy;

    void push_down(int rt) {
        node[rt << 1] = lazy[rt](node[rt << 1]);
        lazy[rt << 1] = lazy[rt](lazy[rt << 1]);
        node[rt << 1 | 1] = lazy[rt](node[rt << 1 | 1]);
        lazy[rt << 1 | 1] = lazy[rt](lazy[rt << 1 | 1]);
        lazy[rt] = F();
    }

    void update(int rt, int l, int r, int x, int y, F f) {
        if (r < x || y < l) return;
        if (x <= l && r <= y) return node[rt] = f(node[rt]), lazy[rt] = f(lazy[rt]), void();
        push_down(rt);
        int mid = l + r >> 1;
        update(rt << 1, l, mid, x, y, f);
        update(rt << 1 | 1, mid + 1, r, x, y, f);
        node[rt] = node[rt << 1] + node[rt << 1 | 1];
    }

    T query(int rt, int l, int r, int x, int y) {
        if (r < x || y < l) return T();
        if (x <= l && r <= y) return node[rt];
        push_down(rt);
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    }

public:
    SegmentTreeLazy(int _n = 0) { init(_n); }
    SegmentTreeLazy(const vector<T> &src) { init(src); }

    void init(int _n) {
        n = _n;
        node.assign(n << 2, T());
        lazy.assign(n << 2, F());
    }
    void init(const vector<T> &src) {
        assert(src.size() >= 2);
        init(src.size() - 1);
        function<void(int, int, int)> build = [&](int rt, int l, int r) {
            if (l == r) return node[rt] = src[l], void();
            int mid = l + r >> 1;
            build(rt << 1, l, mid);
            build(rt << 1 | 1, mid + 1, r);
            node[rt] = node[rt << 1] + node[rt << 1 | 1];
        };
        build(1, 1, n);
    }

    void update(int x, int y, F f) { update(1, 1, n, x, y, f); }

    T query(int x, int y) { return query(1, 1, n, x, y); }
};

struct T {
    ll mi = 1e18;
    ll mx = -1e18;
    friend T operator+(const T &a, const T &b) {
        return{
            min(a.mi,b.mi),
            max(a.mx,b.mx)
        };
    }
};

struct F {
    ll add = 0;
    T operator()(const T &x) {
        return{
            x.mi + add,
            x.mx + add
        };
    }
    F operator()(const F &g) { return{ g.add + add }; }
};

vector<pair<int, int>> L[200007], R[200007];

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<T> h(n + 1);
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        h[i] = { x,x };
    }
    for (int i = 1;i <= m;i++) {
        int l, r, w;
        cin >> l >> r >> w;
        L[l].push_back({ r,-w });
        R[r].push_back({ l,w });
    }

    SegmentTreeLazy<T, F> sgt(h);

    ll ans = 0;
    for (int i = 1;i <= n;i++) {
        for (auto [r, w] : L[i])
            sgt.update(i, r, { w });
        auto [mi, mx] = sgt.query(1, n);
        ans = max(ans, mx - mi);
        for (auto [l, w] : R[i]) sgt.update(l, i, { w });
    }
    cout << ans << '\n';
    return 0;
}