Added prefix trie, eliminated Clippy warnings

Author: EbTech

.gitignore

@@ -1 +1,3 @@
-target
+target/
+**/*.rs.bk
+Cargo.lock

src/graph/dfs.rs

@@ -38,9 +38,8 @@ impl<'a> Iterator for DfsIterator<'a> {
         // https://www.geeksforgeeks.org/iterative-depth-first-traversal/
         // https://en.wikipedia.org/wiki/Depth-first_search
         while let Some(&s) = self.stack.last() {
-
             //Does s still have neighbors we need to process?
-            if let Some((_,s_nbr)) = self.adj_iters[s].next() {
+            if let Some((_, s_nbr)) = self.adj_iters[s].next() {
                 if !self.visited[s_nbr] {
                     self.stack.push(s_nbr);
                 }
@@ -109,13 +108,13 @@ mod test {
         let mut dfs_check = vec![];
         for _ in 0..num_v {
             dfs_check.push(dfs_search.next().unwrap());
-            assert!(dfs_search.stack.len() <= num_v+1);
+            assert!(dfs_search.stack.len() <= num_v + 1);
         }
 
         dfs_check.sort();
         dfs_check.dedup();
         assert_eq!(0, dfs_check[0]);
         assert_eq!(num_v, dfs_check.len());
-        assert_eq!(num_v-1, dfs_check[num_v-1]);
+        assert_eq!(num_v - 1, dfs_check[num_v - 1]);
     }
 }

src/math.rs

@@ -17,28 +17,28 @@ pub fn mod_pow(mut base: u64, mut exp: u64, m: u64) -> u64 {
     result
 }
 
-/// Finds (d, x, y) such that d = gcd(a, b) = ax + by.
+/// Finds (d, coef_a, coef_b) such that d = gcd(a, b) = a * coef_a + b * coef_b.
 pub fn extended_gcd(a: i64, b: i64) -> (i64, i64, i64) {
     if b == 0 {
         (a.abs(), a.signum(), 0)
     } else {
-        let (d, x, y) = extended_gcd(b, a % b);
-        (d, y, x - y * (a / b))
+        let (d, coef_a, coef_b) = extended_gcd(b, a % b);
+        (d, coef_b, coef_a - coef_b * (a / b))
     }
 }
 
-/// Assuming a != 0, finds smallest y >= 0 such that ax + by = c.
+/// Assuming a != 0, finds smallest coef_b >= 0 such that a * coef_a + b * coef_b = c.
 ///
 /// # Panics
 ///
 /// Panics if a == 0.
 pub fn canon_egcd(a: i64, b: i64, c: i64) -> Option<(i64, i64, i64)> {
-    let (d, _, yy) = extended_gcd(a, b);
+    let (d, _, coef_b_init) = extended_gcd(a, b);
     if c % d == 0 {
-        let z = (a / d).abs();
-        let y = (yy * (c / d) % z + z) % z;
-        let x = (c - b * y) / a;
-        Some((d, x, y))
+        let a_d = (a / d).abs();
+        let coef_b = (coef_b_init * (c / d) % a_d + a_d) % a_d;
+        let coef_a = (c - b * coef_b) / a;
+        Some((d, coef_a, coef_b))
     } else {
         None
     }

src/string_proc.rs

@@ -90,7 +90,7 @@ impl SuffixArray {
     /// Suffix array construction in O(n log n) time.
     pub fn new(text: &[u8]) -> Self {
         let n = text.len();
-        let init_rank = text.into_iter().map(|&ch| ch as usize).collect::<Vec<_>>();
+        let init_rank = text.iter().map(|&ch| ch as usize).collect::<Vec<_>>();
         let mut sfx = Self::counting_sort(0..n, &init_rank, 256);
         let mut rank = vec![init_rank];
         // Invariant at the start of every loop iteration:
@@ -137,6 +137,39 @@ impl SuffixArray {
     }
 }
 
+/// Prefix trie
+#[derive(Default)]
+pub struct Trie<K: std::hash::Hash + Eq> {
+    count: usize,
+    branches: std::collections::HashMap<K, Trie<K>>,
+}
+
+impl<K: std::hash::Hash + Eq + Default> Trie<K> {
+    /// Inserts a word into the trie.
+    pub fn insert(&mut self, word: impl IntoIterator<Item = K>) {
+        let mut node = self;
+        node.count += 1;
+
+        for ch in word {
+            node = { node }.branches.entry(ch).or_insert_with(Default::default);
+            node.count += 1;
+        }
+    }
+
+    /// Computes the number of inserted words that start with the given prefix.
+    pub fn get(&self, prefix: impl IntoIterator<Item = K>) -> usize {
+        let mut node = self;
+
+        for ch in prefix {
+            match node.branches.get(&ch) {
+                Some(sub) => node = sub,
+                None => return 0,
+            }
+        }
+        node.count
+    }
+}
+
 /// Manacher's algorithm for computing palindrome substrings in linear time.
 /// pal[2*i] = odd length of palindrome centred at text[i].
 /// pal[2*i+1] = even length of palindrome centred at text[i+0.5].
@@ -208,6 +241,24 @@ mod test {
         }
     }
 
+    #[test]
+    fn test_trie() {
+        let dict = vec!["banana", "benefit", "banapple", "ban"];
+
+        let trie = dict.into_iter().fold(Trie::default(), |mut trie, word| {
+            Trie::insert(&mut trie, word.bytes());
+            trie
+        });
+
+        assert_eq!(trie.get("".bytes()), 4);
+        assert_eq!(trie.get("b".bytes()), 4);
+        assert_eq!(trie.get("ba".bytes()), 3);
+        assert_eq!(trie.get("ban".bytes()), 3);
+        assert_eq!(trie.get("bana".bytes()), 2);
+        assert_eq!(trie.get("banan".bytes()), 1);
+        assert_eq!(trie.get("bane".bytes()), 0);
+    }
+
     #[test]
     fn test_palindrome() {
         let text = "banana".as_bytes();