No more struct node (#151)

* no longer have node structs

* fix compile error

* fix another compile error

* fixed

* assume tree, not forest

* fix another test

* fix shadow warning

* rename test now that it's not a forest

* add extra member to linear lca

Author: lrvideckis

library/data_structures/dsu/dsu_bipartite.hpp

@@ -4,37 +4,33 @@
 //! bipartite check
 struct dsu_bipartite {
   int num_sets;
-  struct node {
-    int p = -1;
-    bool is_bi = 1, parity;
-  };
-  vector<node> t;
-  dsu_bipartite(int n): num_sets(n), t(n) {}
+  vi p, is_bi, parity;
+  dsu_bipartite(int n):
+    num_sets(n), p(n, -1), is_bi(n, 1), parity(n) {}
   int find(int v) {
-    if (t[v].p < 0) return v;
-    int root = find(t[v].p);
-    t[v].parity ^= t[t[v].p].parity;
-    return t[v].p = root;
+    if (p[v] < 0) return v;
+    int root = find(p[v]);
+    parity[v] ^= parity[p[v]];
+    return p[v] = root;
   }
   bool join(int u, int v) {
     int root_u = find(u), root_v = find(v);
     if (root_u == root_v) {
-      if (t[u].parity == t[v].parity) t[root_u].is_bi = 0;
+      if (parity[u] == parity[v]) is_bi[root_u] = 0;
       return 0;
     }
-    if (t[root_u].p > t[root_v].p) {
+    if (p[root_u] > p[root_v]) {
       swap(u, v);
       swap(root_u, root_v);
     }
-    t[root_u].is_bi &= t[root_v].is_bi;
-    t[root_v].parity = t[v].parity ^ 1 ^ t[u].parity;
-    t[root_u].p += t[root_v].p, t[root_v].p = root_u,
-                                num_sets--;
+    is_bi[root_u] &= is_bi[root_v];
+    parity[root_v] = parity[v] ^ 1 ^ parity[u];
+    p[root_u] += p[root_v], p[root_v] = root_u, num_sets--;
     return 1;
   }
-  int size(int v) { return -t[find(v)].p; }
+  int size(int v) { return -p[find(v)]; }
   bool same_set(int u, int v) {
     return find(u) == find(v);
   }
-  bool is_bipartite(int v) { return t[find(v)].is_bi; }
+  bool is_bipartite(int v) { return is_bi[find(v)]; }
 };

library/trees/centroid_decomp.hpp

@@ -18,7 +18,7 @@ template<class F, class G> struct centroid {
   vi siz;
   centroid(const G& adj, F f):
     adj(adj), f(f), siz(sz(adj), -1) {
-    rep(i, 0, sz(adj)) if (siz[i] == -1) dfs(i, -1);
+    dfs(0, -1);
   }
   void calc_sz(int v, int p) {
     siz[v] = 1;

library/trees/extra_members/compress_tree.hpp

@@ -11,10 +11,10 @@
 //! @time O(|subset| log |subset|)
 //! @space O(|subset|)
 array<vi, 2> compress_tree(vi subset) {
-  auto proj = [&](int v) { return t[v].in; };
+  auto proj = [&](int v) { return in[v]; };
   ranges::sort(subset, {}, proj);
-  int siz = sz(subset);
-  rep(i, 1, siz)
+  int len = sz(subset);
+  rep(i, 1, len)
     subset.push_back(lca(subset[i - 1], subset[i]));
   ranges::sort(subset, {}, proj);
   subset.erase(unique(all(subset)), end(subset));

library/trees/extra_members/dist_edges.hpp

@@ -1,3 +1,3 @@
-int dist_edges(int u, int v) {
-  return t[u].d + t[v].d - 2 * t[lca(u, v)].d;
+int dist(int u, int v) {
+  return d[u] + d[v] - 2 * d[lca(u, v)];
 }

library/trees/extra_members/in_subtree.hpp

@@ -1,5 +1,4 @@
 //! returns 1 if v is in u's subtree
 bool in_subtree(int u, int v) {
-  return t[u].in <= t[v].in &&
-    t[v].in < t[u].in + t[u].sub_sz;
+  return in[u] <= in[v] && in[v] < in[u] + siz[u];
 }

library/trees/ladder_decomposition/ladder_decomposition.hpp

@@ -5,37 +5,36 @@
 //! @code
 //!   ladder ld(adj);
 //!   // KACTL functions
-//!   int kth_par = jmp(ld.b_tbl, v, k);
-//!   int curr_lca = lca(ld.b_tbl, ld.d, u, v);
+//!   int kth_par = jmp(ld.jmp, v, k);
+//!   int curr_lca = lca(ld.jmp, ld.d, u, v);
 //! @endcode
 struct ladder {
   int n;
-  vector<vi> b_tbl;
-  vi d, p, dl, idx_l, l_tbl;
+  vi d, p, leaf, idx, lad;
+  vector<vi> jmp;
   //! @param adj forest (rooted or unrooted)
   //! @time O(n log n)
-  //! @space O(n log n) for b_tbl. Everything else is O(n)
+  //! @space O(n log n) for jmp. Everything else is O(n)
   ladder(const auto& adj):
-    n(sz(adj)), d(n), p(n, -1), dl(n), idx_l(n) {
+    n(sz(adj)), d(n), p(n), leaf(n), idx(n), lad(2 * n) {
     auto dfs = [&](auto&& self, int v) -> void {
-      dl[v] = v;
+      leaf[v] = v;
       for (int u : adj[v])
         if (u != p[v]) {
           d[u] = d[p[u] = v] + 1;
           self(self, u);
-          if (d[dl[u]] > d[dl[v]]) dl[v] = dl[u];
+          if (d[leaf[v]] < d[leaf[u]]) leaf[v] = leaf[u];
         }
     };
-    rep(i, 0, n) {
-      if (p[i] == -1) p[i] = i, dfs(dfs, i);
-      if (p[i] == i || dl[p[i]] != dl[i]) {
-        int v = dl[i], len = (d[v] - d[i]) * 2;
-        idx_l[v] = sz(l_tbl) + d[v];
-        for (; v != -1 && len--; v = p[v])
-          l_tbl.push_back(v);
-      }
+    dfs(dfs, 0);
+    int pos = 0;
+    rep(i, 0, n) if (p[i] == i || leaf[p[i]] != leaf[i]) {
+      int l = leaf[i];
+      int len = min((d[l] - d[i]) * 2, d[l] + 1);
+      idx[l] = pos;
+      for (; len--; l = p[l]) lad[pos++] = l;
     }
-    b_tbl = treeJump(p);
+    jmp = treeJump(p);
   }
   //! @param v query node
   //! @param k number of edges
@@ -47,11 +46,11 @@ struct ladder {
     assert(0 <= k && k <= d[v]);
     if (k == 0) return v;
     int bit = __lg(k);
-    v = b_tbl[bit][v], k -= (1 << bit);
-    int l = idx_l[dl[v]] - d[v];
-    assert(l_tbl[l] == v);
-    // subarray [l, l+k] of l_tbl corresponds to the rest
+    v = jmp[bit][v], k -= (1 << bit);
+    int l = idx[leaf[v]] + d[leaf[v]] - d[v];
+    assert(lad[l] == v);
+    // subarray [l, l+k] of lad corresponds to the rest
     // of the jump
-    return l_tbl[l + k];
+    return lad[l + k];
   }
 };

library/trees/lca_rmq/lca_rmq.hpp

@@ -13,29 +13,27 @@
 //! @space O(nlogn)
 // NOLINTNEXTLINE(readability-identifier-naming)
 struct LCA {
-  struct node {
-    int in, sub_sz = 1, d, p = -1;
-  };
-  vector<node> t;
+  int n;
+  vi in, siz, d, p;
   RMQ<int, function<int(int, int)>> rmq = {{}, NULL};
-  LCA(const auto& adj): t(sz(adj)) {
+  LCA(const auto& adj):
+    n(sz(adj)), in(n), siz(n, 1), d(n), p(n) {
     vi order;
     auto dfs = [&](auto&& self, int v) -> void {
-      t[v].in = sz(order), order.push_back(v);
+      in[v] = sz(order), order.push_back(v);
       for (int u : adj[v])
-        if (u != t[v].p)
-          t[u].d = t[t[u].p = v].d + 1, self(self, u),
-          t[v].sub_sz += t[u].sub_sz;
+        if (u != p[v])
+          d[u] = d[p[u] = v] + 1, self(self, u),
+          siz[v] += siz[u];
     };
-    rep(i, 0, sz(t)) if (t[i].p == -1) dfs(dfs, i);
-    rmq = {order, [&](int u, int v) {
-             return t[u].d < t[v].d ? u : v;
-           }};
+    dfs(dfs, 0);
+    rmq = {order,
+      [&](int u, int v) { return d[u] < d[v] ? u : v; }};
   }
   int lca(int u, int v) {
     if (u == v) return u;
-    auto [x, y] = minmax(t[u].in, t[v].in);
-    return t[rmq.query(x + 1, y + 1)].p;
+    auto [x, y] = minmax(in[u], in[v]);
+    return p[rmq.query(x + 1, y + 1)];
   }
 #include "../extra_members/dist_edges.hpp"
 #include "../extra_members/in_subtree.hpp"

library/trees/lca_rmq/next_on_path.hpp

@@ -5,7 +5,6 @@
 //! @space O(1)
 int next_on_path(int u, int v) {
   assert(u != v);
-  return in_subtree(u, v)
-    ? rmq.query(t[u].in + 1, t[v].in + 1)
-    : t[u].p;
+  return in_subtree(u, v) ? rmq.query(in[u] + 1, in[v] + 1)
+                          : p[u];
 }

library/trees/linear_lca.hpp

@@ -41,4 +41,5 @@ struct linear_lca {
     }
     return d[u] < d[v] ? u : v;
   }
+#include "extra_members/dist_edges.hpp"
 };

library/trees/subtree_isomorphism.hpp

@@ -26,6 +26,6 @@ auto subtree_iso(const auto& adj) {
              hashes.try_emplace(ch_ids, sz(hashes))
                .first->second;
   };
-  rep(i, 0, sz(adj)) if (iso_id[i] == -1) dfs(dfs, i, i);
+  dfs(dfs, 0, 0);
   return pair{sz(hashes), iso_id};
 }