Refactoring

Author: tanakh

Cargo.toml

@@ -2,5 +2,7 @@
 name = "competitive"
 version = "0.1.0"
 authors = ["Hideyuki Tanaka <[email protected]>"]
+edition = "2018"
 
 [dependencies]
+proconio = "0.3"

examples/atc001_b.rs

@@ -1,7 +1,5 @@
-extern crate competitive;
-
-#[macro_use]
-use competitive::*;
+use competitive::prelude::*;
+use competitive::union_find::*;
 
 fn main() {
     // let ss = io::read_string();
@@ -10,13 +8,13 @@ fn main() {
     // let q: usize = sc.next();
     // let qs: Vec<(i32, usize, usize)> = (0..q).map(|_| (sc.next(), sc.next(), sc.next())).collect();
 
-    input!{
+    input! {
         n: usize,
         q: usize,
         qs: [(i32, usize, usize); q],
     }
 
-    let mut uf = union_find::UnionFind::new(n);
+    let mut uf = UnionFind::new(n);
     for (p, a, b) in qs {
         if p == 0 {
             uf.union(a, b);

examples/bench.rs

@@ -1,10 +1,7 @@
-extern crate competitive;
-
-#[macro_use]
-use competitive::*;
+use competitive::prelude::*;
 
 fn main() {
-    input!{
+    input! {
         n: usize,
         v: [usize; n],
     }

src/binary_search.rs

@@ -0,0 +1,19 @@
+pub fn binary_search(mut ok: i64, mut ng: i64, pred: impl Fn(i64) -> bool) -> i64 {
+    while (ok - ng).abs() > 1 {
+        let mi = (ok + ng) / 2;
+        if pred(mi) {
+            ok = mi;
+        } else {
+            ng = mi;
+        }
+    }
+    ok
+}
+
+#[test]
+fn binary_search_test() {
+    let v = [1, 2, 3, 4, 5];
+    assert_eq!(3, binary_search(v.len() as _, -1, |i| v[i as usize] > 3));
+    assert_eq!(5, binary_search(v.len() as _, -1, |i| v[i as usize] > 100));
+    assert_eq!(0, binary_search(v.len() as _, -1, |i| v[i as usize] > 0));
+}

src/graph.rs

@@ -0,0 +1,60 @@
+use std::cmp::min;
+use std::collections::VecDeque;
+
+pub fn visit(
+    g: &Vec<Vec<usize>>,
+    v: usize,
+    scc: &mut Vec<Vec<usize>>,
+    s: &mut VecDeque<usize>,
+    ins: &mut Vec<bool>,
+    low: &mut Vec<usize>,
+    num: &mut Vec<usize>,
+    time: usize,
+) {
+    low[v] = time;
+    num[v] = time;
+
+    s.push_back(v);
+    ins[v] = true;
+
+    for &e in g[v].iter() {
+        let w = e;
+        if num[w] == 0 {
+            visit(g, w, scc, s, ins, low, num, time + 1);
+            low[v] = min(low[v], low[w]);
+        } else if ins[w] {
+            low[v] = min(low[v], num[w]);
+        }
+    }
+
+    if low[v] == num[v] {
+        let mut c = vec![];
+        loop {
+            let w = s.pop_back().unwrap();
+            ins[w] = false;
+            c.push(w);
+            if v == w {
+                break;
+            }
+        }
+        scc.push(c);
+    }
+}
+
+pub fn strongly_connected_components(g: &Vec<Vec<usize>>) -> Vec<Vec<usize>> {
+    let n = g.len();
+
+    let mut num = vec![0; n];
+    let mut low = vec![0; n];
+    let mut s = VecDeque::new();
+    let mut ins = vec![false; n];
+    let mut scc = vec![];
+
+    for u in 0..n {
+        if num[u] == 0 {
+            visit(g, u, &mut scc, &mut s, &mut ins, &mut low, &mut num, 1);
+        }
+    }
+
+    scc
+}

src/inf.rs

@@ -0,0 +1,42 @@
+use std::cmp::min;
+use std::ops::Add;
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub enum Inf<T> {
+    NotInf(T),
+    Inf,
+}
+
+use self::Inf::*;
+
+impl<T> From<T> for Inf<T> {
+    fn from(v: T) -> Self {
+        Inf::NotInf(v)
+    }
+}
+
+impl<T: Add<Output = T>> Add for Inf<T> {
+    type Output = Inf<T>;
+    fn add(self, rhs: Self) -> Self {
+        match (self, rhs) {
+            (NotInf(a), NotInf(b)) => NotInf(a + b),
+            _ => Inf,
+        }
+    }
+}
+
+impl<T: Add<Output = T>> Add<T> for Inf<T> {
+    type Output = Inf<T>;
+    fn add(self, rhs: T) -> Self {
+        match self {
+            NotInf(a) => NotInf(a + rhs),
+            _ => Inf,
+        }
+    }
+}
+
+impl<T: Clone + Ord> Inf<T> {
+    pub fn min_assign(&mut self, rhs: Self) {
+        *self = min(self.clone(), rhs);
+    }
+}

src/io.rs

@@ -0,0 +1,55 @@
+use std::io::Read;
+use std::str::FromStr;
+
+/// Input scanner
+///
+/// # Examples
+///
+/// ```
+/// # use competitive::io::*;
+/// let mut sc = Scanner::new("1 3.14 Hello");
+/// assert_eq!(sc.next::<i32>(), 1);
+/// assert_eq!(sc.next::<f64>(), 3.14);
+/// assert_eq!(sc.next::<String>(), "Hello");
+/// ```
+pub struct Scanner<'a> {
+    iter: std::str::SplitWhitespace<'a>,
+}
+
+impl<'a> Scanner<'a> {
+    pub fn new(s: &'a str) -> Scanner<'a> {
+        Scanner {
+            iter: s.split_whitespace(),
+        }
+    }
+
+    pub fn next<T: FromStr>(&mut self) -> T {
+        let s = self.iter.next().unwrap();
+        if let Ok(v) = s.parse::<T>() {
+            v
+        } else {
+            panic!("Parse error")
+        }
+    }
+
+    pub fn next_vec_len<T: FromStr>(&mut self) -> Vec<T> {
+        let n: usize = self.next();
+        self.next_vec(n)
+    }
+
+    pub fn next_vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {
+        (0..n).map(|_| self.next()).collect()
+    }
+}
+
+pub fn read_string() -> String {
+    let mut s = String::new();
+    std::io::stdin().read_to_string(&mut s).unwrap();
+    s
+}
+
+pub fn read_line() -> String {
+    let mut s = String::new();
+    std::io::stdin().read_line(&mut s).unwrap();
+    s.trim_end().to_owned()
+}