rename IIFE recursion parameter to self

Per convention, name the `this auto&&` recursion parameter of the
unnamed IIFEs `self` (previously `dfs`/`dnc`). Updates the parameter
and all recursive call sites within each of the 7 IIFEs. No behavior
change.

Author: cameroncuster

library/convolution/min_plus_convolution_convex_and_arbitrary.hpp

@@ -9,7 +9,7 @@ vi min_plus(const vi& convex, const vi& arbitrary) {
   int n = sz(convex);
   int m = sz(arbitrary);
   vi res(n + m - 1, INT_MAX);
-  [&](this auto&& dnc, int res_le, int res_ri, int arb_le,
+  [&](this auto&& self, int res_le, int res_ri, int arb_le,
     int arb_ri) {
     if (res_le >= res_ri) return;
     int mid_res = (res_le + res_ri) / 2;
@@ -22,9 +22,9 @@ vi min_plus(const vi& convex, const vi& arbitrary) {
         op_arb = i;
       }
     }
-    dnc(res_le, mid_res, arb_le, min(arb_ri, op_arb + 1));
+    self(res_le, mid_res, arb_le, min(arb_ri, op_arb + 1));
     // NOLINTNEXTLINE(readability-suspicious-call-argument)
-    dnc(mid_res + 1, res_ri, op_arb, arb_ri);
+    self(mid_res + 1, res_ri, op_arb, arb_ri);
   }(0, n + m - 1, 0, m);
   return res;
 }

library/graphs/euler_path.hpp

@@ -17,11 +17,11 @@
 vector<pii> euler_path(auto& g, int m, int s) {
   vi vis(m);
   vector<pii> path;
-  [&](this auto&& dfs, int u, int eu) -> void {
+  [&](this auto&& self, int u, int eu) -> void {
     while (!empty(g[u])) {
       auto [v, ev] = g[u].back();
       g[u].pop_back();
-      if (!vis[ev]) vis[ev] = 1, dfs(v, ev);
+      if (!vis[ev]) vis[ev] = 1, self(v, ev);
     }
     path.emplace_back(u, eu);
   }(s, -1);

library/graphs/strongly_connected_components/offline_incremental_scc.hpp

@@ -18,7 +18,7 @@ vi offline_incremental_scc(vector<array<int, 2>> eds,
   vector<vi> g;
   // uses -1 as the lower bound to correctly handle
   // self-edges
-  [&](this auto&& dnc, auto el, auto er, int tl, int tr) {
+  [&](this auto&& self, auto el, auto er, int tl, int tr) {
     g.clear();
     int mid = midpoint(tl, tr);
     for (auto it = el; it != er; it++) {
@@ -43,8 +43,8 @@ vi offline_incremental_scc(vector<array<int, 2>> eds,
       auto& [u, v] = eds[*it];
       u = scc_id[u], v = scc_id[v];
     }
-    dnc(el, split, tl, mid);
-    dnc(split, er, mid, tr);
+    self(el, split, tl, mid);
+    self(split, er, mid, tr);
   }(all(idx), -1, m);
   return joins;
 }

library/trees/centroid_decomp.hpp

@@ -19,9 +19,9 @@ vi cd(auto& g, auto f) {
       }
     return 2 * s[u] >= n ? s[p] = n - s[u], u : -1;
   };
-  [&](this auto&& dfs, int u) -> int {
+  [&](this auto&& self, int u) -> int {
     f(u = ctd(u, u, s[u]));
-    for (int v : g[u]) erase(g[v], u), p[dfs(v)] = u;
+    for (int v : g[u]) erase(g[v], u), p[self(v)] = u;
     return u;
   }(0);
   return p;

library/trees/edge_cd.hpp

@@ -26,7 +26,7 @@ template<class G> void edge_cd(vector<G>& g, auto f) {
       }
     return 2 * s[u] > m ? s[p] = m + 1 - s[u], u : -1;
   };
-  [&](this auto&& dfs, int u, int m) {
+  [&](this auto&& self, int u, int m) {
     if (m < 2) return;
     u = ctd(u, u, m);
     int sum = 0;
@@ -37,8 +37,8 @@ template<class G> void edge_cd(vector<G>& g, auto f) {
     f(u, it - begin(g[u]));
     G oth(it, end(g[u]));
     g[u].erase(it, end(g[u]));
-    dfs(u, sum);
+    self(u, sum);
     swap(g[u], oth);
-    dfs(u, m - sum);
+    self(u, m - sum);
   }(0, sz(g) - 1);
 };

library/trees/shallowest_decomp_tree.hpp

@@ -9,11 +9,11 @@
 //! @space O(n)
 void shallowest(auto& g, auto f) {
   vector<vi> order(bit_width(size(g)));
-  [&](this auto&& dfs, int u, int p) -> int {
+  [&](this auto&& self, int u, int p) -> int {
     int once = 0, twice = 0;
     for (int v : g[u])
       if (v != p) {
-        int dp = dfs(v, u);
+        int dp = self(v, u);
         twice |= once & dp, once |= dp;
       }
     auto dp = (once | (bit_ceil(twice + 1u) - 1)) + 1;

library/trees/uncommon/subtree_isomorphism.hpp

@@ -12,10 +12,10 @@
 auto subtree_iso(const auto& g) {
   vi iso_id(sz(g), -1);
   map<vi, int> hashes;
-  [&](this auto&& dfs, int u, int p) -> int {
+  [&](this auto&& self, int u, int p) -> int {
     vi ch_ids;
     for (int v : g[u])
-      if (v != p) ch_ids.push_back(dfs(v, u));
+      if (v != p) ch_ids.push_back(self(v, u));
     ranges::sort(ch_ids);
     return iso_id[u] =
              hashes.try_emplace(ch_ids, sz(hashes))