Solve #222

Author: aylei

src/lib.rs

@@ -189,3 +189,5 @@ mod n0218_the_skyline_problem;
 mod n0220_contains_duplicate_iii;
 mod n0219_contains_duplicate_ii;
 mod n0221_maximal_square;
+mod n0223_rectangle_area;
+mod n0222_count_complete_tree_nodes;

src/n0222_count_complete_tree_nodes.rs

@@ -0,0 +1,83 @@
+/**
+ * [222] Count Complete Tree Nodes
+ *
+ * Given a complete binary tree, count the number of nodes.
+ *
+ * Note:
+ *
+ * <u>Definition of a complete binary tree from <a href="http://en.wikipedia.org/wiki/Binary_tree#Types_of_binary_trees" target="_blank">Wikipedia</a>:</u><br />
+ * In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2^h nodes inclusive at the last level h.
+ *
+ * Example:
+ *
+ *
+ * Input:
+ *     1
+ *    / \
+ *   2   3
+ *  / \  /
+ * 4  5 6
+ *
+ * Output: 6
+ *
+ */
+pub struct Solution {}
+use super::util::tree::{to_tree, TreeNode};
+
+// submission codes start here
+
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn count_nodes(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        // 0. get the hight of full nodes
+        let mut height = 0;
+        let mut curr = root.clone();
+        let mut result = 0;
+        while let Some(inner) = curr {
+            height += 1;
+            result += 2_i32.pow(height-1);
+            curr = inner.borrow().right.clone();
+        }
+        if height == 0 { return result }
+        // 1. 'binary search' to find the node number of the lowest level
+        // the lowest level may have 0~2^H-1 node
+        let mut curr_root = root.clone();
+        while height > 1 {
+            // see if left tree is full
+            let mut node = curr_root.clone().unwrap().borrow().left.clone();
+            let mut level = 2;
+            while level < height {
+                node = node.unwrap().borrow().right.clone();
+                level += 1;
+            }
+            if node.unwrap().borrow().right.is_some() {
+                curr_root = curr_root.unwrap().borrow().right.clone();
+                result += 2_i32.pow(height-1);
+            } else {
+                curr_root = curr_root.unwrap().borrow().left.clone();
+            }
+            height -= 1;
+        }
+        if curr_root.as_ref().unwrap().borrow().left.is_some() {
+            result += 1;
+        }
+        result
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_222() {
+        assert_eq!(Solution::count_nodes(tree![1,1,1,1,1,1,1]), 7);
+        assert_eq!(Solution::count_nodes(tree![]), 0);
+        assert_eq!(Solution::count_nodes(tree![1,1]), 2);
+        assert_eq!(Solution::count_nodes(tree![1]), 1);
+        assert_eq!(Solution::count_nodes(tree![1,1,1]), 3);
+    }
+}

src/n0223_rectangle_area.rs

@@ -0,0 +1,39 @@
+/**
+ * [223] Rectangle Area
+ *
+ * Find the total area covered by two rectilinear rectangles in a 2D plane.
+ *
+ * Each rectangle is defined by its bottom left corner and top right corner as shown in the figure.
+ *
+ * <img alt="Rectangle Area" src="https://assets.leetcode.com/uploads/2018/10/22/rectangle_area.png" style="width: 542px; height: 304px;" />
+ *
+ * Example:
+ *
+ *
+ * Input: A = <span id="example-input-1-1">-3</span>, B = <span id="example-input-1-2">0</span>, C = <span id="example-input-1-3">3</span>, D = <span id="example-input-1-4">4</span>, E = <span id="example-input-1-5">0</span>, F = <span id="example-input-1-6">-1</span>, G = <span id="example-input-1-7">9</span>, H = <span id="example-input-1-8">2</span>
+ * Output: <span id="example-output-1">45</span>
+ *
+ * Note:
+ *
+ * Assume that the total area is never beyond the maximum possible value of int.
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn compute_area(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32, g: i32, h: i32) -> i32 {
+        0
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_223() {}
+}