convert single-call recursive lambdas to unnamed IIFEs

For the 7 library files where a `this auto&&` recursive lambda is
defined and invoked exactly once, drop the name and immediately
invoke the lambda in place. This removes a redundant binding
without changing behavior.

Note: explicit return types are retained where present, since C++
cannot deduce the return type of a recursive lambda whose
recursive call precedes any return.

Verified: repo clang-format passes; all affected tests compile
under both g++ and clang; self-contained handmade stress tests
pass at runtime.

Author: cameroncuster

library/convolution/min_plus_convolution_convex_and_arbitrary.hpp

@@ -9,8 +9,8 @@ vi min_plus(const vi& convex, const vi& arbitrary) {
   int n = sz(convex);
   int m = sz(arbitrary);
   vi res(n + m - 1, INT_MAX);
-  auto dnc = [&](this auto&& dnc, int res_le, int res_ri,
-               int arb_le, int arb_ri) {
+  [&](this auto&& dnc, 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;
     int op_arb = arb_le;
@@ -25,7 +25,6 @@ vi min_plus(const vi& convex, const vi& arbitrary) {
     dnc(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);
-  };
-  dnc(0, n + m - 1, 0, m);
+  }(0, n + m - 1, 0, m);
   return res;
 }

library/graphs/euler_path.hpp

@@ -17,15 +17,14 @@
 vector<pii> euler_path(auto& g, int m, int s) {
   vi vis(m);
   vector<pii> path;
-  auto dfs = [&](this auto&& dfs, int u, int eu) -> void {
+  [&](this auto&& dfs, 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);
     }
     path.emplace_back(u, eu);
-  };
-  dfs(s, -1);
+  }(s, -1);
   ranges::reverse(path);
   return path;
 }

library/graphs/strongly_connected_components/offline_incremental_scc.hpp

@@ -16,8 +16,9 @@ vi offline_incremental_scc(vector<array<int, 2>> eds,
   vi ids(n, -1), joins(m, m), idx(m), vs(n), scc_id;
   ranges::iota(idx, 0);
   vector<vi> g;
-  auto dnc = [&](this auto&& dnc, auto el, auto er, int tl,
-               int tr) {
+  // uses -1 as the lower bound to correctly handle
+  // self-edges
+  [&](this auto&& dnc, auto el, auto er, int tl, int tr) {
     g.clear();
     int mid = midpoint(tl, tr);
     for (auto it = el; it != er; it++) {
@@ -44,9 +45,6 @@ vi offline_incremental_scc(vector<array<int, 2>> eds,
     }
     dnc(el, split, tl, mid);
     dnc(split, er, mid, tr);
-  };
-  // uses -1 as the lower bound to correctly handle
-  // self-edges
-  dnc(all(idx), -1, m);
+  }(all(idx), -1, m);
   return joins;
 }

library/trees/centroid_decomp.hpp

@@ -19,10 +19,10 @@ vi cd(auto& g, auto f) {
       }
     return 2 * s[u] >= n ? s[p] = n - s[u], u : -1;
   };
-  auto dfs = [&](this auto&& dfs, int u) -> int {
+  [&](this auto&& dfs, int u) -> int {
     f(u = ctd(u, u, s[u]));
     for (int v : g[u]) erase(g[v], u), p[dfs(v)] = u;
     return u;
-  };
-  return dfs(0), p;
+  }(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;
   };
-  auto dfs = [&](this auto&& dfs, int u, int m) {
+  [&](this auto&& dfs, int u, int m) {
     if (m < 2) return;
     u = ctd(u, u, m);
     int sum = 0;
@@ -40,6 +40,5 @@ template<class G> void edge_cd(vector<G>& g, auto f) {
     dfs(u, sum);
     swap(g[u], oth);
     dfs(u, m - sum);
-  };
-  dfs(0, sz(g) - 1);
+  }(0, sz(g) - 1);
 };

library/trees/shallowest_decomp_tree.hpp

@@ -9,7 +9,7 @@
 //! @space O(n)
 void shallowest(auto& g, auto f) {
   vector<vi> order(bit_width(size(g)));
-  auto dfs = [&](this auto&& dfs, int u, int p) -> int {
+  [&](this auto&& dfs, int u, int p) -> int {
     int once = 0, twice = 0;
     for (int v : g[u])
       if (v != p) {
@@ -19,8 +19,7 @@ void shallowest(auto& g, auto f) {
     auto dp = (once | (bit_ceil(twice + 1u) - 1)) + 1;
     order[countr_zero(dp)].push_back(u);
     return dp;
-  };
-  dfs(0, 0);
+  }(0, 0);
   for (const vi& vec : order | views::reverse)
     for (int u : vec) {
       f(u);

library/trees/uncommon/subtree_isomorphism.hpp

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