Add solutions

Author: martwz

src/leetcode/interview/mod.rs

@@ -1,2 +1,3 @@
 mod amazon;
 mod robinhood;
+mod uber;

src/leetcode/interview/uber/mod.rs

@@ -0,0 +1 @@
+automod::dir!("src/leetcode/interview/uber");

src/leetcode/interview/uber/num_buses_to_destination.rs

@@ -0,0 +1,73 @@
+use std::collections::{HashMap, HashSet, VecDeque};
+
+// 815. Bus Routes, Hard
+// https://leetcode.com/problems/bus-routes/
+impl Solution {
+    pub fn num_buses_to_destination(routes: Vec<Vec<i32>>, source: i32, target: i32) -> i32 {
+        let mut hm: HashMap<i32, Vec<(i32, i32)>> = HashMap::new();
+
+        for (bus, route) in routes.iter().enumerate() {
+            let bus = bus as i32;
+
+            let mut route = route.clone();
+            route.push(route[0]);
+
+            for j in 0..route.len() - 1 {
+                let j = j as i32;
+                hm.entry(route[j as usize])
+                    .and_modify(|f| f.push((route[j as usize + 1], bus)))
+                    .or_insert(vec![(route[j as usize + 1], bus)]);
+            }
+        }
+
+        let mut queue: VecDeque<(i32, HashSet<i32>)> = VecDeque::new();
+        queue.push_back((source, HashSet::<i32>::new()));
+
+        let mut seen: HashSet<i32> = HashSet::new();
+
+        let mut min_busses = usize::MAX;
+
+        while !queue.is_empty() {
+            let (stop, busses) = queue.pop_front().unwrap();
+
+            if stop == target {
+                min_busses = min_busses.min(busses.len());
+            }
+
+            seen.insert(stop);
+
+            for edge in hm.get(&stop).unwrap_or(&vec![]) {
+                if seen.contains(&edge.0) {
+                    continue;
+                }
+
+                let mut busses = busses.clone();
+                busses.insert(edge.1);
+                queue.push_back((edge.0, busses));
+            }
+        }
+
+        min_busses as i32
+    }
+}
+
+struct Solution {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::vec_vec_i32;
+
+    #[test]
+    fn test_num_buses_to_destination() {
+        assert_eq!(Solution::num_buses_to_destination(vec_vec_i32![[1, 2, 7], [3, 6, 7]], 1, 6), 2);
+    }
+
+    #[test]
+    fn test_num_buses_to_destination2() {
+        assert_eq!(
+            Solution::num_buses_to_destination(vec_vec_i32![[7, 12], [4, 5, 15], [6], [15, 19], [9, 12, 13]], 15, 12),
+            -1
+        );
+    }
+}

src/leetcode/problem/can_construct.rs

@@ -0,0 +1,26 @@
+use std::collections::HashMap;
+
+// 1400. Construct K Palindrome Strings, Medium
+// https://leetcode.com/problems/construct-k-palindrome-strings/
+impl Solution {
+    pub fn can_construct(s: String, k: i32) -> bool {
+        let mut counter: HashMap<char, i32> = HashMap::new();
+
+        let n = s.len() as i32;
+        for ch in s.chars() {
+            counter.entry(ch).and_modify(|c| *c += 1).or_insert(1);
+        }
+
+        let mut odds = 0;
+
+        for (_k, v) in counter {
+            if v % 2 != 0 {
+                odds += 1;
+            }
+        }
+
+        return n >= k && odds <= k;
+    }
+}
+
+struct Solution {}

src/leetcode/problem/keys-and-rooms.rs renamed to src/leetcode/problem/can_visit_all_rooms.rs

@@ -0,0 +1,28 @@
+// 986. Interval List Intersections, Medium
+// https://leetcode.com/problems/interval-list-intersections/
+impl Solution {
+    pub fn interval_intersection(first_list: Vec<Vec<i32>>, second_list: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
+        let mut ans: Vec<Vec<i32>> = vec![];
+
+        let (mut i, mut j) = (0, 0);
+
+        while i < first_list.len() && j < second_list.len() {
+            let start = i32::max(first_list[i][0], second_list[j][0]);
+            let end = i32::min(first_list[i][1], second_list[j][1]);
+
+            if start <= end {
+                ans.push(vec![start, end]);
+            }
+
+            if first_list[i][1] < second_list[j][1] {
+                i += 1;
+            } else {
+                j += 1;
+            }
+        }
+
+        ans
+    }
+}
+
+struct Solution {}

src/leetcode/problem/interval_intersection.rs

@@ -0,0 +1,48 @@
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
+    pub val: i32,
+    pub left: Option<Rc<RefCell<TreeNode>>>,
+    pub right: Option<Rc<RefCell<TreeNode>>>,
+}
+
+impl TreeNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        TreeNode { val, left: None, right: None }
+    }
+}
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+// 993. Cousins in Binary Tree, Easy
+// https://leetcode.com/problems/cousins-in-binary-tree/
+impl Solution {
+    pub fn is_cousins(root: Option<Rc<RefCell<TreeNode>>>, x: i32, y: i32) -> bool {
+        let mut found: Vec<(i32, i32)> = vec![]; // (parent, level)
+
+        fn bfs(node: Option<Rc<RefCell<TreeNode>>>, x: &i32, y: &i32, parent: i32, level: i32, found: &mut Vec<(i32, i32)>) {
+            if node.is_some() {
+                let node = node.as_ref().unwrap().borrow();
+
+                if found.len() == 2 {
+                    return;
+                }
+
+                if node.val == *x || node.val == *y {
+                    found.push((parent, level));
+                    return;
+                }
+
+                bfs(node.left.clone(), &x, &y, node.val, level + 1, found);
+                bfs(node.right.clone(), &x, &y, node.val, level + 1, found);
+            }
+        }
+
+        bfs(root, &x, &y, -1, 0, &mut found);
+
+        found.len() == 2 && found[0].0 != found[1].0 && found[0].1 == found[1].1
+    }
+}
+
+struct Solution {}

src/leetcode/problem/is_cousins.rs

@@ -0,0 +1,47 @@
+use std::collections::HashMap;
+
+// 465. Optimal Account Balancing, Hard
+// https://leetcode.com/problems/optimal-account-balancing/
+impl Solution {
+    pub fn min_transfers(transactions: Vec<Vec<i32>>) -> i32 {
+        let mut hm = HashMap::new();
+
+        for transaction in transactions.iter() {
+            let (from, to, amount) = (transaction[0], transaction[1], transaction[2]);
+            hm.entry(from).and_modify(|d| *d -= amount).or_insert(-amount);
+            hm.entry(to).and_modify(|d| *d += amount).or_insert(amount);
+        }
+
+        let mut debts = vec![];
+        for v in hm.values() {
+            debts.push(*v);
+        }
+
+        fn dfs(debts: &mut Vec<i32>, mut i: usize) -> i32 {
+            while i < debts.len() && debts[i] == 0 {
+                i += 1;
+            }
+
+            let mut ans = i32::MAX;
+            let mut prev = 0;
+            for j in i + 1..debts.len() {
+                if debts[j] != prev && debts[j] * debts[i] < 0 {
+                    debts[j] += debts[i];
+                    ans = i32::min(ans, 1 + dfs(debts, i + 1));
+                    debts[j] -= debts[i];
+                    prev = debts[j];
+                }
+            }
+
+            if ans < i32::MAX {
+                ans
+            } else {
+                0
+            }
+        }
+
+        dfs(&mut debts, 0)
+    }
+}
+
+struct Solution {}

src/leetcode/problem/min_transfers.rs

@@ -0,0 +1,68 @@
+use std::collections::{HashMap, VecDeque};
+
+// 496. Next Greater Element I, Easy
+// https://leetcode.com/problems/next-greater-element-i/
+impl Solution {
+    pub fn next_greater_element(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let mut queue = VecDeque::new();
+        let mut nums2_next_bigger = HashMap::new();
+
+        for (i, curr_num) in nums2.iter().enumerate() {
+            while queue.len() > 0 && *queue.back().unwrap() < curr_num {
+                let num = queue.pop_back().unwrap();
+                nums2_next_bigger.insert(num, *curr_num);
+            }
+            queue.push_back(curr_num);
+        }
+
+        queue.iter().for_each(|k| {
+            nums2_next_bigger.insert(*k, -1);
+        });
+
+        let mut ans = vec![];
+
+        'outer: for i in 0..nums1.len() {
+            for j in 0..nums2.len() {
+                if nums1[i] == nums2[j] {
+                    ans.push(*nums2_next_bigger.get(&nums2[j]).unwrap());
+                    continue 'outer;
+                }
+            }
+        }
+
+        ans
+    }
+
+    pub fn next_greater_element_slow(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let mut ans = vec![];
+
+        'outer: for i in 0..nums1.len() {
+            let mut found = -1;
+            let mut found_i = -1;
+
+            for j in i + 1..nums2.len() {
+                if nums1[i] == nums2[j] {
+                    found = nums2[j];
+                    found_i = j as i32;
+                    break;
+                }
+            }
+
+            if found_i != -1 {
+                let found_i = found_i as usize;
+                for i in found_i + 1..nums2.len() {
+                    if found < nums2[i] {
+                        ans.push(nums2[i]);
+                        continue 'outer;
+                    }
+                }
+            }
+
+            ans.push(-1);
+        }
+
+        ans
+    }
+}
+
+struct Solution {}

src/leetcode/problem/next_greater_element.rs

@@ -0,0 +1,46 @@
+// 764. Largest Plus Sign, Medium
+// https://leetcode.com/problems/largest-plus-sign/
+impl Solution {
+    pub fn order_of_largest_plus_sign(n: i32, mines: Vec<Vec<i32>>) -> i32 {
+        let n = n as usize;
+        let mut grid = vec![vec![0; n]; n];
+
+        for mine in mines.iter() {
+            grid[mine[0] as usize][mine[1] as usize] = 1;
+        }
+
+        let mut prefix_sum_grid = vec![vec![i32::MAX; n]; n];
+
+        for i in 0..n {
+            let mut sum_right = 0;
+            let mut sum_left = 0;
+            let mut sum_down = 0;
+            let mut sum_up = 0;
+
+            for j in 0..n {
+                sum_right += grid[i][j];
+                prefix_sum_grid[i][j] += i32::min(prefix_sum_grid[i][j], sum_right);
+
+                sum_left += grid[i][n - j - 1];
+                prefix_sum_grid[i][n - j - 1] += i32::min(prefix_sum_grid[i][n - j - 1], sum_left);
+
+                sum_down += grid[j][i];
+                prefix_sum_grid[j][i] += i32::min(prefix_sum_grid[j][i], sum_down);
+
+                sum_up += grid[n - j - 1][i];
+                prefix_sum_grid[n - j - 1][i] += i32::min(prefix_sum_grid[n - j - 1][i], sum_up);
+            }
+        }
+
+        let mut ans = 0;
+        for i in 0..n {
+            for j in 0..n {
+                ans = i32::max(ans, prefix_sum_grid[i][j]);
+            }
+        }
+
+        ans
+    }
+}
+
+struct Solution {}

src/leetcode/problem/order_of_largest_plus_sign.rs

@@ -0,0 +1,42 @@
+use std::collections::{HashMap, HashSet};
+
+// 1743. Restore the Array From Adjacent Pairs, Medium
+// https://leetcode.com/problems/restore-the-array-from-adjacent-pairs/
+impl Solution {
+    pub fn restore_array(adjacent_pairs: Vec<Vec<i32>>) -> Vec<i32> {
+        let mut graph: HashMap<i32, Vec<i32>> = HashMap::new();
+
+        for pair in adjacent_pairs.iter() {
+            let (u, v) = (pair[0], pair[1]);
+            graph.entry(u).and_modify(|e| e.push(v)).or_insert(vec![v]);
+            graph.entry(v).and_modify(|e| e.push(u)).or_insert(vec![u]);
+        }
+
+        let n = adjacent_pairs.len() + 1;
+        let mut ans = vec![];
+
+        let mut head_cands = graph.iter().map(|(k, v)| (*k, v.len())).collect::<Vec<(i32, usize)>>();
+        head_cands.sort_by_key(|(_, v)| *v);
+
+        let mut head = head_cands.first().unwrap().0;
+        let mut seen = HashSet::<i32>::new();
+
+        while ans.len() < n {
+            seen.insert(head);
+            ans.push(head);
+            
+            let cands = graph.get(&head).unwrap();
+            for cand in cands.iter() {
+                if !seen.contains(&cand) {
+                    seen.insert(*cand);
+                    head = *cand;
+                    break;
+                }
+            }
+        }
+
+        ans
+    }
+}
+
+struct Solution {}