no longer have node structs

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/extra_members/compress_tree.hpp

@@ -11,7 +11,7 @@
 //! @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)

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/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/tree_lift/kth_path.hpp

@@ -7,42 +7,34 @@
 //!   }
 //!   vector<basic_string<int>> adj(n);
 //!   tree_lift tree_l(adj);
-//!   int kth_p = tree_l.kth_par(v, k);
+//!   tree_l.kth_par(v, k); // k edges up from v
 //! @endcode
-//! kth_p = a node k edges up from v
 //! @time O(n + q log n)
 //! @space O(n)
 struct tree_lift {
-  struct node {
-    int d, p = -1, j = -1;
-  };
-  vector<node> t;
-  tree_lift(const auto& adj): t(sz(adj)) {
+  vi d, p, j;
+  tree_lift(const auto& adj): d(sz(adj)), p(d), j(d) {
     auto dfs = [&](auto&& self, int v) -> void {
-      int jump =
-        (t[v].d + t[t[t[v].j].j].d == 2 * t[t[v].j].d)
-        ? t[t[v].j].j
-        : v;
+      int up =
+        d[v] + d[j[j[v]]] == 2 * d[j[v]] ? j[j[v]] : v;
       for (int u : adj[v])
-        if (u != t[v].p)
-          t[u].d = t[t[u].p = v].d + 1, t[u].j = jump,
-          self(self, u);
+        if (u != p[v])
+          d[u] = d[p[u] = v] + 1, j[u] = up, self(self, u);
     };
-    rep(i, 0, sz(t)) if (t[i].j == -1) t[i].j = i,
-                                       dfs(dfs, i);
+    dfs(dfs, 0);
   }
   int kth_par(int v, int k) {
-    int anc_d = t[v].d - k;
-    while (t[v].d > anc_d)
-      v = t[t[v].j].d >= anc_d ? t[v].j : t[v].p;
+    int anc_d = d[v] - k;
+    while (d[v] > anc_d)
+      v = d[j[v]] >= anc_d ? j[v] : p[v];
     return v;
   }
   int lca(int u, int v) {
-    if (t[u].d < t[v].d) swap(u, v);
-    u = kth_par(u, t[u].d - t[v].d);
+    if (d[u] < d[v]) swap(u, v);
+    u = kth_par(u, d[u] - d[v]);
     while (u != v)
-      if (t[u].j != t[v].j) u = t[u].j, v = t[v].j;
-      else u = t[u].p, v = t[v].p;
+      if (j[u] != j[v]) u = j[u], v = j[v];
+      else u = p[u], v = p[v];
     return u;
   }
 #include "../extra_members/dist_edges.hpp"