make variable naming consistent across library

Author: Cameron Custer

library/data_structures_[l,r)/bit.hpp

@@ -19,9 +19,9 @@ struct BIT {
     for (; i < sz(s); i |= i + 1) s[i] += d;
   }
   ll query(int r) {
-    ll ret = 0;
-    for (; r > 0; r &= r - 1) ret += s[r - 1];
-    return ret;
+    ll res = 0;
+    for (; r > 0; r &= r - 1) res += s[r - 1];
+    return res;
   }
   ll query(int l, int r) { return query(r) - query(l); }
 #include "bit_uncommon/walk_lambda.hpp"

library/data_structures_[l,r)/bit_uncommon/kd_bit.hpp

@@ -19,10 +19,10 @@ template<int K> struct KD_BIT {
     for (; i < sz(s); i |= i + 1) s[i].update(a...);
   }
   ll query(int l, int r, auto... a) {
-    ll ans = 0;
-    for (; l < r; r &= r - 1) ans += s[r - 1].query(a...);
-    for (; r < l; l &= l - 1) ans -= s[l - 1].query(a...);
-    return ans;
+    ll res = 0;
+    for (; l < r; r &= r - 1) res += s[r - 1].query(a...);
+    for (; r < l; l &= l - 1) res -= s[l - 1].query(a...);
+    return res;
   }
 };
 template<> struct KD_BIT<0> {

library/data_structures_[l,r)/seg_tree_uncommon/kth_smallest_query.hpp

@@ -26,12 +26,12 @@ struct kth_smallest {
   int query(int k, int tl, int tr, int vl, int vr) {
     if (tr - tl == 1) return tl;
     int tm = tl + (tr - tl) / 2;
-    int left_count = pst.tree[pst.tree[vr].lch].sum -
-                     pst.tree[pst.tree[vl].lch].sum;
-    if (left_count >= k)
+    int cnt_l = pst.tree[pst.tree[vr].lch].sum -
+                pst.tree[pst.tree[vl].lch].sum;
+    if (cnt_l >= k)
       return query(k, tl, tm, pst.tree[vl].lch,
         pst.tree[vr].lch);
-    return query(k - left_count, tm, tr, pst.tree[vl].rch,
+    return query(k - cnt_l, tm, tr, pst.tree[vl].rch,
       pst.tree[vr].rch);
   }
 };

library/data_structures_[l,r)/uncommon/deque_op.hpp

@@ -24,9 +24,9 @@ template<class T, class F> struct deq {
   T front() { return (empty(l) ? r[0] : l.back())[0]; }
   T back() { return (empty(r) ? l[0] : r.back())[0]; }
   int siz() { return sz(l) + sz(r); }
-  void push_back(T elem) {
+  void push_back(T val) {
     r.push_back(
-      {elem, empty(r) ? elem : op(r.back()[1], elem)});
+      {val, empty(r) ? val : op(r.back()[1], val)});
   }
   void pop_back() {
     if (empty(r)) {
@@ -37,9 +37,9 @@ template<class T, class F> struct deq {
     }
     r.pop_back();
   }
-  void push_front(T elem) {
+  void push_front(T val) {
     l.push_back(
-      {elem, empty(l) ? elem : op(elem, l.back()[1])});
+      {val, empty(l) ? val : op(val, l.back()[1])});
   }
   void pop_front() {
     if (empty(l)) {

library/data_structures_[l,r)/uncommon/mode_query.hpp

@@ -3,20 +3,20 @@ const int b = 318; //!< sqrt(1e5)
 //! https://noshi91.hatenablog.com/entry/2020/10/26/140105
 struct mode_query {
   int n;
-  vi a, cnt, index_into_index;
-  vector<vi> index;
+  vi a, cnt, pos_idx;
+  vector<vi> pos;
   vector<vector<pii>>
     mode_blocks; //!< {mode, cnt} of range of blocks
   //! @param a compressed array: 0 <= a[i] < n
   //! @time O(n * sqrt(n))
   //! @space O(n)
   mode_query(const vi& a):
-    n(sz(a)), a(a), cnt(n), index_into_index(n), index(n),
+    n(sz(a)), a(a), cnt(n), pos_idx(n), pos(n),
     mode_blocks((n + b - 1) / b,
       vector<pii>((n + b - 1) / b)) {
     rep(i, 0, n) {
-      index_into_index[i] = sz(index[a[i]]);
-      index[a[i]].push_back(i);
+      pos_idx[i] = sz(pos[a[i]]);
+      pos[a[i]].push_back(i);
     }
     for (int start = 0; start < n; start += b) {
       int mode = a[start];
@@ -51,17 +51,17 @@ struct mode_query {
     for (int i = l / b * b + b - 1; i >= l; i--)
       cnt[a[i]]++;
     for (int i = l / b * b + b - 1; i >= l; i--) {
-      int idx = index_into_index[i];
-      if (idx + res.second < sz(index[a[i]]) &&
-          index[a[i]][idx + res.second] < r)
+      int idx = pos_idx[i];
+      if (idx + res.second < sz(pos[a[i]]) &&
+          pos[a[i]][idx + res.second] < r)
         res = {a[i], cnt[a[i]] + res.second};
       cnt[a[i]]--;
     }
     rep(i, (r - 1) / b * b, r) cnt[a[i]]++;
     rep(i, (r - 1) / b * b, r) {
-      int idx = index_into_index[i];
+      int idx = pos_idx[i];
       if (idx >= res.second &&
-          index[a[i]][idx - res.second] >= l)
+          pos[a[i]][idx - res.second] >= l)
         res = {a[i], cnt[a[i]] + res.second};
       cnt[a[i]]--;
     }

library/data_structures_[l,r)/uncommon/priority_queue_of_updates.hpp

@@ -6,7 +6,7 @@
 //!     rep (i, 0, n) pq.ds.add(i, initial_nums[i]);
 //!     //or
 //!     pq.ds.subtree = initial_nums;
-//!     pq.push_update(u, v, curr_pri);
+//!     pq.push_update(u, v, cur_pri);
 //!     cout << pq.ds.sum(v) << '\n';
 //! @endcode
 //! @time n interweaved calls to pop_update, push_update
@@ -39,10 +39,9 @@ template<class DS, class... ARGS> struct pq_updates {
       extra.push_back(upd_st[idx_sk]);
       idx = min(idx, idx_sk), lowest_pri = pri;
     }
-    auto it =
-      remove_if(idx + all(upd_st), [&](auto& curr) {
-        return curr.second->first >= lowest_pri;
-      });
+    auto it = remove_if(idx + all(upd_st), [&](auto& cur) {
+      return cur.second->first >= lowest_pri;
+    });
     reverse_copy(all(extra), it);
     rep(i, idx, sz(upd_st)) ds.undo();
     upd_st.pop_back();
@@ -54,13 +53,13 @@ template<class DS, class... ARGS> struct pq_updates {
     }
   }
   //! @param args arguments to DS::join
-  //! @param priority must be distinct, can be negative
+  //! @param pri must be distinct, can be negative
   //! @time O(log(n) + T(n))
   //! @space an new update is allocated, inserted into
   //! `upd_st`, `mp` member variables
-  void push_update(ARGS... args, int priority) {
+  void push_update(ARGS... args, int pri) {
     ds.join(args...);
-    auto [it, ins] = mp.emplace(priority, sz(upd_st));
+    auto [it, ins] = mp.emplace(pri, sz(upd_st));
     assert(ins);
     upd_st.emplace_back(make_tuple(args...), it);
   }

library/data_structures_[l,r]/bit.hpp

@@ -19,9 +19,9 @@ struct BIT {
     for (; i < sz(s); i |= i + 1) s[i] += d;
   }
   ll query(int i) {
-    ll ret = 0;
-    for (; i >= 0; (i &= i + 1)--) ret += s[i];
-    return ret;
+    ll res = 0;
+    for (; i >= 0; (i &= i + 1)--) res += s[i];
+    return res;
   }
   ll query(int l, int r) {
     return query(r) - query(l - 1);

library/flow/hungarian.hpp

@@ -18,18 +18,18 @@ pair<ll, vi> hungarian(const vector<vector<ll>>& cost) {
     p[0] = i;
     int j0 = 0;
     vector minv(m, LLONG_MAX);
-    vi used(m);
+    vi vis(m);
     do {
-      used[j0] = 1;
+      vis[j0] = 1;
       int i0 = p[j0], j1 = 0;
       ll delta = LLONG_MAX;
-      rep(j, 1, m) if (!used[j]) {
+      rep(j, 1, m) if (!vis[j]) {
         ll cur = cost[i0][j] - u[i0] - v[j];
         if (cur < minv[j]) minv[j] = cur, way[j] = j0;
         if (minv[j] < delta) delta = minv[j], j1 = j;
       }
       rep(j, 0, m) {
-        if (used[j]) u[p[j]] += delta, v[j] -= delta;
+        if (vis[j]) u[p[j]] += delta, v[j] -= delta;
         else minv[j] -= delta;
       }
       j0 = j1;

library/graphs/bcc_callback.hpp

@@ -4,17 +4,17 @@
 //!   {
 //!     vector<vi> g(n);
 //!     DSU dsu(n);
-//!     vector<bool> seen(n);
+//!     vector<bool> vis(n);
 //!     bcc(g, [&](const vi& nodes) {
-//!       int count_edges = 0;
+//!       int cnt_edges = 0;
 //!       rep (i, 0, sz(nodes) - 1) {
-//!         seen[nodes[i]] = 1;
-//!         for (int u : g[nodes[i]]) if (!seen[u]) {
+//!         vis[nodes[i]] = 1;
+//!         for (int u : g[nodes[i]]) if (!vis[u]) {
 //!           // edge nodes[i] <=> u is in current BCC
-//!           count_edges++;
+//!           cnt_edges++;
 //!         }
 //!       }
-//!       if (count_edges == 1) {
+//!       if (cnt_edges == 1) {
 //!         // nodes[0] <=> nodes[1] is a bridge
 //!         return;
 //!       }

library/graphs/uncommon/enumerate_triangles.hpp

@@ -16,11 +16,11 @@ void enumerate_triangles(const vector<pii>& edges, int n,
     if (tie(deg[u], u) > tie(deg[v], v)) swap(u, v);
     g[u].push_back(v);
   }
-  vector<bool> seen(n);
+  vector<bool> vis(n);
   for (auto [u, v] : edges) {
-    for (int w : g[u]) seen[w] = 1;
+    for (int w : g[u]) vis[w] = 1;
     for (int w : g[v])
-      if (seen[w]) f(u, v, w);
-    for (int w : g[u]) seen[w] = 0;
+      if (vis[w]) f(u, v, w);
+    for (int w : g[u]) vis[w] = 0;
   }
 }