Rust 2024 edition

EbTech · EbTech · commit 2073670c5409 · 2025-02-27T12:23:49.000-08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
 name = "contest-algorithms"
-version = "0.3.1-alpha.0"
+version = "0.3.1-alpha.1"
 authors = ["Aram Ebtekar"]
-edition = "2021"
+edition = "2024"
 
 description = "Common algorithms and data structures for programming contests"
 repository = "https://github.com/EbTech/rust-algorithms"
diff --git a/README.md b/README.md
@@ -35,10 +35,7 @@ Some contest sites and online judges that support Rust:
 - [HackerRank](https://www.hackerrank.com/contests)
 - [Timus](http://acm.timus.ru/help.aspx?topic=rust)
 
-The following support pre-2018 versions of Rust:
-- [Google Kick Start and Code Jam](https://codingcompetitions.withgoogle.com)
-
-For help in getting started, you may check out [some of my past submissions](https://codeforces.com/contest/1168/submission/55200038).
+For help in getting started, you may check out [some of my past submissions](https://codeforces.com/contest/1168/submission/55200038) (requires login).
 
 ## Programming Language Advocacy
 
diff --git a/src/graph/flow.rs b/src/graph/flow.rs
@@ -143,7 +143,7 @@ impl FlowGraph {
         let (mut min_cost, mut max_flow) = (0, 0);
         loop {
             let par = self.mcf_search(s, &flow, &mut pot);
-            if par[t] == None {
+            if par[t].is_none() {
                 break;
             }
             let (dc, df) = self.mcf_augment(t, &par, &mut flow);
diff --git a/src/graph/mod.rs b/src/graph/mod.rs
@@ -111,7 +111,7 @@ pub struct AdjListIterator<'a> {
     next_e: Option<usize>,
 }
 
-impl<'a> Iterator for AdjListIterator<'a> {
+impl Iterator for AdjListIterator<'_> {
     type Item = (usize, usize);
 
     /// Produces an outgoing edge and vertex.
diff --git a/src/graph/util.rs b/src/graph/util.rs
@@ -12,16 +12,16 @@ impl Graph {
             .map(|u| self.adj_list(u))
             .collect::<Vec<_>>();
         let mut edges = Vec::with_capacity(self.num_e());
-        self.euler_recurse(u, &mut adj_iters, &mut edges);
+        Self::euler_recurse(u, &mut adj_iters, &mut edges);
         edges.reverse();
         edges
     }
 
     // Helper function used by euler_path. Note that we can't use a for-loop
     // that would consume the adjacency list as recursive calls may need it.
-    fn euler_recurse(&self, u: usize, adj: &mut [AdjListIterator], edges: &mut Vec<usize>) {
+    fn euler_recurse(u: usize, adj: &mut [AdjListIterator], edges: &mut Vec<usize>) {
         while let Some((e, v)) = adj[u].next() {
-            self.euler_recurse(v, adj, edges);
+            Self::euler_recurse(v, adj, edges);
             edges.push(e);
         }
     }
@@ -42,7 +42,7 @@ impl Graph {
     // Single-source shortest paths on a directed graph with non-negative weights
     pub fn dijkstra(&self, weights: &[u64], u: usize) -> Vec<u64> {
         assert_eq!(self.num_e(), weights.len());
-        let mut dist = vec![u64::max_value(); weights.len()];
+        let mut dist = vec![u64::MAX; weights.len()];
         let mut heap = std::collections::BinaryHeap::new();
 
         dist[u] = 0;
@@ -82,7 +82,7 @@ pub struct DfsIterator<'a> {
     adj_iters: Vec<AdjListIterator<'a>>,
 }
 
-impl<'a> Iterator for DfsIterator<'a> {
+impl Iterator for DfsIterator<'_> {
     type Item = (usize, usize);
 
     /// Returns next edge and vertex in the depth-first traversal
diff --git a/src/li_chao.rs b/src/li_chao.rs
@@ -1,16 +1,15 @@
 /// A structure for answering maximum queries on a set of linear functions. Supports two
-/// operations: inserting a linear function and querying for maximum at a given point. 
+/// operations: inserting a linear function and querying for maximum at a given point.
 /// The queries can be done in any order, and we can do all the calculations using integers.
 /// https://cp-algorithms.com/geometry/convex_hull_trick.html#li-chao-tree
 /// Compared to the code in the above link, this implementation further improves the algorithm by
 /// reducing the number of nodes to (right - left). This is done by removing the midpoint of a
 /// segment from both children. Even better, this allows the index of a node to just be the
 /// midpoint of the interval!
-
+///
 /// Just like normal segment trees, this could be modified to a dynamic tree when the range is
 /// huge, or if the queries are known in advance the x-coordinates can be compressed.
 /// (it can also be made persistent!).
-
 pub struct LiChaoTree {
     left: i64,
     right: i64,
@@ -23,7 +22,7 @@ impl LiChaoTree {
         Self {
             left,
             right,
-            lines: vec![(0, std::i64::MIN); (right - left) as usize],
+            lines: vec![(0, i64::MIN); (right - left) as usize],
         }
     }
 
@@ -100,7 +99,7 @@ mod test {
         ];
         let mut li_chao = LiChaoTree::new(0, 6);
 
-        assert_eq!(li_chao.evaluate(0), std::i64::MIN);
+        assert_eq!(li_chao.evaluate(0), i64::MIN);
         for (&(slope, intercept), expected) in lines.iter().zip(results.iter()) {
             li_chao.max_with(slope, intercept);
             let ys: Vec<i64> = xs.iter().map(|&x| li_chao.evaluate(x)).collect();
diff --git a/src/math/mod.rs b/src/math/mod.rs
@@ -31,11 +31,7 @@ pub fn canon_egcd(a: i64, b: i64, c: i64) -> Option<(i64, i64, i64)> {
 
 // TODO: deduplicate modular arithmetic code with num::Field
 fn pos_mod(n: i64, m: i64) -> i64 {
-    if n < 0 {
-        n + m
-    } else {
-        n
-    }
+    if n < 0 { n + m } else { n }
 }
 fn mod_mul(a: i64, b: i64, m: i64) -> i64 {
     pos_mod((a as i128 * b as i128 % m as i128) as i64, m)
diff --git a/src/range_query/dynamic_arq.rs b/src/range_query/dynamic_arq.rs
@@ -24,7 +24,7 @@ impl<T: ArqSpec> Default for DynamicArqNode<T> {
         Self {
             val: T::identity(),
             app: None,
-            down: (usize::max_value(), usize::max_value()),
+            down: (usize::MAX, usize::MAX),
         }
     }
 }
@@ -97,7 +97,7 @@ impl<T: ArqSpec> DynamicArq<T> {
     }
 
     pub fn push(&mut self, (p, s): ArqView) -> (ArqView, ArqView) {
-        if self.nodes[p].down.0 == usize::max_value() {
+        if self.nodes[p].down.0 == usize::MAX {
             self.nodes.push(DynamicArqNode::default());
             self.nodes.push(DynamicArqNode::default());
             self.nodes[p].down = (self.nodes.len() - 2, self.nodes.len() - 1)
diff --git a/src/range_query/specs.rs b/src/range_query/specs.rs
@@ -50,7 +50,7 @@ impl ArqSpec for AssignMin {
         a.min(b)
     }
     fn identity() -> Self::S {
-        i64::max_value()
+        i64::MAX
     }
     fn compose(&f: &Self::F, _: &Self::F) -> Self::F {
         f
diff --git a/src/range_query/static_arq.rs b/src/range_query/static_arq.rs
@@ -50,14 +50,14 @@ impl<T: ArqSpec> StaticArq<T> {
 
     fn push(&mut self, p: usize) {
         if let Some(ref f) = self.app[p].take() {
-            let s = ((self.app.len() + p - 1) / p / 2).next_power_of_two() as i64;
+            let s = (self.app.len().div_ceil(p) / 2).next_power_of_two() as i64;
             self.apply(p << 1, f, s);
-            self.apply(p << 1 | 1, f, s);
+            self.apply((p << 1) | 1, f, s);
         }
     }
 
     fn pull(&mut self, p: usize) {
-        self.val[p] = T::op(&self.val[p << 1], &self.val[p << 1 | 1]);
+        self.val[p] = T::op(&self.val[p << 1], &self.val[(p << 1) | 1]);
     }
 
     fn push_to(&mut self, p: usize) {
diff --git a/src/string_proc.rs b/src/string_proc.rs
@@ -1,6 +1,6 @@
 //! String processing algorithms.
 use std::cmp::{max, min};
-use std::collections::{hash_map::Entry, HashMap, VecDeque};
+use std::collections::{HashMap, VecDeque, hash_map::Entry};
 
 /// Prefix trie, easily augmentable by adding more fields and/or methods
 pub struct Trie<C: std::hash::Hash + Eq> {
diff --git a/tests/codeforces343d.rs b/tests/codeforces343d.rs
@@ -4,7 +4,7 @@
 //! Also, use the commented code in main() to employ standard I/O.
 extern crate contest_algorithms;
 use contest_algorithms::graph::Graph;
-use contest_algorithms::range_query::{specs::AssignSum, StaticArq};
+use contest_algorithms::range_query::{StaticArq, specs::AssignSum};
 use contest_algorithms::scanner::Scanner;
 use std::io;
 

Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ impl FlowGraph {`
`143`	`143`	`let (mut min_cost, mut max_flow) = (0, 0);`
`144`	`144`	`loop {`
`145`	`145`	`let par = self.mcf_search(s, &flow, &mut pot);`
`146`		`- if par[t] == None {`
	`146`	`+ if par[t].is_none() {`
`147`	`147`	`break;`
`148`	`148`	`}`
`149`	`149`	`let (dc, df) = self.mcf_augment(t, &par, &mut flow);`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ pub struct AdjListIterator<'a> {`
`111`	`111`	`next_e: Option<usize>,`
`112`	`112`	`}`
`113`	`113`
`114`		`-impl<'a> Iterator for AdjListIterator<'a> {`
	`114`	`+impl Iterator for AdjListIterator<'_> {`
`115`	`115`	`type Item = (usize, usize);`
`116`	`116`
`117`	`117`	`/// Produces an outgoing edge and vertex.`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ impl<T: ArqSpec> Default for DynamicArqNode<T> {`
`24`	`24`	`Self {`
`25`	`25`	`val: T::identity(),`
`26`	`26`	`app: None,`
`27`		`- down: (usize::max_value(), usize::max_value()),`
	`27`	`+ down: (usize::MAX, usize::MAX),`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`	`}`
`@@ -97,7 +97,7 @@ impl<T: ArqSpec> DynamicArq<T> {`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`pub fn push(&mut self, (p, s): ArqView) -> (ArqView, ArqView) {`
`100`		`- if self.nodes[p].down.0 == usize::max_value() {`
	`100`	`+ if self.nodes[p].down.0 == usize::MAX {`
`101`	`101`	`self.nodes.push(DynamicArqNode::default());`
`102`	`102`	`self.nodes.push(DynamicArqNode::default());`
`103`	`103`	`self.nodes[p].down = (self.nodes.len() - 2, self.nodes.len() - 1)`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ impl ArqSpec for AssignMin {`
`50`	`50`	`a.min(b)`
`51`	`51`	`}`
`52`	`52`	`fn identity() -> Self::S {`
`53`		`- i64::max_value()`
	`53`	`+ i64::MAX`
`54`	`54`	`}`
`55`	`55`	`fn compose(&f: &Self::F, _: &Self::F) -> Self::F {`
`56`	`56`	`f`
Original file line number	Diff line number	Diff line change
`@@ -50,14 +50,14 @@ impl<T: ArqSpec> StaticArq<T> {`
`50`	`50`
`51`	`51`	`fn push(&mut self, p: usize) {`
`52`	`52`	`if let Some(ref f) = self.app[p].take() {`
`53`		`- let s = ((self.app.len() + p - 1) / p / 2).next_power_of_two() as i64;`
	`53`	`+ let s = (self.app.len().div_ceil(p) / 2).next_power_of_two() as i64;`
`54`	`54`	`self.apply(p << 1, f, s);`
`55`		`- self.apply(p << 1 \| 1, f, s);`
	`55`	`+ self.apply((p << 1) \| 1, f, s);`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`fn pull(&mut self, p: usize) {`
`60`		`- self.val[p] = T::op(&self.val[p << 1], &self.val[p << 1 \| 1]);`
	`60`	`+ self.val[p] = T::op(&self.val[p << 1], &self.val[(p << 1) \| 1]);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`fn push_to(&mut self, p: usize) {`