3 files changed, 52 insertions, 31 deletions

diff --git a/graph-checker/src/compute.rs b/graph-checker/src/compute.rs
index a9e88ae..b14c2cd 100644
--- a/graph-checker/src/compute.rs
+++ b/graph-checker/src/compute.rs
@@ -5,49 +5,59 @@ pub fn dominating_numbers(g: Graph) -> (String, Option<u32>, u32) {
     let line = g.to_g6();
     let mut independent_dominating = None;
 
-    let mut smallest_geodesic = None;
+    // let mut smallest_geodesic = None;
     let mut geodesic_sets = Vec::new();
 
-    let mut done = false;
+    // let mut done = false;
 
     for cs in g.cutsets() {
-        if done {
-            break;
-        }
+        // if done {
+        //     break;
+        // }
         let dom = cs.is_dominating_in(&g);
         let idp = cs.graph.is_independent();
         if independent_dominating.is_none() && dom && idp {
             independent_dominating = Some(cs.cardinality as u32);
         }
 
+        // let mut geodesics = Vec::new();
         let mut visited = vec![0; g.size];
-        for vx in &cs.vertices {
-            if *vx == 1 {
-                g.dfs(*vx as usize, &mut visited);
+        for a in 0..cs.graph.size {
+            if cs.vertices[a] == 1 {
+                continue;
             }
-            if visited.iter().sum::<usize>() == g.size {
-                let geodesic_size: u32 = cs.vertices.iter().sum();
-                if let Some(smallest_geodesic) = smallest_geodesic {
-                    if geodesic_size > smallest_geodesic {
-                        done = true;
-                        break;
+            for b in 0..cs.graph.size {
+                if cs.vertices[b] == 1 {
+                    continue;
+                }
+                if a != b {
+                    // let mut gds = g.get_geodesics(a, b);
+                    for geod in g.get_geodesics(a, b) {
+                        for i in geod {
+                            visited[i] = 1;
+                        }
                     }
-                } else {
-                    smallest_geodesic = Some(geodesic_size);
+                    // geodesics.append(&mut gds);
                 }
-                println!("cs {:?}", cs.vertices);
-                geodesic_sets.push(cs.vertices.clone());
             }
         }
+        if visited.iter().sum::<usize>() == g.size {
+            geodesic_sets.push(cs.vertices.clone());
+        }
     }
 
-    println!("geodesic_sets = {}", geodesic_sets.len());
+    // println!("geodesic_sets = {}", geodesic_sets.len());
     let mut fg = g.size as u32;
-    println!("start");
-    for check in &geodesic_sets {
-        println!("{:?}", check);
+    // println!("start");
+    for i in 0..geodesic_sets.len() {
+        let check = &geodesic_sets[i];
+        // println!("{:?}", check);
         let mut verts = check.clone();
-        for set in &geodesic_sets {
+        for j in 0..geodesic_sets.len() {
+            if i == j {
+                continue;
+            }
+            let set = &geodesic_sets[j];
             for v in 0..g.size {
                 if check[v] == set[v] {
                     verts[v] = 0;
@@ -59,7 +69,11 @@ pub fn dominating_numbers(g: Graph) -> (String, Option<u32>, u32) {
             fg = new_fg;
         }
     }
-    println!("end");
+    // println!("end");
+
+    if fg != 0 && fg != g.size as u32 && fg != 1 {
+        println!("{line} {independent_dominating:?} {fg}");
+    }
 
     (line, independent_dominating, fg)
 }
diff --git a/graph-checker/src/graph.rs b/graph-checker/src/graph.rs
index fd6fa63..bb0fb03 100644
--- a/graph-checker/src/graph.rs
+++ b/graph-checker/src/graph.rs
@@ -288,24 +288,31 @@ impl Graph {
             next: usize,
             to: usize,
             path: Vec<usize>,
+            mut visited: Vec<usize>,
             paths: &mut Vec<Vec<usize>>,
         ) {
             if next == to {
                 paths.push(path.clone());
                 return;
             }
+            visited[next] = 1;
+            // println!("{next} {to} {path:?}");
             for i in 0..g.size {
-                if g.matrix[next][i] != 0 {
+                if visited[i] != 1 && g.matrix[next][i] != 0 {
                     let mut p = path.clone();
                     p.push(i);
-                    dfs(g, i, to, p, paths);
+                    dfs(g, i, to, p, visited.clone(), paths);
                 }
             }
         }
         let mut paths = Vec::new();
-        dfs(self, from, to, vec![from], &mut paths);
-        let d = paths.iter().map(Vec::len).min().unwrap();
-        return paths.into_iter().filter(|p| p.len() == d).collect();
+        let visited = vec![0; self.size];
+        dfs(self, from, to, vec![from], visited, &mut paths);
+
+        match paths.iter().map(Vec::len).min() {
+            Some(d) => paths.into_iter().filter(|p| p.len() == d).collect(),
+            None => Vec::new(),
+        }
     }
 
     fn count_components_partial(&self, included_vertices: &Vec<u32>) -> usize {
diff --git a/graph-checker/src/main.rs b/graph-checker/src/main.rs
index bea7d6a..85699f1 100644
--- a/graph-checker/src/main.rs
+++ b/graph-checker/src/main.rs
@@ -35,7 +35,7 @@ async fn main() -> Result<(), sqlx::Error> {
 
     // gi.par_bridge().for_each(|_| {});
 
-    let gi = GengIterator::new(7);
+    let gi = GengIterator::new(8);
 
     // let start = Instant::now();
     // let tasks: Vec<_> = gi
@@ -53,7 +53,7 @@ async fn main() -> Result<(), sqlx::Error> {
     for pair in &res {
         if let Some(cardinality) = pair.1 {
             if pair.2 != 0 {
-                println!("{} {:?} {}", pair.0, cardinality, pair.2);
+                // println!("{} {:?} {}", pair.0, cardinality, pair.2);
             }
         }
     }