NC14402 求最大值

题目链接

题目

题目描述

给出一个序列，你的任务是求每次操作之后序列中 （a[j]-a[i]）/（j-i）【1<=i<j<=n】的最大值。

操作次数有Q次，每次操作需要将位子p处的数字变成y.

输入描述

本题包含多组输入，每组输入第一行一个数字n，表示序列的长度。
然后接下来一行输入n个数，表示原先序列的样子。
再接下来一行一个数字Q，表示需要进行的操作的次数。
最后Q行每行两个元素p，y，表示本操作需要将位子p处的数字变成y.
数据范围：
3<=n<=200000
1<=Q<=200000
-1000000000<=a[i]<=1000000000

输出描述

每组数据输出Q行，每行输出一个浮点数，保留两位小数，表示所求的最大值。

示例1

输入

5
2 4 6 8 10
2
2 5
4 9

输出

3.00
3.00

说明

第一次操作之后的序列变成：2 5 6 8 10
第二次操作之后的序列变成：2 5 6 9 10

备注

输入只有整形

题解

知识点：线段树，贪心。

一个巧妙的贪心，原式可以理解为两点的斜率，现在将点顺序画在坐标系上，注意到选择相邻两点的斜率一定比不相邻两点更优，因此我们直接考虑相邻两点的斜率即可。

相邻两点斜率就等于 $a[j] - a[i]$ ，我们用线段树维护差分数组即可。

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

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
struct T {
    int mx;
    static T e() { return { (int)-2e9 }; }
    friend T operator+(const T &a, const T &b) { return { max(a.mx,b.mx) }; }
};
struct F {
    int upd;
    T operator()(const T &x) { return { upd }; }
};
 
template<class T, class F>
class SegmentTree {
    int n;
    vector<T> node;
 
    void update(int rt, int l, int r, int x, F f) {
        if (r < x || x < l) return;
        if (l == r) return node[rt] = f(node[rt]), void();
        int mid = l + r >> 1;
        update(rt << 1, l, mid, x, f);
        update(rt << 1 | 1, mid + 1, r, x, 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::e();
        if (x <= l && r <= y) return node[rt];
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    }
 
public:
    SegmentTree(int _n = 0) { init(_n); }
    SegmentTree(const vector<T> &src) { init(src); }
 
    void init(int _n) {
        n = _n;
        node.assign(n << 2, T::e());
    }
    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, F f) { update(1, 1, n, x, f); }
 
    T query(int x, int y) { return query(1, 1, n, x, y); }
};
 
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    while (cin >> n) {
        vector<int> a(n + 1);
        for (int i = 1;i <= n;i++) cin >> a[i];
 
        vector<T> a_src(n);
        for (int i = 1;i <= n - 1;i++) a_src[i] = { a[i + 1] - a[i] };
        SegmentTree<T, F> sgt(a_src);
 
        int m;
        cin >> m;
        while (m--) {
            int p, y;
            cin >> p >> y;
            a[p] = y;
            if (p >= 2) sgt.update(p - 1, { y - a[p - 1] });
            if (p <= n - 1) sgt.update(p, { a[p + 1] - y });
            cout << sgt.query(1, n - 1).mx << ".00" << '\n';
        }
    }
    return 0;
}