concept for reducing the number of operations

Author: lrvideckis

library/trees/linear_lca.hpp

@@ -12,39 +12,50 @@
 //! @space O(n)
 struct linear_lca {
   struct node {
-    int d, label, asc;
+    int pos, label, asc;
   };
   vector<node> t;
   vi head;
-  linear_lca(const auto& adj):
-    t(sz(adj)), head(sz(t) + 1) {
-    vector<pii> order;
-    auto dfs = [&](auto&& self, int v, int p) -> void {
-      order.emplace_back(v, p);
-      t[v].label = sz(order);
-      for (int u : adj[v])
-        if (u != p) {
-          t[u].d = 1 + t[v].d;
+  linear_lca(auto& adj) : t(sz(adj)), head(sz(t) + 1) {
+    {
+      int Time = 1;
+      auto dfs = [&](auto&& self, int v, int p) -> void {
+        t[v].label = Time++;
+        for (int& u : adj[v]) {
+          assert(u != p);
           self(self, u, v);
           head[t[u].label] = v;
-          if ((t[u].label & -t[u].label) >
-            (t[v].label & -t[v].label))
+          if ((t[u].label & -t[u].label) > (t[v].label & -t[v].label)) {
             t[v].label = t[u].label;
+            swap(u, adj[v][0]);
+          }
         }
-    };
-    rep(i, 0, sz(t)) if (t[i].d == 0) dfs(dfs, i, i);
-    for (auto [v, p] : order)
-      t[v].asc = t[p].asc | (t[v].label & -t[v].label);
+      };
+      dfs(dfs, 0, 0);
+    }
+    {
+      int Time = 0;
+      auto dfs = [&](auto&& self, int v, int p) -> void {
+        t[v].asc = t[p].asc | (t[v].label & -t[v].label);
+        t[v].pos = Time++;
+        for (int u : adj[v])
+          if (u != p) {
+            self(self, u, v);
+          }
+      };
+      dfs(dfs, 0, 0);
+    }
   }
   int lca(int u, int v) {
+    if (t[u].pos > t[v].pos) swap(u, v);
     if (unsigned j = t[u].label ^ t[v].label; j) {
       j = t[u].asc & t[v].asc & -bit_floor(j);
-      if (unsigned k = t[u].asc ^ j; k)
-        k = bit_floor(k), u = head[(t[u].label & -k) | k];
+      //if (unsigned k = t[u].asc ^ j; k)
+        //k = bit_floor(k), u = head[(t[u].label & -k) | k];
       if (unsigned k = t[v].asc ^ j; k)
         k = bit_floor(k), v = head[(t[v].label & -k) | k];
     }
-    return t[u].d < t[v].d ? u : v;
+    return t[u].pos < t[v].pos ? u : v;
   }
-#include "extra_members/dist_edges.hpp"
+//#include "extra_members/dist_edges.hpp"
 };

tests/library_checker_aizu_tests/trees/lca_all_methods_lib_checker.test.cpp

@@ -17,8 +17,8 @@ int main() {
   }
   tree_lift tl(adj);
   LCA lc(adj);
-  linear_lca lin_lca(adj);
   compress_tree_asserts(adj, lc);
+  linear_lca lin_lca(adj);
   for (int i = 0; i < n; i++) {
     assert(tl.lca(i, i) == i);
     assert(lc.lca(i, i) == i);