Add maxflow

examples/practice2_d_maxflow.rs

@@ -0,0 +1,64 @@
+use ac_library_rs::MfGraph;
+use std::io::Read;
+
+#[allow(clippy::many_single_char_names)]
+#[allow(clippy::needless_range_loop)]
+fn main() {
+    const N: usize = 128;
+
+    let mut buf = String::new();
+    std::io::stdin().read_to_string(&mut buf).unwrap();
+    let mut input = buf.split_whitespace();
+
+    let n: usize = input.next().unwrap().parse().unwrap();
+    let m: usize = input.next().unwrap().parse().unwrap();
+    let mut s = vec![vec![false; N]; N];
+    for i in 1..=n {
+        for (j, c) in (1..=m).zip(input.next().unwrap().chars()) {
+            s[i][j] = c == '.';
+        }
+    }
+
+    let dy = [1, 0, -1, 0];
+    let dx = [0, 1, 0, -1];
+    let c = "v>^<".chars().collect::<Vec<_>>();
+    let mut graph = MfGraph::<i32>::new(128 * 128);
+
+    for i in 1..=n {
+        for j in 1..=m {
+            if (i + j) % 2 == 0 {
+                graph.add_edge(0, i * N + j, 1);
+                for (dy, dx) in dy.iter().zip(dx.iter()) {
+                    let k = (i as i32 + dy) as usize;
+                    let l = (j as i32 + dx) as usize;
+                    if s[i][j] && s[k][l] {
+                        graph.add_edge(i * N + j, k * N + l, 1);
+                    }
+                }
+            } else {
+                graph.add_edge(i * N + j, 1, 1);
+            }
+        }
+    }
+    println!("{}", graph.flow(0, 1));
+    let mut res: Vec<Vec<_>> = (1..=n)
+        .map(|i| (1..=m).map(|j| if s[i][j] { '.' } else { '#' }).collect())
+        .collect();
+    for e in graph.edges() {
+        let i = e.from / N;
+        let j = e.from % N;
+        let k = e.to / N;
+        let l = e.to % N;
+        if e.flow == 1 {
+            for h in 0..4 {
+                if i as i32 + dy[h] == k as i32 && j as i32 + dx[h] == l as i32 {
+                    res[i - 1][j - 1] = c[h];
+                    res[k - 1][l - 1] = c[h ^ 2];
+                }
+            }
+        }
+    }
+    for s in res {
+        println!("{}", s.iter().collect::<String>());
+    }
+}

src/internal_queue.rs

@@ -1 +1,104 @@
+#![allow(dead_code)]
 
+#[derive(Default)]
+pub(crate) struct SimpleQueue<T> {
+    payload: Vec<T>,
+    pos: usize,
+}
+
+impl<T> SimpleQueue<T> {
+    pub(crate) fn reserve(&mut self, n: usize) {
+        if n > self.payload.len() {
+            self.payload.reserve(n - self.payload.len());
+        }
+    }
+
+    pub(crate) fn size(&self) -> usize {
+        self.payload.len() - self.pos
+    }
+
+    pub(crate) fn empty(&self) -> bool {
+        self.pos == self.payload.len()
+    }
+
+    pub(crate) fn push(&mut self, t: T) {
+        self.payload.push(t);
+    }
+
+    // Do we need mutable version?
+    pub(crate) fn front(&self) -> Option<&T> {
+        if self.pos < self.payload.len() {
+            Some(&self.payload[self.pos])
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn clear(&mut self) {
+        self.payload.clear();
+        self.pos = 0;
+    }
+
+    pub(crate) fn pop(&mut self) -> Option<&T> {
+        if self.pos < self.payload.len() {
+            self.pos += 1;
+            Some(&self.payload[self.pos - 1])
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::internal_queue::SimpleQueue;
+
+    #[allow(clippy::cognitive_complexity)]
+    #[test]
+    fn test_simple_queue() {
+        let mut queue = SimpleQueue::default();
+
+        assert_eq!(queue.size(), 0);
+        assert!(queue.empty());
+        assert!(queue.front().is_none());
+        assert!(queue.pop().is_none());
+
+        queue.push(123);
+
+        assert_eq!(queue.size(), 1);
+        assert!(!queue.empty());
+        assert_eq!(queue.front(), Some(&123));
+
+        queue.push(456);
+
+        assert_eq!(queue.size(), 2);
+        assert!(!queue.empty());
+        assert_eq!(queue.front(), Some(&123));
+
+        assert_eq!(queue.pop(), Some(&123));
+        assert_eq!(queue.size(), 1);
+        assert!(!queue.empty());
+        assert_eq!(queue.front(), Some(&456));
+
+        queue.push(789);
+        queue.push(789);
+        queue.push(456);
+        queue.push(456);
+
+        assert_eq!(queue.size(), 5);
+        assert!(!queue.empty());
+        assert_eq!(queue.front(), Some(&456));
+
+        assert_eq!(queue.pop(), Some(&456));
+        assert_eq!(queue.size(), 4);
+        assert!(!queue.empty());
+        assert_eq!(queue.front(), Some(&789));
+
+        queue.clear();
+
+        assert_eq!(queue.size(), 0);
+        assert!(queue.empty());
+        assert!(queue.front().is_none());
+        assert!(queue.pop().is_none());
+    }
+}

src/lib.rs

@@ -21,6 +21,7 @@ pub(crate) mod internal_type_traits;
 pub use dsu::Dsu;
 pub use fenwicktree::FenwickTree;
 pub use math::{crt, floor_sum, inv_mod, pow_mod};
+pub use maxflow::{Edge, MfGraph};
 pub use mincostflow::MinCostFlowGraph;
 pub use string::{
     lcp_array, lcp_array_arbitrary, suffix_array, suffix_array_arbitrary, suffix_array_manual,