Bipartite matching (#65)

lrvideckis · web-flow · commit 00cc846c0bf5 · 2024-06-20T10:13:09.000-05:00
* adding progress

* finish yosupo test

* nit

* finish docs

* fix code cov

* another rename

* move duplicate code to new file

* I like this way more

* add back other way as aizu test doesn't check actual matching

* fix one nit

* address another comment

* add comment

* remove duplicate code

* convert

* fix documentation

* finish docs

---------

Co-authored-by: Luke Videckis &lt;lukevideckis@gmail.com&gt;
diff --git a/Cargo.toml b/Cargo.toml
@@ -127,6 +127,14 @@ path = "examples/graphs/hld_jump_on_tree_nodes.rs"
 name = "hld_jump_on_tree_edges"
 path = "examples/graphs/hld_jump_on_tree_edges.rs"
 
+[[example]]
+name = "hopcroft_karp_yosupo"
+path = "examples/graphs/hopcroft_karp_yosupo.rs"
+
+[[example]]
+name = "hopcroft_karp_aizu"
+path = "examples/graphs/hopcroft_karp_aizu.rs"
+
 [[example]]
 name = "lcp_query_yosupo_zfunc"
 path = "examples/strings/lcp_query_yosupo_zfunc.rs"
diff --git a/examples/graphs/hopcroft_karp_aizu.rs b/examples/graphs/hopcroft_karp_aizu.rs
@@ -0,0 +1,33 @@
+// verification-helper: PROBLEM https://onlinejudge.u-aizu.ac.jp/problems/GRL_7_A
+
+use proconio::input;
+use programming_team_code_rust::graphs::hopcroft_karp::HopcroftKarp;
+
+mod hopcroft_karp_asserts;
+use hopcroft_karp_asserts::hopcroft_karp_asserts;
+
+fn main() {
+    input! {
+        lsz: usize,
+        rsz: usize,
+        m: usize,
+        edge_list: [(usize, usize); m],
+    }
+
+    let mut adj = vec![vec![]; lsz];
+    for &(u, v) in edge_list.iter() {
+        adj[u].push(v);
+    }
+
+    let HopcroftKarp {
+        matching_siz,
+        l_to_r,
+        r_to_l,
+        mvc_l,
+        mvc_r,
+    } = HopcroftKarp::new(&adj, rsz);
+
+    hopcroft_karp_asserts(matching_siz, &l_to_r, &r_to_l, &mvc_l, &mvc_r, &edge_list);
+
+    println!("{}", matching_siz);
+}
diff --git a/examples/graphs/hopcroft_karp_asserts.rs b/examples/graphs/hopcroft_karp_asserts.rs
@@ -0,0 +1,33 @@
+pub fn hopcroft_karp_asserts(
+    matching_siz: usize,
+    l_to_r: &[Option<usize>],
+    r_to_l: &[Option<usize>],
+    mvc_l: &[bool],
+    mvc_r: &[bool],
+    edge_list: &[(usize, usize)],
+) {
+    for (left, right) in [(l_to_r, r_to_l), (r_to_l, l_to_r)] {
+        assert_eq!(
+            matching_siz,
+            left.iter().filter(|elem| elem.is_some()).count()
+        );
+        for (i, elem) in left.iter().enumerate().filter(|(_, elem)| elem.is_some()) {
+            assert_eq!(Some(i), right[elem.unwrap()]);
+        }
+    }
+
+    fn count_true(a: &[bool]) -> usize {
+        a.iter().filter(|&&elem| elem).count()
+    }
+    assert_eq!(matching_siz, count_true(mvc_l) + count_true(mvc_r));
+
+    for &(u, v) in edge_list.iter() {
+        // this might look weird, but it's done so that code coverage passes:
+        //
+        // this:
+        // assert!(mvc_l[u] || mvc_r[v]);
+        // will fail code coverage, saying that the false branch is never run
+        let either = mvc_l[u] || mvc_r[v];
+        assert!(either);
+    }
+}
diff --git a/examples/graphs/hopcroft_karp_yosupo.rs b/examples/graphs/hopcroft_karp_yosupo.rs
@@ -0,0 +1,36 @@
+// verification-helper: PROBLEM https://judge.yosupo.jp/problem/bipartitematching
+
+use proconio::input;
+use programming_team_code_rust::graphs::hopcroft_karp::HopcroftKarp;
+
+mod hopcroft_karp_asserts;
+use hopcroft_karp_asserts::hopcroft_karp_asserts;
+
+fn main() {
+    input! {
+        lsz: usize,
+        rsz: usize,
+        m: usize,
+        edge_list: [(usize, usize); m],
+    }
+
+    let mut adj = vec![vec![]; lsz];
+    for &(u, v) in edge_list.iter() {
+        adj[u].push(v);
+    }
+
+    let HopcroftKarp {
+        matching_siz,
+        l_to_r,
+        r_to_l,
+        mvc_l,
+        mvc_r,
+    } = HopcroftKarp::new(&adj, rsz);
+
+    hopcroft_karp_asserts(matching_siz, &l_to_r, &r_to_l, &mvc_l, &mvc_r, &edge_list);
+
+    println!("{}", matching_siz);
+    for (i, elem) in l_to_r.iter().enumerate().filter(|(_, elem)| elem.is_some()) {
+        println!("{} {}", i, elem.unwrap());
+    }
+}
diff --git a/src/graphs/hopcroft_karp.rs b/src/graphs/hopcroft_karp.rs
@@ -0,0 +1,112 @@
+//! # Hopcroft Karp algorithm for Bipartite Matching
+
+use std::collections::VecDeque;
+
+/// # Example
+/// ```
+/// use programming_team_code_rust::graphs::hopcroft_karp::HopcroftKarp;
+///
+/// let mut adj = vec![vec![]; 2];
+/// for (u, v) in [(0, 0), (0, 2), (1, 2)] {
+///    adj[u].push(v);
+/// }
+///
+/// let HopcroftKarp {
+///    matching_siz,
+///    l_to_r,
+///    r_to_l,
+///    mvc_l,
+///    mvc_r,
+/// } = HopcroftKarp::new(&adj, 3);
+///
+/// assert_eq!(matching_siz, 2);
+/// assert_eq!(l_to_r, [Some(0), Some(2)]);
+/// assert_eq!(r_to_l, [Some(0), None, Some(1)]);
+/// assert_eq!(mvc_l, [true, true]);
+/// assert_eq!(mvc_r, [false, false, false]);
+/// ```
+///
+/// # Complexity
+/// - V: number of vertices; V = lsz + rsz
+/// - E: number of edges
+/// - Time: O(V + E * sqrt(v))
+/// - Space: O(V)
+pub struct HopcroftKarp {
+    /// number of edges in matching
+    pub matching_siz: usize,
+    /// l_to_r\[u_left_side\] = Some(v_right_side) iff edge u_left_side <=> v_right_side is in matching
+    pub l_to_r: Vec<Option<usize>>,
+    /// r_to_l\[v_right_side\] = Some(u_left_side) iff edge u_left_side <=> v_right_side is in matching
+    pub r_to_l: Vec<Option<usize>>,
+    /// mvc_l\[u_left_side\] = true iff u_left_side is in min vertex cover
+    pub mvc_l: Vec<bool>,
+    /// mvc_r\[v_right_side\] = true iff v_right_side is in min vertex cover
+    pub mvc_r: Vec<bool>,
+}
+
+impl HopcroftKarp {
+    /// Calculates a max matching and min vertex cover
+    pub fn new(adj: &[Vec<usize>], rsz: usize) -> Self {
+        let lsz = adj.len();
+        let mut e = HopcroftKarp {
+            matching_siz: 0,
+            l_to_r: vec![None; lsz],
+            r_to_l: vec![None; rsz],
+            mvc_l: vec![false; lsz],
+            mvc_r: vec![false; rsz],
+        };
+        loop {
+            let mut dist = vec![usize::MAX; lsz];
+            let mut q = VecDeque::new();
+            for (i, _) in e
+                .l_to_r
+                .iter()
+                .enumerate()
+                .filter(|&(_, elem)| elem.is_none())
+            {
+                dist[i] = 0;
+                q.push_back(i);
+            }
+            let mut found = false;
+            for v in &mut e.mvc_l {
+                *v = true;
+            }
+            for v in &mut e.mvc_r {
+                *v = false;
+            }
+            while let Some(u) = q.pop_front() {
+                e.mvc_l[u] = false;
+                for &v in &adj[u] {
+                    e.mvc_r[v] = true;
+                    if let Some(w) = e.r_to_l[v] {
+                        if dist[w] > 1 + dist[u] {
+                            dist[w] = 1 + dist[u];
+                            q.push_back(w);
+                        }
+                    } else {
+                        found = true;
+                    }
+                }
+            }
+            if !found {
+                return e;
+            }
+            fn dfs(u: usize, adj: &[Vec<usize>], dist: &mut [usize], e: &mut HopcroftKarp) -> bool {
+                for &v in &adj[u] {
+                    let w = e.r_to_l[v];
+                    if w.is_none()
+                        || dist[u] + 1 == dist[w.unwrap()] && dfs(w.unwrap(), adj, dist, e)
+                    {
+                        (e.l_to_r[u], e.r_to_l[v]) = (Some(v), Some(u));
+                        return true;
+                    }
+                }
+                dist[u] = usize::MAX;
+                false
+            }
+            e.matching_siz += (0..lsz)
+                .filter(|&i| e.l_to_r[i].is_none() && dfs(i, adj, &mut dist, &mut e))
+                .count();
+        }
+    }
+}
diff --git a/src/graphs/mod.rs b/src/graphs/mod.rs
@@ -7,6 +7,7 @@ pub mod cuts;
 mod dfs_order;
 pub mod dijk;
 pub mod hld;
+pub mod hopcroft_karp;
 pub mod lca;
 pub mod scc;
 pub mod two_sat;
