solve 337, 347, 357, 368, 373

Author: songyzh

src/solution/mod.rs

@@ -273,3 +273,7 @@ mod s0322_coin_change;
 mod s0328_odd_even_linked_list;
 mod s0331_verify_preorder_serialization_of_a_binary_tree;
 mod s0337_house_robber_iii;
+mod s0347_top_k_frequent_elements;
+mod s0357_count_numbers_with_unique_digits;
+mod s0368_largest_divisible_subset;
+mod s0373_find_k_pairs_with_smallest_sums;

src/solution/s0337_house_robber_iii.rs

@@ -0,0 +1,107 @@
+/**
+ * [337] House Robber III
+ *
+ * The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the "root." Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that "all houses in this place forms a binary tree". It will automatically contact the police if two directly-linked houses were broken into on the same night.
+ *
+ * Determine the maximum amount of money the thief can rob tonight without alerting the police.
+ *
+ * Example 1:
+ *
+ *
+ * Input: [3,2,3,null,3,null,1]
+ *
+ *      <font color="red">3</font>
+ *     / \
+ *    2   3
+ *     \   \
+ *      <font color="red">3   1
+ * </font>
+ * Output: 7
+ * Explanation: Maximum amount of money the thief can rob = <font color="red" style="font-family: sans-serif, Arial, Verdana, "Trebuchet MS";">3</font><span style="font-family: sans-serif, Arial, Verdana, "Trebuchet MS";"> + </span><font color="red" style="font-family: sans-serif, Arial, Verdana, "Trebuchet MS";">3</font><span style="font-family: sans-serif, Arial, Verdana, "Trebuchet MS";"> + </span><font color="red" style="font-family: sans-serif, Arial, Verdana, "Trebuchet MS";">1</font><span style="font-family: sans-serif, Arial, Verdana, "Trebuchet MS";"> = </span><b style="font-family: sans-serif, Arial, Verdana, "Trebuchet MS";">7<span style="font-family: sans-serif, Arial, Verdana, "Trebuchet MS";">.</span>
+ *
+ * Example 2:
+ *
+ *
+ * Input: [3,4,5,1,3,null,1]
+ *
+ *      3
+ *     / \
+ *    <font color="red">4</font>   <font color="red">5</font>
+ *   / \   \
+ *  1   3   1
+ *
+ * Output: 9
+ * Explanation: Maximum amount of money the thief can rob = <font color="red">4</font> + <font color="red">5</font> = 9.
+ *
+ */
+pub struct Solution {}
+use crate::util::tree::{to_tree, TreeNode};
+
+// submission codes start here
+
+// Definition for a binary tree node.
+// #[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;
+impl Solution {
+    pub fn rob(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        if root.is_none() {
+            return 0;
+        }
+        let left = root.as_ref().unwrap().borrow().left.clone();
+        let right = root.as_ref().unwrap().borrow().right.clone();
+        if left.is_none() && right.is_none() {
+            return root.unwrap().borrow().val;
+        }
+        let (left_left, left_right) = if left.is_none() {
+            (None, None)
+        } else {
+            (
+                left.as_ref().unwrap().borrow().left.clone(),
+                left.as_ref().unwrap().borrow().right.clone(),
+            )
+        };
+
+        let (right_left, right_right) = if right.is_none() {
+            (None, None)
+        } else {
+            (
+                right.as_ref().unwrap().borrow().left.clone(),
+                right.as_ref().unwrap().borrow().right.clone(),
+            )
+        };
+
+        (root.unwrap().borrow().val
+            + Self::rob(left_left)
+            + Self::rob(left_right)
+            + Self::rob(right_left)
+            + Self::rob(right_right))
+        .max(Self::rob(left) + Self::rob(right))
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_337() {}
+}

src/solution/s0347_top_k_frequent_elements.rs

@@ -0,0 +1,54 @@
+/**
+ * [347] Top K Frequent Elements
+ *
+ * Given a non-empty array of integers, return the k most frequent elements.
+ *
+ * Example 1:
+ *
+ *
+ * Input: nums = <span id="example-input-1-1">[1,1,1,2,2,3]</span>, k = <span id="example-input-1-2">2</span>
+ * Output: <span id="example-output-1">[1,2]</span>
+ *
+ *
+ * <div>
+ * Example 2:
+ *
+ *
+ * Input: nums = <span id="example-input-2-1">[1]</span>, k = <span id="example-input-2-2">1</span>
+ * Output: <span id="example-output-2">[1]</span>
+ * </div>
+ *
+ * Note:
+ *
+ *
+ * 	You may assume k is always valid, 1 &le; k &le; number of unique elements.
+ * 	Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn top_k_frequent(nums: Vec<i32>, k: i32) -> Vec<i32> {
+        use std::collections::HashMap;
+        let mut map = HashMap::new();
+        nums.iter()
+            .map(|num| *map.entry(*num).or_insert(0) += 1)
+            .count();
+        let mut nums: Vec<i32> = map.keys().map(|num| *num).collect();
+        nums.sort_by_key(|num| -*map.get(num).unwrap());
+        nums[0..k as usize].to_vec()
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_347() {}
+}

src/solution/s0357_count_numbers_with_unique_digits.rs

@@ -0,0 +1,56 @@
+/**
+ * [357] Count Numbers with Unique Digits
+ *
+ * Given a non-negative integer n, count all numbers with unique digits, x, where 0 &le; x < 10^n.
+ *
+ * <div>
+ * Example:
+ *
+ *
+ * Input: <span id="example-input-1-1">2</span>
+ * Output: <span id="example-output-1">91
+ * Explanation: </span>The answer should be the total numbers in the range of 0 &le; x < 100,
+ *              excluding 11,22,33,44,55,66,77,88,99
+ *
+ * </div>
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn count_numbers_with_unique_digits(n: i32) -> i32 {
+        if n == 0 {
+            return 0;
+        }
+        if n == 1 {
+            return 10;
+        }
+        if n == 2 {
+            return 91;
+        }
+        let mut dp = vec![0; n as usize + 1];
+        dp[1] = 10;
+        dp[2] = 91;
+        for i in 3..(n + 1) {
+            let mut curr = 9;
+            let mut remain = 9;
+            for _ in 0..(i - 1) {
+                curr *= remain;
+                remain -= 1;
+            }
+            dp[i as usize] = dp[i as usize - 1] + curr;
+        }
+        dp[n as usize]
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_357() {}
+}

src/solution/s0368_largest_divisible_subset.rs

@@ -0,0 +1,71 @@
+/**
+ * [368] Largest Divisible Subset
+ *
+ * Given a set of distinct positive integers, find the largest subset such that every pair (Si, Sj) of elements in this subset satisfies:
+ *
+ * Si % Sj = 0 or Sj % Si = 0.
+ *
+ * If there are multiple solutions, return any subset is fine.
+ *
+ * Example 1:
+ *
+ * <div>
+ *
+ * Input: <span id="example-input-1-1">[1,2,3]</span>
+ * Output: <span id="example-output-1">[1,2] </span>(of course, [1,3] will also be ok)
+ *
+ *
+ * <div>
+ * Example 2:
+ *
+ *
+ * Input: <span id="example-input-2-1">[1,2,4,8]</span>
+ * Output: <span id="example-output-2">[1,2,4,8]</span>
+ *
+ * </div>
+ * </div>
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn largest_divisible_subset(nums: Vec<i32>) -> Vec<i32> {
+        let mut nums = nums;
+        nums.sort();
+        let mut prev_indices: Vec<i32> = vec![-1; nums.len()];
+        let mut dp = vec![1; nums.len()];
+        let mut max_count = 0;
+        let mut max_index: i32 = -1;
+        for i in 0..nums.len() {
+            for j in (0..i).rev() {
+                if nums[i] % nums[j] == 0 && dp[j] + 1 > dp[i] {
+                    dp[i] = dp[j] + 1;
+                    prev_indices[i] = j as i32;
+                }
+            }
+            if dp[i] > max_count {
+                max_count = dp[i];
+                max_index = i as i32;
+            }
+        }
+        let mut ret = vec![];
+        while max_index != -1 {
+            ret.push(nums[max_index as usize]);
+            max_index = prev_indices[max_index as usize];
+        }
+        ret
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_368() {
+        println!("{:?}", Solution::largest_divisible_subset(vec![1, 2, 3]));
+    }
+}

src/solution/s0373_find_k_pairs_with_smallest_sums.rs

@@ -0,0 +1,88 @@
+/**
+ * [373] Find K Pairs with Smallest Sums
+ *
+ * You are given two integer arrays nums1 and nums2 sorted in ascending order and an integer k.
+ *
+ * Define a pair (u,v) which consists of one element from the first array and one element from the second array.
+ *
+ * Find the k pairs (u1,v1),(u2,v2) ...(uk,vk) with the smallest sums.
+ *
+ * Example 1:
+ *
+ *
+ * Input: nums1 = <span id="example-input-1-1">[1,7,11]</span>, nums2 = <span id="example-input-1-2">[2,4,6]</span>, k = <span id="example-input-1-3">3</span>
+ * Output: <span id="example-output-1">[[1,2],[1,4],[1,6]]
+ * Explanation: </span>The first 3 pairs are returned from the sequence:
+ *              [1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
+ *
+ * Example 2:
+ *
+ *
+ * Input: nums1 = [1,1,2], nums2 = [1,2,3], k = 2
+ * Output: [1,1],[1,1]<span>
+ * Explanation: </span>The first 2 pairs are returned from the sequence:
+ *              [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
+ *
+ * Example 3:
+ *
+ *
+ * Input: nums1 = [1,2], nums2 = [3], k = 3
+ * Output: [1,3],[2,3]<span>
+ * Explanation: </span>All possible pairs are returned from the sequence: [1,3],[2,3]
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn k_smallest_pairs(nums1: Vec<i32>, nums2: Vec<i32>, k: i32) -> Vec<Vec<i32>> {
+        // use a max heap
+        use std::collections::BinaryHeap;
+        let k = k as usize;
+        let mut max_heap = BinaryHeap::with_capacity(k);
+        for num1 in &nums1 {
+            for num2 in &nums2 {
+                let sum = *num1 + *num2;
+                if max_heap.len() < k {
+                    max_heap.push(sum);
+                } else {
+                    let mut top = max_heap.peek_mut().unwrap();
+                    if sum < *top {
+                        *top = sum;
+                    }
+                }
+            }
+        }
+        let mut ret = vec![];
+        let top = max_heap.peek();
+        if top.is_none() {
+            return ret;
+        }
+        let top = *top.unwrap();
+        for num1 in &nums1 {
+            for num2 in &nums2 {
+                let sum = *num1 + *num2;
+                if sum <= top {
+                    ret.push(vec![*num1, *num2]);
+                }
+            }
+        }
+        ret.sort_by_key(|v| v[0] + v[1]);
+        if ret.len() > k {
+            ret.split_off(k);
+        }
+        ret
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_373() {}
+}