golf pq of updates

Author: lrvideckis

library/data_structures_[l,r)/uncommon/priority_queue_of_updates.hpp

@@ -1,65 +1,44 @@
 #pragma once
 //! https://codeforces.com/blog/entry/111117
 //! @code
-//!   // DS = any struct with member functions join, undo
-//!   DS ds;
-//!   // int = argument type of DS::join
-//!   pq_updates<DS, int> pq(ds);
-//!   pq.push_update(val, pri);
-//!   pq.pop_update();
+//!   vector<pair<int, int>> updates;
+//!   pq_updates pq([&](int update_id) {},
+//!                 [&](int t) {});
+//!   updates.push_back({u, v});
+//!   pq.push(pri, ssize(updates) - 1);
 //! @endcode
-//! @time n interweaved calls to pop_update, push_update
-//! take O(T(n)*nlogn) where O(T(n)) = time complexity of
-//! DS::join and DS::undo
-//! @space n interweaved calls to pop_update, push_update
-//! uses O(n) space
-template<class DS, class... ARGS> struct pq_updates {
-  DS ds;
-  using upd =
-    pair<tuple<ARGS...>, map<int, int>::iterator>;
-  vector<upd> upd_st;
-  map<int, int>
-    mp; //!< priority -> index into update stack
-  //! @param ds any data structure with member functions
-  //! `join` and `undo`
-  pq_updates(DS& ds): ds(ds) {}
-  //! Remove update with max priority
-  //! @time O(log(n) + k*T(n)) where k = # of pops off the
-  //! update stack
-  //! @space a temporary vector of size O(k) is used to
-  //! store popped updates; size of `upd_st`, `mp` member
-  //! variables decreases by 1
-  void pop_update() {
+//! @time O(n log n)
+//! @space O(n)
+template<class F, class G> struct pq_updates {
+  F update;
+  G rollback;
+  using upd = pair<multimap<int, int>::iterator, int>;
+  vector<upd> st;
+  multimap<int, int> mp;
+  pq_updates(F update, G rollback):
+    update(update), rollback(rollback) {}
+  void pop() {
     vector<upd> extra;
-    int idx = sz(upd_st) - 1, lowest_pri = INT_MAX;
-    for (auto it = rbegin(mp);
-      2 * sz(extra) < sz(upd_st) - idx; it++) {
-      auto [pri, idx_sk] = *it;
-      extra.push_back(upd_st[idx_sk]);
-      idx = min(idx, idx_sk), lowest_pri = pri;
+    int t = sz(st) - 1;
+    for (auto it = rbegin(mp); 2 * sz(extra) < sz(st) - t;
+      it++) {
+      extra.push_back(st[it->second]);
+      t = min(t, it->second);
+      it->second = -1;
     }
-    auto it = remove_if(idx + all(upd_st), [&](auto& cur) {
-      return cur.second->first >= lowest_pri;
-    });
-    ranges::reverse_copy(extra, it);
-    rep(i, idx, sz(upd_st)) ds.undo();
-    upd_st.pop_back();
-    mp.erase(prev(end(mp)));
-    rep(i, idx, sz(upd_st)) {
-      apply(&DS::join,
-        tuple_cat(make_tuple(&ds), upd_st[i].first));
-      upd_st[i].second->second = i;
+    rollback(t);
+    ranges::reverse_copy(extra,
+      remove_if(t + all(st),
+        [](upd& x) { return x.first->second == -1; }));
+    st.pop_back();
+    mp.erase(extra[0].first);
+    rep(i, t, sz(st)) {
+      update(st[i].second);
+      st[i].first->second = i;
     }
   }
-  //! @param args arguments to DS::join
-  //! @param pri must be distinct, can be negative
-  //! @time O(log(n) + T(n))
-  //! @space an new update is allocated, inserted into
-  //! `upd_st`, `mp` member variables
-  void push_update(ARGS... args, int pri) {
-    ds.join(args...);
-    auto [it, ins] = mp.emplace(pri, sz(upd_st));
-    assert(ins);
-    upd_st.emplace_back(make_tuple(args...), it);
+  void push(int pri, int update_id) {
+    update(update_id);
+    st.emplace_back(mp.emplace(pri, sz(st)), update_id);
   }
 };

tests/library_checker_aizu_tests/data_structures/pq_ds_undo_sliding_window.test.cpp

@@ -11,7 +11,7 @@ struct stack_with_get_max {
     st.emplace_back(val,
       empty(st) ? val : min(val, st.back().second));
   }
-  void undo() { st.pop_back(); }
+  void rollback(int siz) { st.resize(siz); }
   int get_max() const { return st.back().second; }
 };
 int main() {
@@ -20,15 +20,21 @@ int main() {
   cin >> n >> l;
   vi arr(n);
   rep(i, 0, n) cin >> arr[i];
+  vector<int> updates;
   stack_with_get_max stm;
-  pq_updates<stack_with_get_max, int> pq(stm);
+  pq_updates pq([&](int id) { stm.join(updates[id]); },
+    [&](int t) { stm.rollback(t); });
   int pri = (n - l) / 2;
-  rep(i, 0, l) pq.push_update(arr[i], pri--);
-  cout << pq.ds.get_max();
+  rep(i, 0, l) {
+    updates.push_back(arr[i]);
+    pq.push(pri--, updates.size() - 1);
+  }
+  cout << stm.get_max();
   rep(i, l, n) {
-    pq.push_update(arr[i], pri--);
-    pq.pop_update();
-    cout << " " << pq.ds.get_max();
+    updates.push_back(arr[i]);
+    pq.push(pri--, updates.size() - 1);
+    pq.pop();
+    cout << " " << stm.get_max();
   }
   cout << '\n';
   return 0;

tests/library_checker_aizu_tests/handmade_tests/pq_updates.test.cpp

@@ -0,0 +1,50 @@
+#define PROBLEM \
+  "https://onlinejudge.u-aizu.ac.jp/problems/ITP1_1_A"
+#include "../template.hpp"
+#include "../../../library/contest/random.hpp"
+#include "../../../library/data_structures_[l,r)/uncommon/priority_queue_of_updates.hpp"
+int main() {
+  for (int max_capacity = 1; max_capacity <= 50;
+    max_capacity++) {
+    rep(pattern, 0, 5) {
+      vi ds_history;
+      auto update = [&](int id) {
+        ds_history.push_back(id);
+      };
+      auto rollback = [&](int t) { ds_history.resize(t); };
+      pq_updates solver(update, rollback);
+      map<pair<int, int>, int> naive_mp;
+      int upd_id_counter = 0;
+      rep(op, 0, 200) {
+        bool do_push =
+          naive_mp.empty() ||
+          (rnd(0, 1) == 0 && sz(naive_mp) < max_capacity);
+        if (do_push) {
+          int upd_id = ++upd_id_counter;
+          int pri;
+          if (pattern == 0) pri = rnd(1, 5);
+          else if (pattern == 1) pri = op / 5;
+          else if (pattern == 2) pri = 10;
+          else if (pattern == 3)
+            pri = (op % 2 == 0) ? 1 : 2;
+          else pri = rnd(1, 100);
+          solver.push(pri, upd_id);
+          naive_mp[{pri, upd_id}] = upd_id;
+        } else {
+          solver.pop();
+          auto max_it = prev(end(naive_mp));
+          naive_mp.erase(max_it);
+        }
+        vi active_ds = ds_history;
+        sort(all(active_ds));
+        vi active_naive;
+        for (auto [key, id] : naive_mp)
+          active_naive.push_back(id);
+        sort(all(active_naive));
+        assert(active_ds == active_naive);
+      }
+    }
+  }
+  cout << "Hello World\n";
+  return 0;
+}