Rust 2024 edition

Author: EbTech

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"

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
 

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);

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.

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

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();

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)

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)

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

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) {

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> {

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;