Updated to Rust 1.21

Author: EbTech

.travis.yml

@@ -3,7 +3,7 @@ rust:
   - stable
   - beta
   - nightly
-  - 1.19.0 # Current version supported by Codeforces
+  - 1.21.0 # Current version supported by Codeforces
 matrix:
   allow_failures:
     - rust: nightly

README.md

@@ -16,11 +16,15 @@ In addition, the Rust language has outstanding pedagogical attributes. Its compi
 
 The original intent of this project was to build a reference for use in programming contests such as [Codeforces](http://codeforces.com) and the [Google Code Jam](https://code.google.com/codejam). As a result, it contains algorithms that are frequently useful to have in one's toolkit, with an emphasis on making the code concise and easy to modify under time pressure.
 
-Most competition programmers use C++ for its fast execution time. However, it's notoriously unsafe, wasting a considerable share of the contestant's time and attention on accident prevention and debugging. Java is the next most popular choice, offering a little safety at some expense to coding and execution speed. To my delight, I found that Rust provides even more safety without the visual clutter, and it's *fast*. A proficient Rust programmer stands to gain a competitive advantage as well as a more pleasant experience!
+Most competition programmers rely on C++ for its fast execution time. However, it's notoriously unsafe, diverting a considerable share of the contestant's time and attention on mistake prevention and debugging. Java is the next most popular choice, offering a little safety at some expense to speed of coding and execution.
+
+To my delight, I found that Rust provides even more safety without the visual clutter, and it's *fast*. A proficient Rust programmer stands to gain a competitive advantage as well as a more pleasant experience!
 
 ## Programming Language Advocacy
 
-My other goal is to appeal to developers who feel, as I once did, trapped between the lesser of headaches among old mainstream languages (e.g., C++/Java), to raise awareness that *it doesn't have to be this way*. Rather than trying to persuade you with words, this repository aims to show by example and ease the learning curve. See [Jim Blandy's *Why Rust?*](http://www.oreilly.com/programming/free/files/why-rust.pdf) for a brief introduction, or just [dive in!](https://doc.rust-lang.org/book/second-edition/)
+My other goal is to appeal to developers who feel, as I once did, trapped between the lesser of headaches among old mainstream languages (e.g., C++/Java), to raise awareness that *it doesn't have to be this way*.
+
+Rather than try to persuade you with words, this repository aims to show by example while easing the learning curve. See [Jim Blandy's *Why Rust?*](http://www.oreilly.com/programming/free/files/why-rust.pdf) for a brief introduction, or just [dive in!](https://doc.rust-lang.org/book/second-edition/)
 
 ## Contents
 

src/arq_tree.rs

@@ -132,13 +132,38 @@ pub trait ArqSpec {
     fn identity() -> Self::M;
 }
 
-/// In this example, we want to support range sum queries and range constant
-/// assignments. Note that constant assignment f_c(a) = c is not a endomorphism
-/// on (i64, +) because f_c(a+b) = c != 2*c = f_c(a) + f_c(b). In intuitive
-/// terms, the problem is that the internal nodes of the tree should really be
-/// set to a multiple of c, corresponding to the subtree size. So let's augment
-/// the monoid type with size information, using the 2D vector (a_i,1) instead
-/// of a_i. Now check that f_c((a, s)) = (c*s, s) is indeed an endomorphism on
+/// Range Minimum Query, a classic application of associative range query.
+// Exercises: try augmenting this struct to find the index of a minimum element
+// in a range query, as well as the number of elements that match the minimum.
+// Then instead of assigning to a range, try to support the operation of
+// incrementing each element in a range by a given offset!
+pub struct AssignMin;
+
+impl ArqSpec for AssignMin {
+    type F = i64;
+    type M = i64;
+    fn compose(f: &Self::F, _: &Self::F) -> Self::F {
+        *f
+    }
+    fn apply(f: &Self::F, _: &Self::M) -> Self::M {
+        *f
+    }
+    fn op(a: &Self::M, b: &Self::M) -> Self::M {
+        (*a).min(*b)
+    }
+    fn identity() -> Self::M {
+        Self::M::max_value()
+    }
+}
+
+/// A slightly more advanced application, where we aim to support range sum
+/// queries and range constant assignments.
+/// Note that constant assignment f_c(a) = c is not a endomorphism on (i64, +)
+/// because f_c(a+b) = c != 2*c = f_c(a) + f_c(b). In intuitive terms, the
+/// problem is that the internal nodes of the tree should not simply be set to
+/// c, but rather, to c multiplied by the subtree size. So let's augment the
+/// monoid type with size information, using the 2D vector (a_i,1) instead of
+/// a_i. Now check that f_c((a, s)) = (c*s, s) is indeed an endomorphism on
 /// vector addition: f_c((a,s)+(b,t)) = f_c((a+b,s+t)) = (c*(s+t),s+t)
 ///                 = (c*s,s)+(c*t,t) = f_c((a,s)) + f_c((b,t)).
 ///
@@ -164,30 +189,6 @@ impl ArqSpec for AssignSum {
     }
 }
 
-/// Range Minimum Query, a classic form of associative range query.
-// Exercises: try augmenting this struct to find the index of a minimum element
-// in a range query, as well as the number of elements that match the minimum.
-// Then instead of assigning to a range, try to support the operation of
-// incrementing each element in a range by a given offset!
-pub struct AssignMin;
-
-impl ArqSpec for AssignMin {
-    type F = i64;
-    type M = i64;
-    fn compose(f: &Self::F, _: &Self::F) -> Self::F {
-        *f
-    }
-    fn apply(f: &Self::F, _: &Self::M) -> Self::M {
-        *f
-    }
-    fn op(a: &Self::M, b: &Self::M) -> Self::M {
-        ::std::cmp::min(*a, *b)
-    }
-    fn identity() -> Self::M {
-        Self::M::max_value()
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

src/graph/connectivity.rs

@@ -1,6 +1,5 @@
 //! Graph connectivity structures.
 use graph::Graph;
-use std::cmp::min;
 
 /// Represents the decomposition of a graph into any of its constituent parts:
 ///
@@ -78,7 +77,7 @@ impl<'a> ConnectivityGraph<'a> {
                 self.scc(v, t, vis, low, v_stack);
             }
             if self.cc[v] == 0 {
-                low[u] = min(low[u], low[v]);
+                low[u] = low[u].min(low[v]);
             }
         }
         if vis[u] == low[u] {
@@ -112,7 +111,7 @@ impl<'a> ConnectivityGraph<'a> {
     /// order. Undefined behavior if the graph is not a DAG.
     pub fn topological_sort(&self) -> Vec<usize> {
         let mut vertices = (0..self.graph.num_v()).collect::<Vec<_>>();
-        vertices.sort_by_key(|&u| self.num_cc - self.cc[u]);
+        vertices.sort_unstable_by_key(|&u| self.num_cc - self.cc[u]);
         vertices
     }
 
@@ -134,7 +133,7 @@ impl<'a> ConnectivityGraph<'a> {
             if vis[v] == 0 {
                 e_stack.push(e);
                 self.bcc(v, e, t, vis, low, v_stack, e_stack);
-                low[u] = min(low[u], low[v]);
+                low[u] = low[u].min(low[v]);
                 if vis[u] <= low[v] {
                     // u is a cut vertex unless it's a one-child root
                     self.num_vcc += 1;
@@ -147,7 +146,7 @@ impl<'a> ConnectivityGraph<'a> {
                     }
                 }
             } else if vis[v] < vis[u] && e ^ par != 1 {
-                low[u] = min(low[u], vis[v]);
+                low[u] = low[u].min(vis[v]);
                 e_stack.push(e);
             } else if v == u {
                 // e is a self-loop

src/graph/flow.rs

@@ -1,7 +1,6 @@
 //! Maximum flows, matchings, and minimum cuts.
 use graph::{Graph, AdjListIterator};
-use std::cmp::min;
-const INF: i64 = 0x3f3f3f3f;
+const INF: i64 = 0x3f3f3f3f3f3f3f3f;
 
 /// Representation of a network flow problem with (optional) costs.
 pub struct FlowGraph {
@@ -91,7 +90,7 @@ impl FlowGraph {
         let mut df = 0;
 
         while let Some(&(e, v)) = adj[u].peek() {
-            let rem_cap = min(self.cap[e] - flow[e], f - df);
+            let rem_cap = (self.cap[e] - flow[e]).min(f - df);
             if rem_cap > 0 && dist[v] == dist[u] + 1 {
                 let cf = self.dinic_augment(v, t, rem_cap, dist, adj, flow);
                 flow[e] += cf;
@@ -133,7 +132,7 @@ impl FlowGraph {
                 if self.cap[e] > 0 {
                     let u = self.graph.endp[e ^ 1];
                     let v = self.graph.endp[e];
-                    pot[v] = min(pot[v], pot[u] + self.cost[e]);
+                    pot[v] = pot[v].min(pot[u] + self.cost[e]);
                 }
             }
         }
@@ -181,7 +180,7 @@ impl FlowGraph {
         let (mut dc, mut df) = (0, INF);
         let mut u = t;
         while let Some(e) = par[u] {
-            df = min(df, self.cap[e] - flow[e]);
+            df = df.min(self.cap[e] - flow[e]);
             u = self.graph.endp[e ^ 1];
         }
         u = t;

src/graph/mod.rs

@@ -128,7 +128,7 @@ impl Graph {
     pub fn min_spanning_tree(&self, weights: &[i64]) -> Vec<usize> {
         assert_eq!(self.num_e(), 2 * weights.len());
         let mut edges = (0..weights.len()).collect::<Vec<_>>();
-        edges.sort_by_key(|&e| weights[e]);
+        edges.sort_unstable_by_key(|&e| weights[e]);
 
         let mut components = DisjointSets::new(self.num_v());
         edges

src/string_proc.rs

@@ -61,7 +61,7 @@ pub fn palindromes(text: &[u8]) -> Vec<usize> {
     pal.push(1);
     while pal.len() < pal.capacity() {
         let i = pal.len() - 1;
-        let max_len = ::std::cmp::min(i + 1, pal.capacity() - i);
+        let max_len = (i + 1).min(pal.capacity() - i);
         while pal[i] < max_len && text[(i - pal[i] - 1) / 2] == text[(i + pal[i] + 1) / 2] {
             pal[i] += 2;
         }