update tests

Author: lrvideckis

tests/library_checker_aizu_tests/data_structures/dsu_restorable.test.cpp

@@ -2,7 +2,7 @@
   "https://judge.yosupo.jp/problem/two_edge_connected_components"
 #include "../template.hpp"
 #include "../../../library/graphs/uncommon/bridge_tree.hpp"
-#include "../../../library/dsu/dsu_restorable.hpp"
+#include "../../../library/dsu/dsu.hpp"
 int main() {
   cin.tie(0)->sync_with_stdio(0);
   int n, m;
@@ -33,7 +33,7 @@ int main() {
       accumulate(begin(is_br), end(is_br), 0);
     assert(sum_deg % 2 == 0 && sum_deg / 2 == cnt_bridges);
   }
-  dsu_restorable dsu(n);
+  DSU dsu(n);
   int num_sets_dsu = n;
   for (int i = 0; i < m; i++) {
     if (!is_br[i]) {
@@ -45,12 +45,11 @@ int main() {
   for (int i = 0; i < m; i++) {
     if (is_br[i]) {
       auto [u, v] = edges[i];
-      bool same_set = dsu.same_set(u, v);
-      assert(!same_set);
+      assert(dsu.f(u) != dsu.f(v));
     }
   }
   for (int i = 0; i < n; i++) {
-    int par_of_cc = dsu.find(i);
+    int par_of_cc = dsu.f(i);
     assert(br_id[i] == br_id[par_of_cc]);
   }
   for (int i = 0; i < m; i++) {

tests/library_checker_aizu_tests/data_structures/dsu_segtree_undo_trick.test.cpp

@@ -2,11 +2,11 @@
   "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP1_1_A"
 #include "../template.hpp"
 #include "../../../library/contest/random.hpp"
-#include "../../../library/dsu/dsu_restorable.hpp"
+#include "../../../library/dsu/dsu.hpp"
 int main() {
   cin.tie(0)->sync_with_stdio(0);
   for (int n = 1; n < 100; n++) {
-    dsu_restorable dsu(n);
+    DSU dsu(n);
     vector<vector<int>> adj(n);
     vector<pair<int, int>> edge_st;
     for (int q = 0; q < 100; q++) {

tests/library_checker_aizu_tests/data_structures/pq_ds_undo_with_dsu.test.cpp

@@ -0,0 +1,67 @@
+#define PROBLEM \
+  "https://onlinejudge.u-aizu.ac.jp/problems/ITP1_1_A"
+#include "../template.hpp"
+#include "../../../library/data_structures_[l,r)/seg_tree_midpoint.hpp"
+int main() {
+  cin.tie(0)->sync_with_stdio(0);
+  for (int n = 1; n < 5000; n++) {
+    auto dfs = [&](auto&& self, int tl, int tr,
+                 int v) -> void {
+      assert((v >= n) == ((tr - tl) == 1));
+      if (v >= n) { // leaf node
+        const int depth_leaf = __lg(v),
+                  max_depth = __lg(2 * n - 1);
+        if (tl == 0) { // left-most leaf
+          assert(v == (1 << max_depth));
+          assert(depth_leaf == max_depth);
+        }
+        assert(n <= v && v < 2 * n);
+        assert(depth_leaf == max_depth ||
+          depth_leaf == max_depth - 1);
+        if ((n & (n - 1)) == 0)
+          assert(depth_leaf == max_depth);
+      } else {
+        assert(1 <= v && v < n);
+        if (((tr - tl) & (tr - tl - 1)) == 0)
+          assert(split(tl, tr) == (tl + tr) / 2);
+        {
+          int pow_2 = 1 << __lg(tr - tl);
+          if (tl + pow_2 < tr - pow_2 / 2) {
+            assert(pow_2 != tr - tl);
+            assert(pow_2 / 2 < tr - tl - pow_2 &&
+              tr - tl - pow_2 < pow_2);
+            assert(pow_2 <= 2 * (tr - tl - pow_2) - 1 &&
+              2 * (tr - tl - pow_2) - 1 < 2 * pow_2 - 1);
+            assert(__lg(pow_2) ==
+                __lg(2 * ((tr - tl) - pow_2) - 1) &&
+              __lg(pow_2) == __lg(2 * pow_2 - 1));
+          } else if (pow_2 < tr - tl) {
+            assert(pow_2 / 2 < tr - tl - pow_2 / 2 &&
+              tr - tl - pow_2 / 2 <= pow_2);
+            assert(
+              pow_2 <= 2 * ((tr - tl) - pow_2 / 2) - 1 &&
+              2 * ((tr - tl) - pow_2 / 2) - 1 <=
+                2 * pow_2 - 1);
+            assert(__lg(2 * (tr - tl - pow_2 / 2) - 1) ==
+              __lg(2 * pow_2 - 1));
+            assert(__lg(2 * ((tr - tl) - pow_2 / 2) - 1) ==
+              __lg(pow_2));
+            assert(__lg(pow_2) ==
+              1 + __lg(2 * (pow_2 / 2) - 1));
+          }
+        }
+        int tm = split(tl, tr);
+        // in particular, this tests that split works with
+        // negatives
+        assert(split(tl - 1234, tr - 1234) == tm - 1234);
+        assert(split(tl - 1, tr - 1) == tm - 1);
+        assert(split(tl + 50, tr + 50) == tm + 50);
+        self(self, tl, tm, 2 * v);
+        self(self, tm, tr, 2 * v + 1);
+      }
+    };
+    dfs(dfs, 0, n, 1);
+  }
+  cout << "Hello World\n";
+  return 0;
+}