@@ -0,0 +1,53 @@
+#pragma once
+
+template <class T, int B = 8>
+struct PersistentArray {
+  struct Node {
+    T val;
+    Node* child[B] = {};
+    Node() {}
+    Node(const T& v) : val(v) {}
+  };
+  Node* root;
+  vector<Node*> snapshots;
+  PersistentArray() : root(nullptr) {}
+  T get(Node* t, int k) { return k == 0 ? t->val : get(t->child[k % B], k / B); }
+  T get(const int& k) { return get(root, k); }
+  pair<Node*, T*> mutable_get(Node* t, int k) {
+    t = t ? new Node(*t) : new Node();
+    if (k == 0) return {t, &t->val};
+    auto p = mutable_get(t->child[k % B], k / B);
+    t->child[k % B] = p.first;
+    return {t, p.second};
+  }
+  T* mutable_get(const int& k) {
+    auto ret = mutable_get(root, k);
+    root = ret.first;
+    return ret.second;
+  }
+  Node* build(Node* t, const T& val, int k) {
+    if (!t) t = new Node();
+    if (k == 0) {
+      t->val = val;
+      return t;
+    }
+    t->child[k % B] = build(t->child[k % B], val, k / B);
+    return t;
+  }
+  void build(const vector<T>& v) {
+    root = nullptr;
+    for (int i = 0; i < v.size(); i++) root = build(root, v[i], i);
+  }
+  int take_snapshot() {
+    snapshots.push_back(root);
+    return snapshots.size() - 1;
+  }
+  void apply_snapshot(int k) {
+    root = snapshots[k];
+  }
+};
+
+/**
+ * @brief Persistent Array
+ * @docs docs/val-structure/persistent-array.md
+ */
@@ -0,0 +1,90 @@
+#pragma once
+
+template <class T>
+struct SlopeTrick {
+  const T INF = numeric_limits<T>::max() / 3;
+  T min_f;
+  priority_queue<T, vector<T>, less<> > pq_l;
+  priority_queue<T, vector<T>, greater<> > pq_r;
+  T add_l, add_r;
+  SlopeTrick() : min_f(0), add_l(0), add_r(0) {}
+  T get_min() const { return min_f; }
+  pair<T, T> get_min_range() const { return {top_l(), top_r()}; }
+  // f(x) += a
+  void add_const(const T& a) { min_f += a; }
+  // f(x) += max(0, x - a)
+  void add_x_minus_a(const T& a) {
+    min_f += max(T(0), top_l() - a);
+    push_l(a);
+    push_r(pop_l());
+  }
+  // f(x) += max(a - x, 0)
+  void add_a_minus_x(const T& a) {
+    min_f += max(T(0), a - top_r());
+    push_r(a);
+    push_l(pop_r());
+  }
+  // f(x) += abs(x - a)
+  void add_abs(const T& a) {
+    add_a_minus_x(a);
+    add_x_minus_a(a);
+  }
+  // f(x) <- min_{y <= x} f(y)
+  // \/ -> \_
+  void clear_right() {
+    while (!pq_r.empty()) pq_r.pop();
+  }
+  // f(x) <- min_{x <= y} f(y)
+  // \/ -> _/
+  void clear_left() {
+    while (!pq_l.empty()) pq_l.pop();
+  }
+  // f(x) <- min_{x-b <= y <= x-a} f(y)
+  // \/ -> \_/
+  void shift(const T& a, const T& b) {
+    assert(a <= b);
+    add_l += a;
+    add_r += b;
+  }
+
+  T get_destructive(const T& x) {
+    T ret = min_f;
+    while (!pq_l.empty()) ret += max(T(0), pop_l() - x);
+    while (!pq_r.empty()) ret += max(T(0), x - pop_r());
+    return ret;
+  }
+  void merge(SlopeTrick& st) {
+    if (st.size() > size()) {
+      swap(st.pq_l, pq_l);
+      swap(st.pq_r, pq_r);
+      swap(st.add_l, add_l);
+      swap(st.add_r, add_r);
+      swap(st.min_f, min_f);
+    }
+    while (!st.pq_r.empty()) add_x_minus_a(st.pop_r());
+    while (!st.pq_l.empty()) add_a_minus_x(st.pop_l());
+    min_f += st.min_f;
+  }
+
+ private:
+  void push_r(const T& a) { pq_r.push(a - add_r); }
+  T top_r() const { return pq_r.empty() ? INF : pq_r.top() + add_r; }
+  T pop_r() {
+    T val = top_r();
+    if (!pq_r.empty()) pq_r.pop();
+    return val;
+  }
+  void push_l(const T& a) { pq_l.push(a - add_l); }
+  T top_l() const { return pq_l.empty() ? -INF : pq_l.top() + add_l; }
+  T pop_l() {
+    T val = top_l();
+    if (!pq_l.empty()) pq_l.pop();
+    return val;
+  }
+  size_t size() { return pq_l.size() + pq_r.size(); }
+};
+
+/**
+ * @brief Slope Trick
+ * @docs docs/data-structure/slope-trick.md
+ */
@@ -0,0 +1,18 @@
+
+区分線形凸関数を管理するデータ構造．
+
+最小値と，傾きが変わる点を 2 つの priority queue で管理する．
+DP の遷移で $\max(0,x-a)$, $\max(0,a-x)$, $|x-a|$ を足したり，片側の累積 min を取ったりするときに使う．
+
+- `get_min()`：現在の関数の最小値を返す．
+- `get_min_range()`：最小値を取る区間を返す．
+- `add_const(a)`：関数全体に定数 $a$ を足す．
+- `add_x_minus_a(a)`：$\max(0,x-a)$ を足す．
+- `add_a_minus_x(a)`：$\max(0,a-x)$ を足す．
+- `add_abs(a)`：$|x-a|$ を足す．
+- `clear_right()`：$f(x)\gets\min_{y\leq x} f(y)$ とする．
+- `clear_left()`：$f(x)\gets\min_{x\leq y} f(y)$ とする．
+- `shift(a, b)`：$f(x)\gets\min_{x-b\leq y\leq x-a} f(y)$ とする．
+
+https://ei1333.github.io/library/structure/others/slope-trick.hpp.html
+https://maspypy.com/slope-trick-1-%E8%A7%A3%E8%AA%AC%E7%B7%A8
@@ -0,0 +1,13 @@
+# 永続セグメント木
+
+https://info.atcoder.jp/entry/algorithm_lectures/persistent_segment_tree
+
+完全永続的（fully persistent）なセグメント木
+
+https://nyaannyaan.github.io/library/segment-tree/persistent-segment-tree.hpp.html
+
+`set`, `apply`, `get`, `prod` それぞれ以下のように 3 パターンの方法で呼び出せる
+
+- `set(p, v)` : 最新の木で位置 `p` の値を `v` に更新した新たな木の根へのポインタを返す
+- `set(time, p, v)` : 時刻 `time` の木で位置 `p` の値を `v` に更新した新たな木の根へのポインタを返す
+- `set(ptr, p, v)` : 根が `ptr` の木で位置 `p` の値を `v` に更新した新たな木の根へのポインタを返す
@@ -0,0 +1,13 @@
+根付き木上で ancestor, LCA, パス上の jump を処理するデータ構造．
+
+木を与えて `build()` すると，doubling により祖先を管理する．
+コンストラクタに隣接リストを渡した場合は自動で `build()` される．
+
+- `add_edge(u, v)`：無向辺 $uv$ を追加する．
+- `build()`：頂点 $0$ を根として前処理する．
+- `ancestor(x, k)`：頂点 $x$ から $k$ 個親方向へ進んだ頂点を返す．存在しない場合は `-1` を返す．
+- `lca(x, y)`：頂点 $x,y$ の LCA を返す．
+- `dist(x, y)`：頂点 $x,y$ 間の距離を返す．
+- `jump(x, y, k)`：$x$ から $y$ への単純パス上で，$x$ から $k$ 辺進んだ頂点を返す．存在しない場合は `-1` を返す．
+
+前処理は $O(N\log N)$ 時間，クエリは $O(\log N)$ 時間．
@@ -0,0 +1,12 @@
+永続配列．
+
+長さ $N$ の列 $A=(A_0,A_1,\dots,A_{N-1})$ を管理し，更新前の状態を保存して後から戻せるようにする．
+
+- `build(v)`：列 `v` で初期化する．
+- `get(k)`：$A_k$ を取得する．
+- `mutable_get(k)`：$A_k$ へのポインタを取得する．必要な頂点だけコピーされるため，値を代入すると新しい状態が作られる．
+- `take_snapshot()`：現在の状態を保存し，その番号を返す．
+- `apply_snapshot(k)`：`take_snapshot` で保存した状態 `k` に戻す．
+
+内部では添字を $B$ 進数で見た trie を永続化している．
+各操作でコピーされる頂点数は $O(\log_B N)$ 個．
@@ -0,0 +1,15 @@
+#pragma once
+
+struct Graph {
+  int n;
+  vector<vector<int>> g;
+  Graph() : Graph(0) {}
+  Graph(int size) : n(size), g(size) {}
+  void add_edge(int x, int y) {
+    g[x].push_back(y);
+    g[y].push_back(x);
+  }
+  void add_edge_directed(int from, int to) {
+    g[from].push_back(to);
+  }
+};
@@ -0,0 +1,50 @@
+#pragma once
+
+// T[x]/(x^s-r)
+template <class T, int s, auto r>
+struct RootExtension {
+  using F = RootExtension;
+  array<T, s> a;
+  RootExtension() { a.fill(T{}); }
+  RootExtension(const T& x) {
+    a.fill(T{});
+    a[0] = x;
+  }
+  T& operator[](int k) { return a[k]; }
+  F& operator+=(const F& o) {
+    for (int i = 0; i < s; i++) a[i] += o.a[i];
+    return *this;
+  }
+  F& operator-=(const F& o) {
+    for (int i = 0; i < s; i++) a[i] -= o.a[i];
+    return *this;
+  }
+  F& operator*=(const F& o) {
+    const T _r = T{r};
+    array<T, s> b{};
+    for (int i = 0; i < s; i++) {
+      for (int j = 0; j < s - i; j++) b[i + j] += a[i] * o.a[j];
+      for (int j = s - i; j < s; j++) b[i + j - s] += _r * a[i] * o.a[j];
+    }
+    swap(a, b);
+    return *this;
+  }
+  F operator+(const F& o) const { return F(*this) += o; }
+  F operator-(const F& o) const { return F(*this) -= o; }
+  F operator*(const F& o) const { return F(*this) *= o; }
+  F operator-() const {
+    F ret(*this);
+    for (auto& v : ret.a) v = -v;
+    return ret;
+  }
+  F pow(long long n) const {
+    F ret = T{1}, x = *this;
+    while (n) {
+      if (n & 1) ret *= x;
+      x *= x;
+      n >>= 1;
+    }
+    return ret;
+  }
+  T test() const { return T{r}; }
+};
@@ -27,6 +27,24 @@ long long isqrt(long long n) {
   while (x * x > n) x--;
   return x;
 }
+long long floor_root(long long n, int k) {
+  assert(n >= 0);
+  if (n == 0) return 0;
+  assert(k >= 1);
+  if (k == 1) return n;
+  if (k > 64) return 1;
+  long long x = round(pow((long double)n, 1.0L / k));
+  auto check = [&](long long a) {
+    if (a <= 0) return true;
+    __int128_t p = 1;
+    for (int i = 0; i < k; ++i)
+      if ((p *= a) > n) return false;
+    return true;
+  };
+  while (check(x + 1)) x++;
+  while (!check(x)) x--;
+  return x;
+}
 // return g=gcd(a,b)
 // a*x+b*y=g
 // - b!=0 -> 0<=x<|b|/g
 
@@ -30,14 +30,14 @@ struct Matrix {
   Matrix operator-(const Matrix& r) { return Matrix(*this) -= r; }
   Matrix operator*(const Matrix& r) {
     assert(w == r.h);
-    cerr.flush();
     Matrix ret(h, r.w);
     for (int i = 0; i < h; i++)
       for (int j = 0; j < r.w; j++)
         for (int k = 0; k < w; k++)
           ret.add(i, j, get(i, k) * r.get(k, j));
     return ret;
   }
+  Matrix& operator*=(const Matrix& r) { return *this = *this * r; }
   Matrix pow(long long n) const {
     Matrix ret = id(h);
     Matrix mat(*this);
@@ -118,4 +118,4 @@ struct Matrix {
     }
     return os;
   }
-};
+};