Adding code for finding k shortest paths in a graph. This implements Yen's algorithm to find the k paths in time O(kn^3).

Author: nitsatiisc

.idea/.gitignore

@@ -419,6 +419,7 @@ where
     // their costs are pushed on to the heap. The best path from the heap at the end of the iteration
     // is added to listA.
     let mut listB: BinaryHeap<MinScored<K, Vec<NodeIndex>>> = BinaryHeap::new();
+    let mut paths_in_listB: HashSet<Vec<NodeIndex>> = HashSet::new();
 
     for i in 1usize..max_paths {
         // listA contains the i shortest paths, while listB contains candidate paths.
@@ -470,10 +471,14 @@ where
             if shortest_root_target_path.len() > 0 {
                 // create new_path by appending current_path till divergence point and the shortest path after that.
                 let mut new_path = current_path[0..j].to_owned();
-                println!("new_path {:?}", new_path);
+                //println!("new_path {:?}", new_path);
                 new_path.extend_from_slice(&shortest_root_target_path);
-                println!("Adding path of cost {:?} to listB", root_cost + path_cost);
-                listB.push(MinScored(root_cost + path_cost, new_path));
+                //println!("Adding path of cost {:?} to listB", root_cost + path_cost);
+                // Add the path to listB if it does not already exist.
+                if !paths_in_listB.contains(&new_path) {
+                    listB.push(MinScored(root_cost + path_cost, new_path.clone()));
+                    paths_in_listB.insert(new_path);
+                }
             }
 
             // add current edge cost to the root cost
@@ -642,6 +647,7 @@ mod tests {
     //use crate::get_shortest_paths;
     use petgraph::{Graph, Undirected};
     use petgraph::graph::NodeIndex;
+    use rand::Rng;
     //use crate::shortest_path::get_shortest_paths;
     use crate::shortest_path::simple_shortest_paths::{dijkstra_k_shortest_paths, get_smallest_k_paths_yen};
     //use petgraph_evcxr::draw_graph;
@@ -718,6 +724,29 @@ mod tests {
 
 
 
+    }
+
+    #[test]
+    fn test_k_shortest_random_graph() {
+        let mut g = Graph::new_undirected();
+        let nodes: Vec<NodeIndex> = (0..5000).map(|_| g.add_node(())).collect();
+        let mut rng: rand::prelude::ThreadRng = rand::thread_rng();
+        for _ in 0..62291 { // Adjust the number of edges as desired
+            let a = rng.gen_range(0..nodes.len());
+            let b = rng.gen_range(0..nodes.len());
+            let weight = rng.gen_range(1..100); // Random weight between 1 and 100
+            if a != b { // Prevent self-loops
+                g.add_edge(nodes[a], nodes[b], weight as f32);        }
+        }
+        println!("GRaph created");
+        let source = nodes[1];
+        let target = nodes[4000];
+        let shortest_path_get :usize = 5;
+        //println!(“{:?}“, g);
+        for p in get_smallest_k_paths_yen( &mut g,source,target,10) {
+            println!("New Path {:#?} ",p);
+        }
+
     }