Finish course 2 assignment 2 naivly and clean up

src/dijkstra.rs

@@ -0,0 +1,35 @@
+use crate::util::DirectedWeightedGraph;
+
+pub fn dijkstra(g: &mut DirectedWeightedGraph) -> () {
+    let mut x: Vec<usize> = vec![0];
+    g.distance[0] = 0;
+
+    while x.len() < g.nodes.len() {
+        let mut min_node = std::usize::MAX;
+        let mut min_distance = std::usize::MAX;
+
+        for &i in x.iter() {
+            let v = &g.nodes[i];
+            for &edge in v.iter() {
+                let w = edge.0;
+                let distance = edge.1;
+                if x.contains(&w) {
+                    continue;
+                }
+
+                let current_edge_distance = g.distance[i] + distance;
+                if current_edge_distance < min_distance {
+                    min_distance = current_edge_distance;
+                    min_node = w;
+                }
+            }
+        }
+
+        if min_node == std::usize::MAX {
+            panic!("Did not find a min_node");
+        }
+
+        g.distance[min_node] = min_distance;
+        x.push(min_node);
+    }
+}

src/main.rs

@@ -1,29 +1,28 @@
+mod dijkstra;
 mod merge_sort;
 mod min_cut;
 mod quick_sort;
 mod ssc;
 mod util;
 
-use crate::util::read_to_graph;
 use std::cmp::min;
 
+use crate::dijkstra::dijkstra;
 use crate::merge_sort::merge_sort_inversions;
 use crate::min_cut::min_cut;
 use crate::quick_sort::quick_sort;
 use crate::ssc::ssc;
-use crate::util::read_to_directed_graph;
-use crate::util::read_to_vector;
 
 #[allow(dead_code)]
 fn c1a2() {
-    let vec = read_to_vector("data/c1a2.txt").unwrap();
+    let vec = util::read_to_vector("data/c1a2.txt").unwrap();
     let (_sorted, inversions) = merge_sort_inversions(vec);
     println!("c1a2={:?}", inversions);
 }
 
 #[allow(dead_code)]
 fn c1a3() {
-    let mut vec = read_to_vector("data/c1a3.txt").unwrap();
+    let mut vec = util::read_to_vector("data/c1a3.txt").unwrap();
     let mut comp_acc: usize = 0;
     quick_sort(&mut vec, &mut comp_acc);
     println!("c1a3={:?}", comp_acc);
@@ -32,7 +31,7 @@ fn c1a3() {
 
 #[allow(dead_code)]
 fn c1a4() {
-    let g = read_to_graph("data/c1a4.txt").unwrap();
+    let g = util::read_to_graph("data/c1a4.txt").unwrap();
     let mut smallest_min_cut = u32::MAX;
     let iterations = g.nodes.len().pow(1);
     for _ in 0..iterations {
@@ -48,7 +47,7 @@ fn c1a4() {
 #[allow(dead_code)]
 fn c2a1() {
     // I have not checked in the graph file, because it has 70MB. This is a tiny test example.
-    let g = read_to_directed_graph("data/c2a1_test.txt").unwrap();
+    let g = util::read_to_directed_graph("data/c2a1_test.txt").unwrap();
     let sizes = ssc(g.0, g.1);
     let max_size = min(sizes.len(), 5);
     println!("{:?}", &sizes[0..max_size]);
@@ -57,7 +56,14 @@ fn c2a1() {
 
 #[allow(dead_code)]
 fn c2a2() {
-	println!("here we go again!");
+    let mut requested_vertices: Vec<usize> = vec![7, 37, 59, 82, 99, 115, 133, 165, 188, 197];
+    let mut g = util::read_to_directed_weighted_graph("data/c2a2.txt").unwrap();
+    dijkstra(&mut g);
+    for i in 0..requested_vertices.len() {
+        requested_vertices[i] = g.distance[requested_vertices[i] - 1];
+    }
+    println!("{:?}", requested_vertices);
+    // [2599, 2610, 2947, 2052, 2367, 2399, 2029, 2442, 2505, 3068]
 }
 
 fn main() {

src/merge_sort.py

@@ -0,0 +1,37 @@
+
+def merge(a, b):
+    """Merges two sorted lists"""
+    i, j = 0, 0
+    r = []
+    while i < len(a) and j < len(b):
+        if a[i] < b[j]:
+            r.append(a[i])
+            i += 1
+        else:
+            r.append(b[j])
+            j += 1
+
+    while i < len(a):
+        r.append(a[i])
+        i += 1
+
+    while j < len(b):
+        r.append(b[j])
+        j += 1
+    return r
+
+
+def merge_sort(v):
+    length = len(v)
+    if length <= 1:
+        return v
+
+    half_length = length // 2
+
+    a = merge_sort(v[:half_length])
+    b = merge_sort(v[half_length:])
+    return merge(a, b)
+
+
+if __name__ == "__main__":
+    print(merge_sort([42, 12, 3, 1, 5]))

src/util.rs

@@ -9,7 +9,7 @@ pub struct Graph {
     pub edges: Vec<(u32, u32)>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DirectedGraph {
     pub nodes: Vec<Vec<usize>>,
     pub explored: Vec<bool>,
@@ -17,6 +17,12 @@ pub struct DirectedGraph {
     pub leader: Vec<usize>,
 }
 
+#[derive(Debug)]
+pub struct DirectedWeightedGraph {
+    pub nodes: Vec<Vec<(usize, usize)>>,
+    pub distance: Vec<usize>,
+}
+
 pub fn read_to_vector(path: &str) -> Result<Vec<i64>, io::Error> {
     let file = File::open(path)?;
     let br = BufReader::new(file);
@@ -107,3 +113,28 @@ pub fn read_to_directed_graph(path: &str) -> Result<(DirectedGraph, DirectedGrap
 
     Ok((g, g_dash))
 }
+
+pub fn read_to_directed_weighted_graph(path: &str) -> Result<DirectedWeightedGraph, io::Error> {
+    let nodes: usize = get_node_size(path).unwrap();
+    let mut g = DirectedWeightedGraph {
+        nodes: vec![vec![]; nodes],
+        distance: vec![1000000; nodes], // initial distance based on instructions
+    };
+
+    let file = File::open(path)?;
+    let br = BufReader::new(file);
+
+    for line in br.lines() {
+        let line = line?;
+        let mut nodes = line.split_whitespace();
+        let current_node: usize = nodes.next().unwrap().parse().unwrap();
+
+        for edge in nodes {
+            let mut it = edge.split(",");
+            let target_node: usize = it.next().unwrap().parse().unwrap();
+            let distance: usize = it.next().unwrap().parse().unwrap();
+            g.nodes[current_node - 1].push((target_node - 1, distance))
+        }
+    }
+    Ok(g)
+}