add range-chmax-range-sum beats

Author: hitonanode

segmenttree/test/range-chmax-range-sum.yuki3314.test.cpp

@@ -0,0 +1,55 @@
+#define PROBLEM "https://yukicoder.me/problems/no/3314"
+#include "../trees/range-chmax-range-sum.hpp"
+
+#include <iostream>
+#include <tuple>
+#include <vector>
+using namespace std;
+
+using RCRS = RangeChmaxRangeSum<long long, (1LL << 60)>;
+
+int main() {
+    cin.tie(nullptr), ios::sync_with_stdio(false);
+
+    int N, K, Q;
+    cin >> N >> K >> Q;
+
+    RCRS::segtree seg(N);
+    for (int i = 0; i < N; ++i) {
+        int a;
+        cin >> a;
+        seg.set(i, RCRS::Gen(a));
+    }
+
+    vector<tuple<int, int, int>> updates(K);
+    for (auto &[l, r, x] : updates) cin >> l >> r >> x, --l;
+
+    vector<tuple<int, int, long long>> query(Q);
+    for (auto &[l, r, x] : query) cin >> l >> r >> x, --l;
+
+    vector<int> ok(Q, K + 1), ng(Q, -1);
+
+    for (int t = 0; t < 15; ++t) {
+        vector<vector<int>> t2qs(K + 1);
+        for (int q = 0; q < Q; ++q) {
+            const int t = (ok.at(q) + ng.at(q)) / 2;
+            t2qs.at(t).push_back(q);
+        }
+
+        RCRS::segtree tree = seg;
+
+        for (int t = 0; t < K + 1; ++t) {
+            if (t) {
+                auto [l, r, x] = updates.at(t - 1);
+                tree.apply(l, r, RCRS::Chmax(x));
+            }
+
+            for (int q : t2qs.at(t)) {
+                auto [l, r, x] = query.at(q);
+                (tree.prod(l, r).sum >= x ? ok : ng).at(q) = t;
+            }
+        }
+    }
+
+    for (auto t : ok) cout << (t == K + 1 ? -1 : t) << '\n';
+}

segmenttree/trees/range-chmax-range-sum.hpp

@@ -0,0 +1,69 @@
+#pragma once
+#include <algorithm>
+#include <type_traits>
+#include "../acl_beats.hpp"
+
+// Verified: https://yukicoder.me/problems/no/3314
+template <typename Num, Num INF> struct RangeChmaxRangeSum {
+    static_assert(std::is_signed<Num>::value, "Num must be signed");
+
+    struct S {
+        Num lo, lo2, sum;
+        unsigned sz, nlo;
+        bool fail;
+        S() : lo(INF), lo2(INF), sum(0), sz(0), nlo(0), fail(false) {}
+        S(Num x, unsigned sz_ = 1)
+            : lo(x), lo2(INF), sum(Num(x) * sz_), sz(sz_), nlo(sz_), fail(false) {}
+    };
+
+private:
+    using F = Num;
+    RangeChmaxRangeSum() = default;
+
+    static Num second_lowest(Num a, Num a2, Num c, Num c2) noexcept { // a < a2, c < c2
+        return a == c ? std::min(a2, c2) : a2 <= c ? a2 : c2 <= a ? c2 : std::max(a, c);
+    }
+
+    static S op(S l, S r) {
+        S ret;
+        ret.lo = std::min(l.lo, r.lo);
+        ret.lo2 = second_lowest(l.lo, l.lo2, r.lo, r.lo2);
+        ret.sum = l.sum + r.sum, ret.sz = l.sz + r.sz;
+        ret.nlo = l.nlo * (l.lo <= r.lo) + r.nlo * (r.lo <= l.lo);
+        return ret;
+    }
+
+    static S e() { return S{}; }
+
+    static F composition(F fnew, F fold) { return std::max(fnew, fold); }
+
+    static F id() { return -INF; }
+
+    static S mapping(F f, S x) {
+        if (x.sz == 0) return e();
+        if (f < x.lo2) {
+            Num nxt_lo = std::max(x.lo, f);
+            x.sum += (nxt_lo - x.lo) * x.nlo;
+            x.lo = nxt_lo;
+            return x;
+        }
+        x.fail = 1;
+        return x;
+    }
+
+public:
+    static F Chmax(Num x) { return x; }
+
+    static S Gen(Num x, unsigned sz = 1) { return S{x, sz}; }
+
+    using segtree = segtree_beats<S, op, e, F, mapping, composition, id>;
+};
+/* Usage:
+using RCRS = RangeChmaxRangeSum<long long, (1LL << 60)>;
+vector<RCRS::S> init;
+for (auto a : A) init.push_back(RCRS::Gen(a, 1));
+RCRS::segtree tree(init);
+
+tree.apply(l, r, RCRS::Chmax(x));
+auto p = tree.prod(l, r);
+*/