Refactored strongly/biconnected components

Author: EbTech

src/arqtree.rs

@@ -1,4 +1,5 @@
 // Associative Range Query Tree based on http://codeforces.com/blog/entry/18051
+// Stores 
 // Entries [0...size-1] are stored in t[size..2*size-1].
 // The range operation must be associative: in this example, we use addition.
 // In this example, the range operation assigns the value op to all entries.
@@ -46,6 +47,7 @@ impl ARQT {
         }
     }
 
+    // Performs op on all entries from l to r, inclusive.
     pub fn modify(&mut self, mut l: usize, mut r: usize, op: i32) {
         l += self.d.len(); r += self.d.len();
         let (l0, r0) = (l, r);
@@ -58,6 +60,7 @@ impl ARQT {
         self.pull(l0); self.pull(r0);
     }
 
+    // Returns the aggregate range query on all entries from l to r, inclusive.
     pub fn query(&mut self, mut l: usize, mut r: usize) -> i32 {
         l += self.d.len(); r += self.d.len();
         self.push(l); self.push(r);

src/graph/connectivity.rs

@@ -1,136 +1,142 @@
 use graph::Graph;
 use ::std::cmp::min;
 
-// Strongly connected, 2-vertex-connected, and 2-edge-connected components
-// should handle multiple-edges and self-loops
-// USAGE: 1) new(); 2) add_edge(...); 3) compute_bcc();
-// 4) use is_cut_vertex(vertex_index) or is_cut_edge(2 * edge_index)
-
-#[derive(Clone)]
-pub struct CCVertex {
-    pub cc: usize,
-    low: usize,
-    vis: usize,
-}
-
-pub struct CCGraph<'a> {
+// Represents the decomposition of a graph into any of its:
+// - Connected components (CC),
+// - Strongly connected components (SCC),
+// - 2-edge-connected components (2ECC),
+// - 2-vertex-connected components (2VCC)
+// Multiple-edges and self-loops should be correctly handled.
+pub struct ConnectivityGraph<'a> {
     pub graph: &'a Graph,
-    pub vdata: Vec<CCVertex>,
-    pub vcc: Vec<usize>,
+    pub cc: Vec<usize>,  // stores id of a vertex's CC, SCC or 2ECC
+    pub vcc: Vec<usize>, // stores id of an edge's 2VCC
     pub num_cc: usize,
-    pub num_vcc: usize,
-    t: usize,
-    verts: Vec<usize>,
-    edges: Vec<usize>
+    pub num_vcc: usize
 }
 
-impl<'a> CCGraph<'a> {
-    pub fn new(graph: &'a Graph, is_directed: bool) -> CCGraph {
-        let data = CCVertex { cc: 0, low: 0, vis: 0 };
-        let mut cc_graph = CCGraph {
+impl<'a> ConnectivityGraph<'a> {
+    // Computes the SCCs of a directed graph in reverse topological order, or
+    // the 2ECCs/2VCCS of an undirected graph. Can also get CCs by passing an
+    // undirected graph with is_directed == true.
+    pub fn new(graph: &'a Graph, is_directed: bool) -> ConnectivityGraph {
+        let mut connect = ConnectivityGraph {
             graph: graph,
-            vdata: vec![data; graph.num_v()],
+            cc: vec![0; graph.num_v()],
             vcc: vec![0; graph.num_e()],
             num_cc: 0,
-            num_vcc: 0,
-            t: 0,
-            verts: Vec::new(),
-            edges: Vec::new()
+            num_vcc: 0
         };
-        for i in 0..graph.num_v() {
-            if cc_graph.vdata[i].vis == 0 {
+        let mut t = 0;
+        let mut vis = vec![0; graph.num_v()];
+        let mut low = vec![0; graph.num_v()];
+        let mut verts = Vec::new();
+        let mut edges = Vec::new();
+        for u in 0..graph.num_v() {
+            if vis[u] == 0 {
                 if is_directed {
-                    cc_graph.scc(i);
+                    connect.scc(u, &mut t, &mut vis, &mut low, &mut verts);
                 }
                 else {
-                    cc_graph.bcc(i, 0); // TODO: default 2nd arg at root
+                    connect.bcc(u, graph.num_e() + 1, &mut t, &mut vis,
+                                &mut low, &mut verts, &mut edges);
                 }
             }
         }
-        cc_graph
+        connect
     }
 
-    // SCCs form a DAG whose components are numbered in reverse topological order.
-    fn scc(&mut self, u: usize) {
-        self.t += 1;
-        self.vdata[u].low = self.t;
-        self.vdata[u].vis = self.t;
-        self.verts.push(u);
+    fn scc(&mut self, u: usize, t: &mut usize, vis: &mut [usize],
+           low: &mut [usize], verts: &mut Vec<usize>) {
+        *t += 1;
+        vis[u] = *t;
+        low[u] = *t;
+        verts.push(u);
         for (_, v) in self.graph.adj_list(u) {
-            if self.vdata[v].vis == 0 { self.scc(v); }
-            if self.vdata[v].cc == 0 {
-                self.vdata[u].low = min(self.vdata[u].low, self.vdata[v].low);
-            }
+            if vis[v] == 0 { self.scc(v, t, vis, low, verts); }
+            if self.cc[v] == 0 { low[u] = min(low[u], low[v]); }
         }
-        if self.vdata[u].vis <= self.vdata[u].low {
+        if vis[u] == low[u] {
             self.num_cc += 1;
-            while let Some(v) = self.verts.pop() {
-                self.vdata[v].cc = self.num_cc;
+            while let Some(v) = verts.pop() {
+                self.cc[v] = self.num_cc;
                 if v == u { break; }
             }
         }
     }
 
+    // From the directed implication graph corresponding to a 2-SAT clause,
+    // finds a satisfying assignment if it exists or returns None otherwise.
     pub fn two_sat_assign(&self) -> Option<Vec<bool>> {
         (0..self.graph.num_v()/2).map( |i| {
-            let scc_true = self.vdata[2*i].cc;
-            let scc_false = self.vdata[2*i+1].cc;
+            let scc_true = self.cc[2*i];
+            let scc_false = self.cc[2*i+1];
             if scc_true == scc_false { None } else { Some(scc_true < scc_false) }
         }).collect()
     }
 
+    // Gets the vertices of a directed acyclic graph (DAG) in topological order.
+    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
+    }
+    
     // Biconnected components are a work in progress.
-    fn bcc(&mut self, u: usize, par: usize) {
-        self.t += 1;
-        self.vdata[u].low = self.t;
-        self.vdata[u].vis = self.t;
-        self.verts.push(u);
+    fn bcc(&mut self, u: usize, par: usize, t: &mut usize, vis: &mut [usize],
+           low: &mut [usize], verts: &mut Vec<usize>, edges: &mut Vec<usize>) {
+        *t += 1;
+        vis[u] = *t;
+        low[u] = *t;
+        verts.push(u);
         for (e, v) in self.graph.adj_list(u) {
-          if self.vdata[v].vis == 0 {
-              self.edges.push(e);
-              self.bcc(v, e);
-              self.vdata[u].low = min(self.vdata[u].low, self.vdata[v].low);
-              if self.vdata[u].vis <= self.vdata[v].low { // u is a cut vertex unless it's a one-child root
-                  while let Some(top_e) = self.edges.pop() {
+          if vis[v] == 0 {
+              edges.push(e);
+              self.bcc(v, e, t, vis, low, verts, edges);
+              low[u] = min(low[u], low[v]);
+              if vis[u] <= low[v] { // u is a cut vertex unless it's a one-child root
+                  self.num_vcc += 1;
+                  while let Some(top_e) = edges.pop() {
                       self.vcc[top_e] = self.num_vcc;
                       self.vcc[top_e ^ 1] = self.num_vcc;
                       if e ^ top_e <= 1 { break; }
                   }
-                  self.num_vcc += 1;
               }
           }
-          else if self.vdata[v].vis < self.vdata[u].vis && e != (par^1) {
-              self.vdata[u].low = min(self.vdata[u].low, self.vdata[v].vis);
-              self.edges.push(e);
+          else if vis[v] < vis[u] && e ^ par != 1 {
+              low[u] = min(low[u], vis[v]);
+              edges.push(e);
           }
           else if v == u { // e is a self-loop
+              self.num_vcc += 1;
               self.vcc[e] = self.num_vcc;
               self.vcc[e ^ 1] = self.num_vcc;
-              self.num_vcc += 1;
           }
         } 
-        if self.vdata[u].vis <= self.vdata[u].low { // par is a cut edge unless par==-1
-            while let Some(v) = self.verts.pop() {
-                self.vdata[v].cc = self.num_cc;
+        if vis[u] == low[u] { // par is a cut edge unless par==-1
+            self.num_cc += 1;
+            while let Some(v) = verts.pop() {
+                self.cc[v] = self.num_cc;
                 if v == u { break; }
-            }
-            self.num_cc += 1; 
+            } 
         }
     }
 
+    // In an undirected graph, determines whether u is an articulation vertex.
     pub fn is_cut_vertex(&self, u: usize) -> bool {
         if let Some(first_e) = self.graph.first[u] {
-            self.graph.adj_list(u).any(|(e, _)| {self.vcc[e] != self.vcc[first_e]})
+            self.graph.adj_list(u).any(|(e, _)| {self.vcc[first_e] != self.vcc[e]})
         }
         else {
             false
         }
     }
 
+    // In an undirected graph, determines whether v is a bridge
     pub fn is_cut_edge(&self, e: usize) -> bool {
         let u = self.graph.endp[e ^ 1];
         let v = self.graph.endp[e];
-        self.vdata[u].cc != self.vdata[v].cc
+        self.cc[u] != self.cc[v]
     }
 }
 
@@ -147,11 +153,11 @@ mod test {
         graph.add_two_sat_clause(x, z);
         graph.add_two_sat_clause(y^1, z^1);
         graph.add_two_sat_clause(y, y);
-        assert_eq!(CCGraph::new(&graph, true).two_sat_assign(),
+        assert_eq!(ConnectivityGraph::new(&graph, true).two_sat_assign(),
                    Some(vec![true, true, false]));
 
         graph.add_two_sat_clause(z, z);
-        assert_eq!(CCGraph::new(&graph, true).two_sat_assign(), None);
+        assert_eq!(ConnectivityGraph::new(&graph, true).two_sat_assign(), None);
     }
 
     #[test]
@@ -162,7 +168,7 @@ mod test {
         graph.add_undirected_edge(1, 2);
         graph.add_undirected_edge(1, 2);
 
-        let cc_graph = CCGraph::new(&graph, false);
+        let cc_graph = ConnectivityGraph::new(&graph, false);
         let bridges = (0..graph.num_e()).filter(|&e| cc_graph.is_cut_edge(e)).collect::<Vec<_>>();
         let articulation_points = (0..graph.num_v()).filter(|&u| cc_graph.is_cut_vertex(u)).collect::<Vec<_>>();
         assert_eq!(bridges, vec![0, 1]);

src/graph/flow.rs

@@ -1,5 +1,4 @@
-use graph::Graph;
-use graph::AdjListIterator;
+use graph::{Graph, AdjListIterator};
 use ::std::cmp::min;
 const INF: i64 = 0x3f3f3f3f;
 
@@ -22,14 +21,15 @@ impl FlowGraph {
 
     // Adds an edge with specified capacity and cost. The reverse edge is also
     // added for residual graph computation, but has zero capacity.
-    pub fn add_edge(&mut self, a: usize, b: usize, cap: i64, cost: i64) {
+    pub fn add_edge(&mut self, u: usize, v: usize, cap: i64, cost: i64) {
         self.cap.push(cap); self.cost.push(cost);
         self.cap.push(0); self.cost.push(-cost);
-        self.graph.add_undirected_edge(a, b);
+        self.graph.add_undirected_edge(u, v);
     }
 
-    // Dinic's maximum flow / Hopcroft-Karp maximum bipartite matching: V^2E in
-    // general, min(V^(2/3),sqrt(E))E on unit capacity, sqrt(V)E on bipartite.
+    // Dinic's maximum flow / Hopcroft-Karp maximum bipartite matching:
+    // V^2E in general, min(V^(2/3),sqrt(E))E when all edges are unit capacity,
+    // sqrt(V)E when all vertices are unit capacity as in bipartite graphs.
     pub fn dinic(&self, s: usize, t: usize) -> i64 {
         let mut flow = vec![0; self.graph.num_e()];
         let mut max_flow = 0;
@@ -39,7 +39,7 @@ impl FlowGraph {
         max_flow
     }
 
-    // Pushes a saturating flow that increases the residual's s-t distance.
+    // Pushes a blocking flow that increases the residual's s-t distance.
     pub fn dinic_augment(&self, s: usize, t: usize, flow: &mut [i64]) -> Option<i64> {
         let mut dist = vec![INF; self.graph.num_v()];
         let mut q = ::std::collections::VecDeque::new();
@@ -113,7 +113,7 @@ impl FlowGraph {
         (min_cost, max_flow)
     }
 
-    // Pushes along an augmenting path of minimum cost while maintaining the
+    // Pushes along an augmenting path of minimum cost, while maintaining the
     // vertex potentials so that no negative-weight residual edges appear.
     pub fn mcf_augment(&self, s: usize, t: usize, pot: &mut [i64], flow: &mut [i64]) -> Option<(i64, i64)> {
         let mut vis = vec![false; self.graph.num_v()];

src/lib.rs

@@ -1,5 +1,5 @@
-pub mod graph;
 pub mod arqtree;
+pub mod graph;
+pub mod math;
 pub mod scanner;
 pub mod string_proc;
-pub mod math;