saving progress

Author: lrvideckis

library/trees/ladder_decomposition/linear_kth_par.hpp

@@ -9,18 +9,18 @@
 //! @space O(n)
 struct linear_kth_par {
   struct node {
-    int d, p = -1, idx, dl;
-    vi lad;
+    int d, p = -1, idx, dl, tin;
   };
   vector<node> t;
   vector<pii> j;
-  linear_kth_par(const vector<vi>& adj):
-    t(sz(adj)), j(2 * sz(t)) {
+  vi lad;
+  vi head;
+  linear_kth_par(const vector<vi>& adj) : t(sz(adj)), j(2 * sz(t)), head(sz(adj)) {
     vi st;
     int pos = 1;
     auto add_j = [&]() -> void {
       j[pos] = {st[max(0, sz(st) - 1 - 2 * (pos & -pos))],
-        st[max(0, sz(st) - 1 - 4 * (pos & -pos))]};
+                st[max(0, sz(st) - 1 - 4 * (pos & -pos))]};
       pos++;
     };
     auto dfs = [&](auto&& self, int v) -> void {
@@ -40,26 +40,28 @@ struct linear_kth_par {
     rep(i, 0, sz(t)) {
       if (t[i].p == -1) dfs(dfs, i);
       if (t[i].p == -1 || t[t[i].p].dl != t[i].dl) {
-        int leaf = t[i].dl;
-        vi& lad = t[leaf].lad;
-        lad.resize(
-          min((t[leaf].d - t[i].d) * 2, t[leaf].d + 1),
-          leaf);
-        rep(k, 1, sz(lad)) lad[k] = t[lad[k - 1]].p;
+        head[t[i].dl] = i;
+        for (int u = i, v = t[i].dl; u != -1 && v != i; u = t[u].p, v = t[v].p)
+          t[v].tin = sz(lad), lad.push_back(u);
       }
     }
   }
   int kth_par(int v, int k) {
     assert(0 <= k && k <= t[v].d);
     switch (k) {
-    case 0: return v;
-    case 1: return t[v].p;
-    case 2: return t[t[v].p].p;
-    default:
-      int i = 1 << __lg(k / 3);
-      auto [j1, j2] = j[(t[v].idx & -i) | i];
-      int leaf = t[t[v].d - t[j2].d <= k ? j2 : j1].dl;
-      return t[leaf].lad[k + t[leaf].d - t[v].d];
+      case 0: return v;
+      case 1: return t[v].p;
+      case 2: return t[t[v].p].p;
+      default:
+        int i = 1 << __lg(k / 3);
+        auto [j1, j2] = j[(t[v].idx & -i) | i];
+        int up = t[v].d - t[j2].d <= k ? j2 : j1;
+        int leaf = t[up].dl;
+        assert(t[head[leaf]].d >= t[v].d - k);
+        int res = lad[t[leaf].tin + t[head[leaf]].d - (t[v].d - k)];
+        // cerr << "hi: " << t[res].d << ' ' << t[v].d - k << endl;
+        return res;
+        // return t[leaf].lad[k + t[leaf].d - t[v].d];
     }
   }
 };