master > master: code-rust - tarjan alg

code/rust/src/graphs/tarjan.rs

@@ -0,0 +1,176 @@
+// ----------------------------------------------------------------
+// IMPORTS
+// ----------------------------------------------------------------
+
+use std::fmt::Display;
+use std::hash::Hash;
+use std::collections::HashMap;
+
+use crate::core::utils;
+use crate::stacks::stack::Stack;
+use crate::graphs::graph::Graph;
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// CONSTANTS
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#[derive(Clone, Copy, PartialEq)]
+enum State {
+    UNTOUCHED,
+    PENDING,
+    FINISHED,
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// METHOD Tarjan Algorithm
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+/// # Tarjan Algorithm #
+/// Runs the Tarjan-Algorithm to compute the strongly connected components.
+pub fn tarjan_algorithm<T>(gph: &Graph<T>) -> Vec<Vec<T>>
+    where T: Eq + Hash + Clone + Display
+{
+    let mut ctx = Context::new(&gph);
+
+    for u in gph.nodes.iter() {
+        tarjan_visit(gph, u, &mut ctx);
+    }
+    return ctx.components;
+}
+
+/// recursive depth-first search algorithm to compute components
+fn tarjan_visit<T>(gph: &Graph<T>, v: &T, ctx: &mut Context<T>)
+    where T: Eq + Hash + Clone + Display
+{
+    if !(ctx.get_state(v) == State::UNTOUCHED) {
+        return;
+    }
+
+    ctx.max_index += 1;
+    ctx.push(v);
+    ctx.set_root(v, ctx.max_index);
+    ctx.set_index(v, ctx.max_index);
+    ctx.set_state(v, State::PENDING);
+
+    // depth first search:
+    for u in gph.successors(&v) {
+        tarjan_visit(gph, &u, ctx);
+        // remains relevant for v, provided u still in Stack:
+        if ctx.stack.elements.contains(&u) {
+            let root = utils::min(
+                ctx.get_root(&u),
+                ctx.get_root(v)
+            );
+            ctx.set_root(v, root);
+        }
+    }
+    ctx.set_state(v, State::FINISHED);
+
+    if ctx.get_index(v) == ctx.get_root(v) {
+        let mut component: Vec<T> = Vec::new();
+        loop {
+            let u = ctx.top();
+            ctx.pop();
+            component.push(u.clone());
+            if u == *v {
+                break;
+            }
+        }
+        ctx.components.push(component);
+    }
+}
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// AUXILIARY context variables for algorithm
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#[derive(Clone, Copy)]
+struct NodeInformation {
+    root: usize,
+    index: usize,
+    state: State,
+}
+
+struct Context<T> {
+    stack: Stack<T>,
+    max_index: usize,
+    infos: HashMap<T, NodeInformation>,
+    components: Vec<Vec<T>>,
+}
+
+impl<T> Context<T>
+    where T: Eq + Hash + Clone + Display
+{
+    fn new(gph: &Graph<T>) -> Context<T> {
+        let mut infos = HashMap::<T, NodeInformation>::new();
+        for u in gph.nodes.iter() {
+            infos.entry(u.clone()).or_insert(NodeInformation::new());
+        }
+        return Context {
+            stack: Stack::new(),
+            max_index: 0,
+            infos: infos,
+            components: vec![],
+        };
+    }
+
+    fn push(self: &mut Self, u: &T) {
+        self.stack.push(u.clone());
+    }
+
+    fn top(self: &mut Self) -> T {
+        return self.stack.top();
+    }
+
+    fn pop(self: &mut Self) -> T {
+        return self.stack.pop();
+    }
+
+    fn update_infos(self: &mut Self, u: &T, info: NodeInformation) {
+        self.infos.insert(u.clone(), info);
+    }
+
+    fn set_state(self: &mut Self, u: &T, state: State) {
+        let mut info = *self.infos.get(u).unwrap();
+        info.state = state;
+        self.update_infos(u, info);
+    }
+
+    fn set_root(self: &mut Self, u: &T, root: usize) {
+        let mut info = *self.infos.get(u).unwrap();
+        info.root = root;
+        self.update_infos(u, info);
+    }
+
+    fn set_index(self: &mut Self, u: &T, index: usize) {
+        let mut info = *self.infos.get(u).unwrap();
+        info.index = index;
+        self.update_infos(u, info);
+    }
+
+    fn get_state(self: &mut Self, u: &T) -> State {
+        let info = *self.infos.get(u).unwrap();
+        return info.state;
+    }
+
+    fn get_root(self: &mut Self, u: &T) -> usize {
+        let info = *self.infos.get(u).unwrap();
+        return info.root;
+    }
+
+    fn get_index(self: &mut Self, u: &T) -> usize {
+        let info = *self.infos.get(u).unwrap();
+        return info.index;
+    }
+}
+
+impl NodeInformation {
+    fn new() -> NodeInformation {
+        return NodeInformation {
+            root: 0,
+            index: 0,
+            state: State::UNTOUCHED,
+        };
+    }
+}