finished chapter 15

Author: senrust

chapter_15/bellman_ford/input1.txt

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

chapter_15/bellman_ford/input2.txt

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

chapter_15/bellman_ford/input3.txt

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

chapter_15/bellman_ford/src/main.rs

@@ -1,3 +1,58 @@
+/// ベルマンフォードアルゴリズム理解
+/// 0番目(始点)のコストは自明, 負の閉路がなければ必ず0となる
+/// i番目 ノードXに到達する最短のパスは必ず始点より開始されるため,
+/// 1回目のスキャンで始点の次に訪問するノードへのコストは必ず確定する
+/// すなわち, どのノードへの経路でも始点からスタートする以上そのノードへの始点最小経路が求まる
+/// これを繰り返すことで, 最小経路のノードが始点から近い順に求まっていく
+/// V-1回目ですべてが確定する
+fn bellman_ford(start_node: usize, node_count: usize, graph: &mut Vec<Vec<(usize, i32)>>, cost_from_start: &mut Vec<i32>) -> bool{
+    cost_from_start[start_node] = 0;
+    for i in 0..node_count {
+        for (from_node, path_from_node) in graph.iter().enumerate() {
+            for (to_node, cost_to) in path_from_node {
+                if cost_from_start[*to_node] > cost_from_start[from_node] + cost_to {
+                    // update cost
+                    if i != node_count -1 {
+                        cost_from_start[*to_node] = cost_from_start[from_node] + cost_to;
+                    } else {
+                        // this means graph has negative circuit
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    false
+}
+
+
 fn main() {
-    println!("Hello, world!");
+    let input_info: Vec<usize> = input::read_numline();
+    let node_count = input_info[0];
+    let input_lines = input_info[1];
+    let start_node = input_info[2];
+    let mut graph: Vec<Vec<(usize, i32)>> = vec![vec![]; node_count];
+    let mut cost_from_start: Vec<i32> = vec![100000000; node_count];
+    
+    for _ in 0..input_lines {
+        let input_line: Vec<i32> = input::read_numline();
+        let from_node = input_line[0] as usize;
+        let to_node = input_line[1] as usize;
+        let cost = input_line[2];
+        graph[from_node].push((to_node, cost));
+    }
+    let is_negative_cirkit = bellman_ford(start_node, node_count, &mut graph, &mut cost_from_start);
+    
+    if is_negative_cirkit {
+        println!("NEGATIVE CIRCUIT");
+        return;
+    }
+    
+    for node in 0..node_count {
+        if cost_from_start[node] == 100000000 {
+            println!("INF");
+        } else {
+            println!("{}", cost_from_start[node]);
+        }
+    }
 }

chapter_15/topological_sort/Cargo.lock

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

chapter_15/topological_sort/Cargo.toml

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

chapter_15/topological_sort/input.txt

@@ -0,0 +1,58 @@
+fn topological_sort(start_node: usize,  graph: &mut Vec<Vec<usize>>, 
+                    order: &mut Vec<usize>, node_order_decided: &mut Vec<bool>, inflow_count: &mut Vec<usize>) {
+
+    let mut search_node_stack: Vec<usize> = vec![];
+
+    search_node_stack.push(start_node);
+
+    while !search_node_stack.is_empty() {
+        let decided_node = search_node_stack.pop().unwrap();
+        node_order_decided[decided_node] = true;
+        order.push(decided_node);
+
+        for to_node in &graph[decided_node] {
+            inflow_count[*to_node] -= 1;
+
+            if inflow_count[*to_node] == 0 && node_order_decided[*to_node] == false {
+                search_node_stack.push(*to_node);
+            }
+        }
+    }
+}
+
+fn topological_sort_prepare(node_count: usize, graph: &mut Vec<Vec<usize>>, order: &mut Vec<usize>) {
+    let mut inflow_count: Vec<usize> = vec![0; node_count];
+    let mut node_order_decided: Vec<bool> = vec![false; node_count];
+    for node in graph.iter() {
+        for to_node in node {
+            inflow_count[*to_node] += 1;
+        }
+    }
+    for node in 0..node_count {
+        if inflow_count[node] == 0 && node_order_decided[node] == false {
+            topological_sort(node, graph, order, &mut node_order_decided, &mut inflow_count);
+        }
+    }
+}
+
+fn main() {
+    let input_info: Vec<usize> = input::read_numline();
+    let node_count = input_info[0];
+    let input_line_count = input_info[1];
+    let mut order: Vec<usize> = vec![];
+    let mut graph: Vec<Vec<usize>> = vec![vec![]; node_count];
+
+    for _ in 0..input_line_count {
+        let input_line: Vec<usize> = input::read_numline();
+        let node_from = input_line[0];
+        let node_to = input_line[1];
+        graph[node_from].push(node_to);
+    }
+
+    topological_sort_prepare(node_count, &mut graph, &mut order);
+
+    for node in &order {
+        println!("{}", *node);
+    }
+
+}

chapter_15/topological_sort/src/main.rs

@@ -4,4 +4,4 @@
 1 2 2
 1 3 4
 2 3 1
-3 2 -7
+3 2 -7

chapter_15/warshall_floyd/input3.txt

@@ -1,3 +1,49 @@
+fn warshall_ford(node_count: usize, cost_to_node: &mut Vec<Vec<i64>>) {
+    for interchange_node in 0..node_count {
+        for node_from in 0..node_count {
+            for node_to in 0..node_count {
+                let cost_by_interchange: i64 = cost_to_node[node_from][interchange_node] as i64 + cost_to_node[interchange_node][node_to] as i64;
+                if cost_to_node[node_from][node_to] > cost_by_interchange {
+                    cost_to_node[node_from][node_to] = cost_by_interchange;
+                }
+            }
+        }
+    }
+}
+
 fn main() {
-    println!("Hello, world!");
+    let input_info: Vec<usize> = input::read_numline();
+    let node_count = input_info[0];
+    let input_lines = input_info[1];
+    let mut cost_to_node: Vec<Vec<i64>> = vec![vec![i32::MAX as i64; node_count]; node_count];
+
+    for _ in 0..input_lines {
+        let node_relation: Vec<i64> = input::read_numline();
+        let node1 = node_relation[0] as usize;
+        let node2 = node_relation[1]  as usize;
+        let cost = node_relation[2] as i64;
+        cost_to_node[node1][node2] = cost;
+    }
+    for node in 0..node_count {
+        cost_to_node[node][node] = 0;
+    }
+
+    warshall_ford(node_count, &mut cost_to_node);
+    for node in 0..node_count {
+        if cost_to_node[node][node] < 0 {
+            println!("NEGATIVE CYCLE");
+            return;
+        }
+    }
+
+    for cost_vec in &cost_to_node {
+        for cost in cost_vec {
+            if *cost == i32::MAX as i64{
+                print!("INF ");
+            } else {
+                print!("{} ", *cost);
+            }
+        }
+        print!("\n");
+    }
 }

chapter_15/warshall_floyd/src/main.rs

@@ -107,7 +107,7 @@ fn successor<T>(mut next: &mut Link<T>) -> &mut Link<T> {
 // Removes a node, either by simply discarding it if it is a leaf, or by swapping it with
 // its inorder successor (which, in this case, is always in a leaf) and then deleting the leaf.
 fn delete_node<T>(link: &mut Link<T>) {
-    if let Some(mut boxed_node) = link.take() {
+    if let Some(mut  boxed_node) = link.take() {
         match (boxed_node.left.take(), boxed_node.right.take()) {
             (None, None) => (),
             (Some(left), None) => *link = Some(left),