diff --git a/data/c2a2_test.txt b/data/c2a2_test.txt new file mode 100644 index 0000000..8bfbaa0 --- /dev/null +++ b/data/c2a2_test.txt @@ -0,0 +1,4 @@ +1 2,1 3,4 +2 3,2 4,6 +3 4,3 +4 diff --git a/png/dijkstra_1.png b/png/dijkstra_1.png new file mode 100644 index 0000000..6225892 Binary files /dev/null and b/png/dijkstra_1.png differ diff --git a/png/dijkstra_2.png b/png/dijkstra_2.png new file mode 100644 index 0000000..1c61967 Binary files /dev/null and b/png/dijkstra_2.png differ diff --git a/png/dijkstra_3.png b/png/dijkstra_3.png new file mode 100644 index 0000000..66f45da Binary files /dev/null and b/png/dijkstra_3.png differ diff --git a/py/week_1_set_1.py b/py/week_1_set_1.py deleted file mode 100644 index 49d53fb..0000000 --- a/py/week_1_set_1.py +++ /dev/null @@ -1,50 +0,0 @@ -import matplotlib.pyplot as plt -import numpy as np - -n = np.arange(1, 1000, 1) - -# Version 1 - -a = 2**np.log(n) -b = 2**2**np.log(n) -c = n**(5/2) -d = 2**n**2 -e = (n**2)*np.log(n) - -# plt.plot(n, a, 'b', n, b, 'y') # a < b -# plt.plot(n, b, 'b', n, c, 'y') # b > c -# plt.plot(n, a, 'b', n, c, 'y') # a < c - -# plt.plot(n, c, 'b', n, d, 'y') # c << d -# plt.plot(n, c, 'b', n, e, 'y') # c > e -# plt.plot(n, e, 'b', n, b, 'y') # e < b -# plt.plot(n, e, 'b', n, a, 'y') # e > a - -# a < e < c < b < d - -n = np.arange(1, 1000, 1) -# n = 1000 -a = np.sqrt(n) -b = 10**n -c = n**1.5 -d = 2**np.sqrt(np.log(n)) -e = n**5/3 - -# print(a, b, c, d, e) -# d < a < c < e < b -# print(d < a, a < c, c < e, e < b) - -plt.plot(n, a, 'b', n, d, 'y') # a > d - -plt.show() - -""" -1) n*log(n) -2) True -3) Yes if and Sometimes yes -4) O(nk**2) -5) :/ Tried: - -ecadb -abecd -""" diff --git a/src/dijkstra.rs b/src/dijkstra.rs new file mode 100644 index 0000000..c04c605 --- /dev/null +++ b/src/dijkstra.rs @@ -0,0 +1,35 @@ +use crate::util::DirectedWeightedGraph; + +pub fn dijkstra(g: &mut DirectedWeightedGraph) -> () { + let mut x: Vec = 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); + } +} diff --git a/src/main.rs b/src/main.rs index 36bc81c..b930ed1 100644 --- a/src/main.rs +++ b/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 = 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() { diff --git a/py/week_1_merge_sort.py b/src/merge_sort.py similarity index 100% rename from py/week_1_merge_sort.py rename to src/merge_sort.py diff --git a/src/util.rs b/src/util.rs index d189d0f..1073b74 100644 --- a/src/util.rs +++ b/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>, pub explored: Vec, @@ -17,6 +17,12 @@ pub struct DirectedGraph { pub leader: Vec, } +#[derive(Debug)] +pub struct DirectedWeightedGraph { + pub nodes: Vec>, + pub distance: Vec, +} + pub fn read_to_vector(path: &str) -> Result, 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 { + 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) +}