update

Author: KumaCS

docs/segment-tree/lazy-segment-tree.md

@@ -0,0 +1,13 @@
+モノイド $(T,\cdot,e),(F,\circ,\mathrm{id})$ があり，$F$ は $T$ に左から作用するとする．
+
+- 実際には各種演算は計算で出てくる範囲で定義されていれば構わない．
+
+長さ $N$ の $T$ の列 $A=(A_0,A_1,\dots,A_{N-1})$ に対し，空間計算量 $\Theta(N)$ のもとで以下の操作を行える．
+
+- `set(p, x)`：$A_p \gets x$ とする．$O(\log N)$ 時間．
+- `get(p)`：$A_p$ を取得する．$O(\log N)$ 時間．
+- `apply(l, r, f)`：$i=l,l+1,\dots,r-1$ に対し $A_i \gets f A_i$ とする．$O(\log N)$ 時間．
+- `prod(l, r)`：$A_l\cdot A_{l+1}\cdot\cdots\cdot A_{r-1}$ を取得する．$O(\log N)$ 時間．
+- 二分探索：$O(\log N)$ 時間．$\mathrm{cond}(e)=\mathrm{true}$ を要求する．
+  - `max_right(l, cond)`：$\mathrm{cond}(A_l \cdot A_{l+1} \cdot \cdots \cdot A_{r-1})$ が真となる最大の $r$ を返す．
+  - `min_left(r, cond)`：$\mathrm{cond}(A_l \cdot A_{l+1} \cdot \cdots \cdot A_{r-1})$ が真となる最小の $l$ を返す．

docs/union-find/potentialized-union-find.md

@@ -0,0 +1,8 @@
+通常の Union Find のほかに列 $(p_0,p_1,\dots,p_{n-1})$ に関する情報を管理する．
+
+- `unite(u, v, w)`：$p_u-p_v=w$ という情報が与えられる．それまでに与えられた valid な情報と矛盾しないとき valid な情報と呼ぶことにする．与えられた情報が valid な情報か否かを返す．
+- `diff(u, v)`：$p_u-p_v$ の値が valid な情報から一意に定まる場合その値を，定まらない場合はその旨を報告する．
+
+## アルゴリズム
+
+Union Find の内部において $p_v$ から $v$ を含む連結成分の根の $p$ の値を減じたものを管理する．

docs/union-find/union-find.md

@@ -0,0 +1,105 @@
+$n$ 頂点 $0$ 辺のグラフに対する以下のクエリを処理する．$\alpha$ はアッカーマン関数の逆関数．
+
+- `find(v)`：頂点 $v$ を含む連結成分の代表頂点を返す．$O(\alpha(n))$ 時間．
+- `size(v)`：頂点 $v$ を含む連結成分の頂点数を返す．$O(\alpha(n))$ 時間．
+- `same(u, v)`：頂点 $u,v$ が同じ連結成分に含まれるかを返す．$O(\alpha(n))$ 時間．
+- `unite(u, v)`：辺 $uv$ を追加する．$O(\alpha(n))$ 時間．
+  - `unite(u, v, f)` で連結成分マージ時に $f$ を呼び出す．
+- `groups()`：連結成分を列挙する．$O(n)$ 時間．
+
+## アルゴリズム
+
+`find` および `unite` が実装できれば他も難しくない．
+
+根付き木として考える．
+各頂点の親を示す長さ $n$ の列 $(p_0,\dots,p_{n-1})$ を管理する．
+$p_i=i$ ならば頂点 $i$ は根であり，はじめ全ての $i$ に対し $p_i=i$ である．
+
+`find`, `unite` は naive には以下のように実装できる．
+
+```
+def find(v):
+  if p[v] == v: return v
+  return find(p[v])
+def unite(u, v):
+  u = find(u)
+  v = find(v)
+  p[v] = u
+```
+
+## 計算量
+
+https://37zigen.com/union-find-complexity-1/
+
+毎回素直に根まで辿り，unite では一方の根をもう一方の根に繋ぐ．
+これでは worst $\Theta(n)$ 時間である．
+
+計算量を改善する手法がある．
+
+## path compression
+
+path compression では `find` を以下のようにする．
+```
+def find(v):
+  if p[v] == v: return v
+  return p[v] = find(p[v])
+```
+一度再帰で通った部分を圧縮している．
+
+このとき各操作がならし $O(\log n)$ 時間になる．
+
+<details>
+
+証明：頂点 $v$ を根とする部分木の大きさを $s_v$ とし，ポテンシャル $\Phi=2\sum_{v}\log_2 s_v$ を考える．
+はじめ $\Phi=0$ である．
+
+`unite` については `find` での変化を除くと，ポテンシャルは連結性が変化するときにのみ高々 $2\log_2 n$ だけ増加し，この増加は高々 $n$ 回．
+
+`find` の再帰において頂点 $v_0,v_1,\dots,v_k$ を順に通ったとき（$v_k$ が根である），$1\leq i\leq k-1$ について $s_{v_i} \to s_{v_i}-s_{v_{i-1}}$ となる．
+ポテンシャルの差分は
+$$\begin{align*}
+2\sum_{i=1}^{k-1}\left(\log_2(s_{v_i}-s_{v_{i-1}})-\log_2 s_{v_i}\right)
+&=2\sum_{i=1}^{k-1}\log_2\left(1-\dfrac{s_{v_{i-1}}}{s_{v_i}}\right)\\
+&\leq-2\sum_{i=1}^{k-1}\dfrac{s_{v_{i-1}}}{s_{v_i}}\\
+&\leq \log_2 n+1-k
+\end{align*}$$
+と評価できる．
+
+- 一つ目の不等式は $\log(1-x)\leq -x$ より．
+- 二つ目の不等式は $s_{v_i}/s_{v_{i-1}}\geq 2$ なる $i$ が高々 $\log_2 n$ 個であることより．
+
+従って `find` を $q$ 回行ったとき $\Phi\geq 0$ より $\sum k=O((n+q)\log n)$ と評価できる．
+
+</details>
+
+## union by size (rank)
+
+union by size では `unite` を以下のようにする．
+```
+def unite(u, v):
+  u = find(u)
+  v = find(v)
+  if size(u) < size(v): swap(u, v)
+  p[v] = u
+```
+部分木のサイズが小さい方を大きい方の子とする（いわゆるマージテク）．
+
+このとき各操作が $O(\log n)$ 時間になる．
+
+<details>
+
+証明：頂点 $p,c$ で $p$ が $c$ の親であるとき $\operatorname{size}(p)\geq 2\operatorname{size}(c)$ が成り立つから，常に各頂点と根の距離は高々 $\log_2 n$ であり，`find` は $O(\log n)$ 時間で行える．
+
+</details>
+
+各頂点の rank を (path compression しない状態での) その頂点を根とする部分木の高さとする．
+union by rank は union by size で size を用いている部分を rank に置き換えたもの．
+
+## 組み合わせ
+
+path compression と union by size (rank) を組み合わせるとさらにオーダーが改善し，ならし $O(\alpha(n))$ 時間になることが知られている．
+
+ここで $\alpha$ はアッカーマン関数の逆関数で，現実的な $n$ の範囲で $\alpha(n)\leq 5$．
+
+参考
+- [α(m, n) のお勉強 + 定数時間 decremental neighbor query - えびちゃんの日記](https://rsk0315.hatenablog.com/entry/2022/05/04/215704)

fps/taylor-shift.hpp

@@ -8,6 +8,7 @@ FormalPowerSeries<mint> TaylorShift(FormalPowerSeries<mint> f, mint a) {
   using fps = FormalPowerSeries<mint>;
   int n = f.size();
   using fact = Factorial<mint>;
+  fact::reserve(n);
   for (int i = 0; i < n; i++) f[i] *= fact::fact(i);
   reverse(f.begin(), f.end());
   fps g(n, mint(1));

modint/factorial.hpp

@@ -9,48 +9,51 @@ struct Factorial {
   }
   static mint inv(int n) {
     static long long mod = mint::get_mod();
-    static vector<mint> _inv({0, 1});
+    static vector<mint> buf({0, 1});
     assert(n != 0);
     if (mod != mint::get_mod()) {
       mod = mint::get_mod();
-      _inv = vector<mint>({0, 1});
+      buf = vector<mint>({0, 1});
     }
-    if (_inv.size() <= n) _inv.reserve(n + 1);
-    while (_inv.size() <= n) {
-      long long k = _inv.size(), q = (mod + k - 1) / k;
-      _inv.push_back(q * _inv[k * q - mod]);
+    if ((int)buf.size() <= n) buf.reserve(n + 1);
+    while ((int)buf.size() <= n) {
+      long long k = buf.size(), q = (mod + k - 1) / k;
+      buf.push_back(q * buf[k * q - mod]);
     }
-    return _inv[n];
+    return buf[n];
   }
   static mint fact(int n) {
     static long long mod = mint::get_mod();
-    static vector<mint> _fact({1, 1});
+    static vector<mint> buf({1, 1});
     assert(n >= 0);
     if (mod != mint::get_mod()) {
       mod = mint::get_mod();
-      _fact = vector<mint>({1, 1});
+      buf = vector<mint>({1, 1});
     }
-    if (_fact.size() <= n) _fact.reserve(n + 1);
-    while (_fact.size() <= n) {
-      long long k = _fact.size();
-      _fact.push_back(_fact.back() * k);
+    if ((int)buf.size() <= n) buf.reserve(n + 1);
+    while ((int)buf.size() <= n) {
+      long long k = buf.size();
+      buf.push_back(buf.back() * k);
     }
-    return _fact[n];
+    return buf[n];
   }
   static mint fact_inv(int n) {
     static long long mod = mint::get_mod();
-    static vector<mint> _fact_inv({1, 1});
+    static vector<mint> buf({1, 1});
     assert(n >= 0);
     if (mod != mint::get_mod()) {
       mod = mint::get_mod();
-      _fact_inv = vector<mint>({1, 1});
+      buf = vector<mint>({1, 1});
     }
-    if (_fact_inv.size() <= n) _fact_inv.reserve(n + 1);
-    while (_fact_inv.size() <= n) {
-      long long k = _fact_inv.size();
-      _fact_inv.push_back(_fact_inv.back() * inv(k));
+    if ((int)buf.size() <= n) {
+      inv(n);
+      buf.reserve(n + 1);
     }
-    return _fact_inv[n];
+    while ((int)buf.size() <= n) {
+      long long k = buf.size();
+      buf.push_back(buf.back() * inv(k));
+    }
+    return buf[n];
   }
   static mint binom(int n, int r) {
     if (r < 0 || r > n) return 0;
@@ -81,7 +84,7 @@ struct Factorial {
     if (n < 0 || r < 0) return 0;
     return r == 0 ? 1 : binom(n + r - 1, r);
   }
-};  // namespace Factorial
+};
 /**
  * @brief 階乗, 二項係数
  */

union-find/potentialized-union-find.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+template <class T>
+struct PotentializedUnionFind {
+ private:
+  vector<int> a;
+  vector<T> p;
+
+ public:
+  PotentializedUnionFind(int n) : a(n, -1), p(n, 0) {}
+  int find(int v) {
+    if (a[v] < 0) return v;
+    int r = find(a[v]);
+    p[v] += p[a[v]];
+    return a[v] = r;
+  }
+  int size(int v) { return -a[find(v)]; }
+  bool same(int u, int v) { return find(u) == find(v); }
+  // p[u]-p[v]=w
+  bool unite(int u, int v, T w) {
+    int x = find(u), y = find(v);
+    if (x == y) return p[u] - p[v] == w;
+    w -= p[u], w += p[v];
+    if (a[x] < a[y]) {
+      p[y] = p[x] - w;
+      a[x] += a[y];
+      a[y] = x;
+    } else {
+      p[x] = p[y] + w;
+      a[y] += a[x];
+      a[x] = y;
+    }
+    return true;
+  }
+  // p[u]-p[v]
+  T diff(int u, int v) { return p[u] - p[v]; }
+};
+/**
+ * @brief ポテンシャル付き Union Find
+ * @docs docs/union-find/potentialized-union-find.md
+ */

verify/union-find/LC_unionfind_with_potential.test.cpp

@@ -0,0 +1,26 @@
+#define PROBLEM "https://judge.yosupo.jp/problem/unionfind_with_potential"
+
+#include "template/template.hpp"
+#include "modint/modint.hpp"
+using mint = ModInt<998244353>;
+#include "union-find/potentialized-union-find.hpp"
+
+int main() {
+  int n, q;
+  in(n, q);
+  PotentializedUnionFind<mint> uf(n);
+  while (q--) {
+    int type, u, v;
+    in(type, u, v);
+    if (type == 0) {
+      mint w;
+      in(w);
+      out(uf.unite(u, v, w));
+    } else {
+      if (uf.same(u, v))
+        out(uf.diff(u, v));
+      else
+        out(-1);
+    }
+  }
+}