chapter 13 implementing

Author: senrust

chapter_13/minimum_spaning_tree/Cargo.lock

@@ -0,0 +1,10 @@
+[package]
+name = "minimum_spaning_tree"
+version = "0.1.0"
+authors = ["Yohei Osawa <yohei.osawa.318.niko8@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_13/minimum_spaning_tree/Cargo.toml

@@ -0,0 +1,6 @@
+5
+-1 2 3 1 -1
+2 -1 -1 4 -1
+3 -1 -1 1 1
+1 4 1 -1 3
+-1 -1 1 3 -1

chapter_13/minimum_spaning_tree/input.txt

@@ -0,0 +1,60 @@
+#[derive(Clone, PartialEq)]
+enum NodeState {
+    UnReached,
+    Reached,
+    Finished,
+}
+
+fn prim(graph: &mut Vec<Vec<i32>>, node_count: usize) -> Vec<i32> {
+    let mut nodestate: Vec<NodeState> = vec![NodeState::UnReached; node_count];
+    let mut next_node: Vec<i32> = vec![std::i32::MAX; node_count];
+    let mut minpath_to_node: Vec<i32> = vec![std::i32::MAX; node_count];
+    // start from node 0
+    next_node[0] = -1;
+    minpath_to_node[0] =0;
+
+    loop {
+        let mut minpath_to_unfinished_node = std::i32::MAX;
+        let mut path_fnished_node: usize = 0;
+        for node in 0.. node_count {
+            if nodestate[node] != NodeState::Finished  && minpath_to_unfinished_node > minpath_to_node[node] {
+                path_fnished_node = node;
+                minpath_to_unfinished_node = minpath_to_node[node];
+            }
+        }
+
+        if minpath_to_unfinished_node == std::i32::MAX {
+            break;
+        }
+
+        nodestate[path_fnished_node] = NodeState::Finished;
+
+        for node in 0..node_count {
+            if nodestate[node] != NodeState::Finished && graph[path_fnished_node][node] != std::i32::MAX {
+                if graph[path_fnished_node][node] < minpath_to_node[node] {
+                    minpath_to_node[node] = graph[path_fnished_node][node];
+                    next_node[node] = path_fnished_node as i32;
+                    nodestate[node] = NodeState::Reached;
+                }
+            }
+        }
+    }
+    minpath_to_node
+}
+
+fn main() {
+    let node_counts: usize = input::read_number();
+    let mut graph: Vec<Vec<i32>> = vec![vec![std::i32::MAX; node_counts]; node_counts]; 
+    for node_index in 0..node_counts {
+        let node_info: Vec<i32> = input::read_numline();
+        for i in 0..node_info.len() {
+            if node_info[i] == -1 {
+                continue;
+            }
+            graph[node_index][i] = node_info[i];
+        }
+    }
+    let minpath_to_node = prim(&mut graph, node_counts);
+    let pathsum: i32 = minpath_to_node.into_iter().sum();
+    println!("mininum_path sum is {}", pathsum);
+}

chapter_13/minimum_spaning_tree/src/main.rs

@@ -0,0 +1,10 @@
+[package]
+name = "shortest_path"
+version = "0.1.0"
+authors = ["Yohei Osawa <yohei.osawa.318.niko8@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_13/shortest_path/Cargo.lock

@@ -0,0 +1,6 @@
+5
+0 3 2 3 3 1 1 2
+1 2 0 2 3 4
+2 3 0 3 3 1 4 1
+3 4 2 1 0 1 1 4 4 3
+4 2 2 1 3 3

chapter_13/shortest_path/Cargo.toml

@@ -0,0 +1,62 @@
+#[derive(Clone, PartialEq)]
+enum NodeState {
+    UnReached,
+    Reached,
+    Finished,
+}
+
+fn dikkstra(node_count: usize, graph: &mut Vec<Vec<i32>>) -> Vec<i32> {
+    let mut cost_from_start: Vec<i32> = vec![std::i32::MAX; node_count];
+    let mut node_state: Vec<NodeState> = vec![NodeState::UnReached; node_count];
+    // start form 0
+    cost_from_start[0] = 0;
+
+    loop {
+        let mut is_unfinished_node_fount = false;
+        let mut cost_of_this_node = std::i32::MAX;
+        let mut cost_calc_finished_node: usize = 0;
+
+        for node in 0..node_count {
+            if node_state[node] != NodeState::Finished && cost_from_start[node] != std::i32::MAX {
+                if cost_from_start[node] < cost_of_this_node{
+                    cost_of_this_node = cost_from_start[node];
+                    is_unfinished_node_fount = true;
+                    cost_calc_finished_node = node;
+                    node_state[node] = NodeState::Reached;
+                }
+            }
+        }
+
+        if !is_unfinished_node_fount { break; }
+        node_state[cost_calc_finished_node] = NodeState::Finished;
+
+        for node in 0..node_count {
+            if node_state[node] != NodeState::Finished && graph[cost_calc_finished_node][node] != std::i32::MAX {
+                if (cost_from_start[cost_calc_finished_node] + graph[cost_calc_finished_node][node]) < cost_from_start[node] {
+                    cost_from_start[node] = cost_from_start[cost_calc_finished_node] + graph[cost_calc_finished_node][node];
+                    node_state[node] = NodeState::Reached;
+                }
+            }
+        }
+    }
+    cost_from_start
+}
+
+fn main() {
+    let node_count: usize = input::read_number();
+    let mut graph: Vec<Vec<i32>> = vec![vec![std::i32::MAX; node_count]; node_count];
+    for _  in 0..node_count {
+        let node_info: Vec<usize> = input::read_numline();
+        let node = node_info[0];
+        let node_branch_count = node_info[1];
+        for i in 0..node_branch_count {
+            let node_to = node_info[2+i*2];
+            let path_cost = node_info[2+i*2+1] as i32;
+            graph[node][node_to] = path_cost;
+        }
+    }
+    let cost_from_start = dikkstra(node_count, &mut graph);
+    for (node, cost) in cost_from_start.iter().enumerate() {
+        println!("{} {}", node, cost);
+    }
+}

chapter_13/shortest_path/input.txt

@@ -0,0 +1,10 @@
+[package]
+name = "shortest_path_2"
+version = "0.1.0"
+authors = ["Yohei Osawa <yohei.osawa.318.niko8@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+input = {path = "../../library/input"}

chapter_13/shortest_path/src/main.rs

@@ -0,0 +1,6 @@
+5
+0 3 2 3 3 1 1 2
+1 2 0 2 3 4
+2 3 0 3 3 1 4 1
+3 4 2 1 0 1 1 4 4 3
+4 2 2 1 3 3

chapter_13/shortest_path_2/Cargo.lock

@@ -0,0 +1,74 @@
+
+use std::collections::BinaryHeap;
+use std::i32;
+use std::cmp::Ordering;
+
+#[derive(Clone, PartialEq)]
+enum NodeState {
+    UnReached,
+    Reached,
+    Finished,
+}
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+struct State {
+    cost: usize,
+    node: usize,
+}
+
+impl Ord for State {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // maxヒープをminヒープとして使用するためには, 
+        // コストがより小さい方がGreaterとなるよう順序を反転する
+        // つまり自身よりも大きいコストと比較したら, 自身がより大きい(MAXヒープで上）という判断にする
+        // ノード番号は若い順でよい
+        other.cost.cmp(&self.cost)
+            .then_with(|| self.node.cmp(&other.node))
+    }
+}
+impl PartialOrd for State {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+/*
+
+fn dikkstra(node_count: usize, graph: &mut Vec<Vec<(usize, i32)>>) {
+    let mut node_state: Vec<NodeState> = vec![NodeState::UnReached; node_count];
+    let mut cost_from_start :BinaryHeap<(usize, i32)> = BinaryHeap::new();
+
+    // start from node 0
+    cost_from_start[0] = 0;
+    
+    loop {
+        let mut cost_to_node = i32::MAX;
+        let mut is_unfinished_node_found = false;
+
+        for 
+
+    }
+}
+*/
+fn main() {
+
+    let node_count: usize = input::read_number();
+    let mut graph: Vec<Vec<(usize, i32)>> = vec![vec![]; node_count];
+    for _  in 0..node_count {
+        let node_info: Vec<usize> = input::read_numline();
+        let node = node_info[0];
+        let node_branch_count = node_info[1];
+        for i in 0..node_branch_count {
+            let node_to = node_info[2+i*2];
+            let path_cost = node_info[2+i*2+1] as i32;
+            graph[node].push((node_to, path_cost));
+        }
+    }
+    /* 
+    let cost_from_start = dikkstra(node_count, &mut graph);
+    for (node, cost) in cost_from_start.iter().enumerate() {
+        println!("{} {}", node, cost);
+    }
+    */
+    
+}

chapter_13/shortest_path_2/Cargo.toml

@@ -0,0 +1,5 @@
+4 5
+4 2 
+5 2
+2 1
+8 3