Merge branch 'master' of github.com:ryanoneill/rust-leetcode

Author: ryanoneill

src/lib.rs

@@ -59,6 +59,8 @@ pub mod remove_duplicates_from_sorted_array_ii; // 80
 pub mod remove_duplicates_from_sorted_list_ii; // 82
 pub mod remove_duplicates_from_sorted_list; // 83
 
+pub mod merge_sorted_array; // 88
+
 pub mod reverse_linked_list_ii; // 92
 
 pub mod validate_binary_search_tree; // 98
@@ -126,6 +128,8 @@ pub mod bulb_switcher; // 319
 pub mod coin_change; // 322
 pub mod number_of_connected_components_in_an_undirected_graph; // 323
 
+pub mod reconstruct_itinerary; // 332
+
 pub mod reverse_string; // 344
 
 pub mod moving_average_from_data_stream; // 346

src/merge_sorted_array.rs

@@ -0,0 +1,75 @@
+struct Solution;
+
+impl Solution {
+
+    pub fn merge(nums1: &mut Vec<i32>, m: i32, nums2: &mut Vec<i32>, n: i32) {
+        let m = m as usize;
+        let n = n as usize;
+
+        if n == 0 { } // do nothing
+        else if m == 0 {
+            for i in 0..n {
+                nums1[i] = nums2[i];
+            }
+        } else {
+            let mut nums1_i = m-1;
+            let mut nums2_i = n-1;
+            let mut nums1_done = false;
+            let mut nums2_done = false;
+
+            let total = m + n;
+
+            for i in 0..total {
+                let index = total-i-1;
+                if nums2_done {
+                    nums1[index] = nums1[nums1_i];
+                    if nums1_i == 0 { nums1_done = true; }
+                    else { nums1_i -= 1; }
+                } else if nums1_done {
+                    nums1[index] = nums2[nums2_i];
+                    if nums2_i == 0 { nums2_done = true; }
+                    else { nums2_i -= 1; }
+                } else {
+                    let num1 = nums1[nums1_i];
+                    let num2 = nums2[nums2_i];
+                    if num2 > num1 {
+                        nums1[index] = num2;
+                        if nums2_i == 0 { nums2_done = true; }
+                        else { nums2_i -= 1; }
+                    } else {
+                        nums1[index] = num1;
+                        if nums1_i == 0 { nums1_done = true; }
+                        else { nums1_i -= 1; }
+                    }
+                }
+            }
+        }
+    }
+
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn example_1() {
+        let mut nums1 = vec![1,2,3,0,0,0];
+        let m = 3;
+        let mut nums2 = vec![2,5,6];
+        let n = 3;
+        Solution::merge(&mut nums1, m, &mut nums2, n);
+        assert_eq!(nums1, vec![1,2,2,3,5,6]);
+    }
+
+    #[test]
+    fn example_2() {
+        let mut nums1 = vec![1];
+        let m = 1;
+        let mut nums2 = vec![];
+        let n = 0;
+        Solution::merge(&mut nums1, m, &mut nums2, n);
+        assert_eq!(nums1, vec![1]);
+    }
+
+}

src/reconstruct_itinerary.rs

@@ -0,0 +1,99 @@
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
+struct Ticket {
+    from: String,
+    to: String,
+}
+
+impl Ticket {
+
+    fn new(from: String, to: String) -> Self {
+        Self { from, to }
+    }
+
+    fn from_vec(ticket: &Vec<String>) -> Self {
+        Self { from: ticket[0].clone(), to: ticket[1].clone() }
+    }
+
+}
+
+/// You are given a list of airline `tickets` where `tickets[i] = [fromi, toi]`
+/// represent the departure and arrival airports of one flight. Reconstruct
+/// the itinerary in order and return it.
+///
+/// All of the tickets belong to a man who departs from `"JFK"`, thus, the
+/// itinerary must begin with `"JFK"`. If there are multiple valid itineraries,
+/// you should retun the itinerary that has the smallest lexical order when
+/// read as a single string.
+///
+/// * For example, the itinerary `["JFK", "LGA"]` has a smaller lexical order
+/// than `["JFK", "LGB"]`.
+///
+/// You may assume all tickets form at least one valid itinerary. You must use
+/// all the tickets once and only once.
+struct Solution;
+
+impl Solution {
+
+    fn to_map(tickets: &Vec<Vec<String>>) -> HashMap<String, HashSet<Ticket>> {
+        let mut result = HashMap::new();
+        for item in tickets {
+            let ticket = Ticket::from_vec(item);
+            let key = ticket.from.clone();
+            result
+                .entry(key)
+                .or_insert(HashSet::new())
+                .insert(ticket);
+        }
+
+        result
+    }
+
+    pub fn find_itinerary(tickets: Vec<Vec<String>>) -> Vec<String> {
+        let mut results = Vec::new();
+
+        let tickets = Self::to_map(&tickets);
+        let city = "JFK".to_string();
+        let path = vec![];
+        let seen = HashSet::new();
+        Self::worker(&tickets, city, path, seen, &mut results);
+
+        // TODO: Take lexical order result
+        vec![]
+    }
+
+    // TODO: Finish Implementation
+    fn worker(
+        _tickets: &HashMap<String, HashSet<Ticket>>,
+        _city: String,
+        _path: Vec<String>,
+        _seen: HashSet<Ticket>,
+        _results: &mut Vec<Vec<String>>
+    ) {
+
+    }
+
+    // pub fn all_paths_source_target(graph: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+    //     let mut results = Vec::new();
+    //     Self::worker(&graph, 0, vec![], &mut results);
+    //     results
+    // }
+
+    // fn worker(graph: &Vec<Vec<i32>>, node: i32, path: Vec<i32>, results: &mut Vec<Vec<i32>>) {
+    //     let n = graph.len();
+    //     let i = node as usize;
+    //     let mut path = path;
+    //     path.push(node);
+    //     if i == n - 1 {
+    //         results.push(path);
+    //     } else {
+    //         for &next in &graph[i] {
+    //             let cloned_path = path.clone();
+    //             Self::worker(graph, next, cloned_path, results);
+    //         }
+    //     }
+    // }
+
+}