use ranges/views and <bit> consistently: offset ranges via views::drop/take, __lg -> bit_width/bit_floor

Cameron Custer · Cameron Custer · commit 65e3ff77442d · 2026-07-06T12:18:49.000-07:00
diff --git a/library/data_structures_[l,r)/rmq.hpp b/library/data_structures_[l,r)/rmq.hpp
@@ -23,7 +23,7 @@ template<class T, class F> struct RMQ {
   }
   T query(int l, int r) {
     assert(l < r);
-    int lg = __lg(r - l);
+    int lg = bit_width(r - l + 0u) - 1;
     return op(dp[lg][l], dp[lg][r - (1 << lg)]);
   }
 };
diff --git a/library/data_structures_[l,r)/seg_tree_midpoint.hpp b/library/data_structures_[l,r)/seg_tree_midpoint.hpp
@@ -1,6 +1,6 @@
 #pragma once
 //! https://codeforces.com/blog/entry/112755
 int split(int tl, int tr) {
-  int pw2 = 1 << __lg(tr - tl);
+  int pw2 = bit_floor(tr - tl + 0u);
   return min(tl + pw2, tr - pw2 / 2);
 }
diff --git a/library/data_structures_[l,r)/seg_tree_uncommon/max_right.hpp b/library/data_structures_[l,r)/seg_tree_uncommon/max_right.hpp
@@ -1,6 +1,7 @@
 void max_right(int l, int r, auto f) {
   for (T x = unit; l < r;) {
-    int u = l + n, v = __lg(min(u & -u, r - l)),
+    int u = l + n,
+        v = bit_width(min(u & -u, r - l) + 0u) - 1,
         m = l + (1 << v);
     if (T y = op(x, s[u >> v]); f(m, y)) l = m, x = y;
     else r = m - 1;
diff --git a/library/data_structures_[l,r)/seg_tree_uncommon/min_left.hpp b/library/data_structures_[l,r)/seg_tree_uncommon/min_left.hpp
@@ -1,6 +1,7 @@
 void min_left(int l, int r, auto f) {
   for (T x = unit; l < r;) {
-    int u = r + n, v = __lg(min(u & -u, r - l)),
+    int u = r + n,
+        v = bit_width(min(u & -u, r - l) + 0u) - 1,
         m = r - (1 << v);
     if (T y = op(s[(u - 1) >> v], x); f(m, y))
       r = m, x = y;
diff --git a/library/data_structures_[l,r)/uncommon/deque_op.hpp b/library/data_structures_[l,r)/uncommon/deque_op.hpp
@@ -58,9 +58,10 @@ template<class T, class F> struct deq {
     partial_sum(sz_le + all(a), begin(presum) + sz_le, op);
     l.resize(sz_le);
     r.resize(sz(a) - sz_le);
-    transform(begin(a), begin(a) + sz_le, begin(presum),
+    ranges::transform(a | views::take(sz_le), presum,
       rbegin(l), [](T x, T y) { return dt{x, y}; });
-    transform(sz_le + all(a), begin(presum) + sz_le,
-      begin(r), [](T x, T y) { return dt{x, y}; });
+    ranges::transform(a | views::drop(sz_le),
+      presum | views::drop(sz_le), begin(r),
+      [](T x, T y) { return dt{x, y}; });
   }
 };
diff --git a/library/data_structures_[l,r)/uncommon/priority_queue_of_updates.hpp b/library/data_structures_[l,r)/uncommon/priority_queue_of_updates.hpp
@@ -38,9 +38,10 @@ 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& cur) {
-      return cur.second->first >= lowest_pri;
-    });
+    auto it = begin(ranges::remove_if(
+      upd_st | views::drop(idx), [&](auto& cur) {
+        return cur.second->first >= lowest_pri;
+      }));
     ranges::reverse_copy(extra, it);
     rep(i, idx, sz(upd_st)) ds.undo();
     upd_st.pop_back();
diff --git a/library/data_structures_[l,r]/disjoint_rmq.hpp b/library/data_structures_[l,r]/disjoint_rmq.hpp
@@ -27,7 +27,7 @@ template<class T, class F> struct disjoint_rmq {
   }
   T query(int l, int r) {
     if (l == r) return dp[0][l];
-    int lg = __lg(l ^ r);
+    int lg = bit_width((l ^ r) + 0u) - 1;
     return op(dp[lg][l], dp[lg][r]);
   }
 };
diff --git a/library/data_structures_[l,r]/rmq.hpp b/library/data_structures_[l,r]/rmq.hpp
@@ -23,7 +23,7 @@ template<class T, class F> struct RMQ {
   }
   T query(int l, int r) {
     assert(l <= r);
-    int lg = __lg(r - l + 1);
+    int lg = bit_width(r - l + 1u) - 1;
     return op(dp[lg][l], dp[lg][r - (1 << lg) + 1]);
   }
 };
diff --git a/library/data_structures_[l,r]/seg_tree.hpp b/library/data_structures_[l,r]/seg_tree.hpp
@@ -17,7 +17,8 @@
 //! @time O(n + q log n)
 //! @space O(n)
 int nxt(int& l, int r) {
-  int u = l, v = __lg(min(l & -l, r - l + 1));
+  int u = l,
+      v = bit_width(min(l & -l, r - l + 1) + 0u) - 1;
   return l += 1 << v, u >> v;
 }
 template<class T, class F> struct tree {
diff --git a/library/data_structures_[l,r]/seg_tree_uncommon/max_right.hpp b/library/data_structures_[l,r]/seg_tree_uncommon/max_right.hpp
@@ -1,7 +1,8 @@
 void max_right(int l, int r, auto f) {
   if (T x = s[l + n]; f(l, x))
     for (l++; l <= r;) {
-      int u = l + n, v = __lg(min(u & -u, r - l + 1)),
+      int u = l + n,
+          v = bit_width(min(u & -u, r - l + 1) + 0u) - 1,
           m = l + (1 << v) - 1;
       if (T y = op(x, s[u >> v]); f(m, y))
         l = m + 1, x = y;
diff --git a/library/data_structures_[l,r]/seg_tree_uncommon/min_left.hpp b/library/data_structures_[l,r]/seg_tree_uncommon/min_left.hpp
@@ -1,7 +1,8 @@
 int min_left(int l, int r, auto f) {
   if (T x = s[r + n]; f(r, x))
     for (r--; l <= r;) {
-      int u = r + 1 + n, v = __lg(min(u & -u, r - l + 1)),
+      int u = r + 1 + n,
+          v = bit_width(min(u & -u, r - l + 1) + 0u) - 1,
           m = r - (1 << v) + 1;
       if (T y = op(s[(u - 1) >> v], x); f(m, y))
         r = m - 1, x = y;
diff --git a/library/dsu/range_parallel_dsu.hpp b/library/dsu/range_parallel_dsu.hpp
@@ -9,7 +9,7 @@ struct rp_dsu {
   vector<DSU> dsus;
   rp_dsu(int n): dsus(bit_width(n + 0u), DSU(n)) {}
   void join(int u, int v, int len, auto f) {
-    int i = __lg(len);
+    int i = bit_width(len + 0u) - 1;
     join(u, v, f, i);
     join(u + len - (1 << i), v + len - (1 << i), f, i);
   }
diff --git a/library/graphs/strongly_connected_components/offline_incremental_scc.hpp b/library/graphs/strongly_connected_components/offline_incremental_scc.hpp
@@ -33,9 +33,10 @@ vi offline_incremental_scc(vector<array<int, 2>> eds,
     }
     rep(i, 0, sz(g)) ids[vs[i]] = -1;
     scc_id = scc(g).second;
-    auto split = partition(el, er, [&](int i) {
-      return scc_id[eds[i][0]] == scc_id[eds[i][1]];
-    });
+    auto split = begin(ranges::partition(
+      ranges::subrange(el, er), [&](int i) {
+        return scc_id[eds[i][0]] == scc_id[eds[i][1]];
+      }));
     for (auto it = el; it != split; it++) joins[*it] = mid;
     if (tr - tl == 1) return;
     for (auto it = split; it != er; it++) {
diff --git a/library/strings/suffix_array/find/find_string_bs_fast.hpp b/library/strings/suffix_array/find/find_string_bs_fast.hpp
@@ -10,16 +10,16 @@ match find_str_fast(const T& t) {
     if (int lcp_len = s_l == n ? 0 : len_lcp(s_l, i);
       lcp_len != s_len)
       return (lcp_len < s_len) ^ (cmp_sufs(s_l, i) < 0);
-    auto [it_s, it_t] =
-      mismatch(i + s_len + all(s), s_len + all(t));
+    auto [it_s, it_t] = ranges::mismatch(
+      s | views::drop(i + s_len), t | views::drop(s_len));
     s_l = i, s_len = it_t - begin(t);
     return lexicographical_compare(it_s, end(s), it_t,
       end(t));
   };
   int sa_le = ranges::lower_bound(sa, 0, cmp) - begin(sa),
       sa_ri = sa_le;
   if (s_len == sz(t))
-    sa_ri = lower_bound(sa_le + all(sa), 0,
+    sa_ri = ranges::lower_bound(sa | views::drop(sa_le), 0,
               [&](int i, int) -> bool {
                 return len_lcp(s_l, i) >= sz(t);
               }) -
diff --git a/library/strings/suffix_array/find/find_substring.hpp b/library/strings/suffix_array/find/find_substring.hpp
@@ -16,10 +16,11 @@ pii find_substr(int s_l, int s_r) {
   auto cmp = [&](int i, bool flip) -> bool {
     return flip ^ (len_lcp(i, s_l) < s_r - s_l);
   };
-  int l = lower_bound(begin(sa), begin(sa) + sa_inv[s_l],
-            0, cmp) -
+  int l = ranges::lower_bound(
+            sa | views::take(sa_inv[s_l]), 0, cmp) -
           begin(sa);
-  int r = lower_bound(sa_inv[s_l] + 1 + all(sa), 1, cmp) -
+  int r = ranges::lower_bound(
+            sa | views::drop(sa_inv[s_l] + 1), 1, cmp) -
           begin(sa);
   return {l, r};
 }
diff --git a/library/trees/edge_cd.hpp b/library/trees/edge_cd.hpp
@@ -28,10 +28,10 @@ template<class G> void edge_cd(vector<G>& g, auto f) {
     if (m < 2) return;
     u = ctd(ctd, u, u, m);
     int sum = 0;
-    auto it = partition(all(g[u]), [&](int v) {
+    auto it = begin(ranges::partition(g[u], [&](int v) {
       ll x = sum + s[v];
       return x * x < m * (m - x) ? sum = x : 0;
-    });
+    }));
     f(u, it - begin(g[u]));
     G oth(it, end(g[u]));
     g[u].erase(it, end(g[u]));
diff --git a/library/trees/uncommon/ladder_decomposition.hpp b/library/trees/uncommon/ladder_decomposition.hpp
@@ -44,7 +44,7 @@ struct ladder {
   int kth_par(int u, int k) {
     assert(0 <= k && k <= d[u]);
     if (k == 0) return u;
-    int bit = __lg(k);
+    int bit = bit_width(k + 0u) - 1;
     u = jmp[bit][u], k -= (1 << bit);
     int i = idx[u], j = i + d[lad[i]] - d[u];
     assert(lad[j] == u);
diff --git a/library/trees/uncommon/linear_kth_par.hpp b/library/trees/uncommon/linear_kth_par.hpp
@@ -50,7 +50,8 @@ struct linear_kth_par {
     if (k == 0) return u;
     int anc_d = d[u] - k, bc = bit_ceil(k + 0u);
     int t = (tin[u] + bc / 2) & -bc;
-    int i = idx[jmp[t].at(__lg(d_tour[t] - anc_d))];
+    int i = idx[jmp[t].at(
+      bit_width(d_tour[t] - anc_d + 0u) - 1)];
     return lad[i + d[lad[i]] - anc_d];
   }
 };

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ template<class T, class F> struct RMQ {`
`23`	`23`	`}`
`24`	`24`	`T query(int l, int r) {`
`25`	`25`	`assert(l < r);`
`26`		`- int lg = __lg(r - l);`
	`26`	`+ int lg = bit_width(r - l + 0u) - 1;`
`27`	`27`	`return op(dp[lg][l], dp[lg][r - (1 << lg)]);`
`28`	`28`	`}`
`29`	`29`	`};`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`#pragma once`
`2`	`2`	`//! https://codeforces.com/blog/entry/112755`
`3`	`3`	`int split(int tl, int tr) {`
`4`		`- int pw2 = 1 << __lg(tr - tl);`
	`4`	`+ int pw2 = bit_floor(tr - tl + 0u);`
`5`	`5`	`return min(tl + pw2, tr - pw2 / 2);`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ template<class T, class F> struct disjoint_rmq {`
`27`	`27`	`}`
`28`	`28`	`T query(int l, int r) {`
`29`	`29`	`if (l == r) return dp[0][l];`
`30`		`- int lg = __lg(l ^ r);`
	`30`	`+ int lg = bit_width((l ^ r) + 0u) - 1;`
`31`	`31`	`return op(dp[lg][l], dp[lg][r]);`
`32`	`32`	`}`
`33`	`33`	`};`