solve #86

Author: aylei

src/lib.rs

@@ -85,3 +85,5 @@ mod n0081_search_in_rotated_sorted_array_ii;
 mod n0082_remove_duplicates_from_sorted_list_ii;
 mod n0083_remove_duplicates_from_sorted_list;
 mod n0084_largest_rectangle_in_histogram;
+mod n0085_maximal_rectangle;
+mod n0086_partition_list;

src/n0085_maximal_rectangle.rs

@@ -0,0 +1,41 @@
+/**
+ * [85] Maximal Rectangle
+ *
+ * Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.
+ * 
+ * Example:
+ * 
+ * 
+ * Input:
+ * [
+ *   ["1","0","1","0","0"],
+ *   ["1","0","1","1","1"],
+ *   ["1","1","1","1","1"],
+ *   ["1","0","0","1","0"]
+ * ]
+ * Output: 6
+ * 
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn maximal_rectangle(matrix: Vec<Vec<char>>) -> i32 {
+        let mut max_area = 0;
+        
+        max_area
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_85() {
+    }
+}

src/n0086_partition_list.rs

@@ -0,0 +1,63 @@
+/**
+ * [86] Partition List
+ *
+ * Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
+ * 
+ * You should preserve the original relative order of the nodes in each of the two partitions.
+ * 
+ * Example:
+ * 
+ * 
+ * Input: head = 1->4->3->2->5->2, x = 3
+ * Output: 1->2->2->4->3->5
+ * 
+ * 
+ */
+pub struct Solution {}
+use super::util::linked_list::{ListNode, to_list};
+
+impl Solution {
+    pub fn partition(head: Option<Box<ListNode>>, x: i32) -> Option<Box<ListNode>> {
+        let mut lower = Some(Box::new(ListNode::new(0)));
+        let mut higher = Some(Box::new(ListNode::new(0)));
+        let mut lower_tail = lower.as_mut();
+        let mut higher_tail = higher.as_mut();
+        let mut head = head;
+        while let Some(mut inner) = head {
+            let mut next = inner.next.take();
+            if inner.val < x {
+                lower_tail.as_mut().unwrap().next = Some(inner);
+                lower_tail = lower_tail.unwrap().next.as_mut();
+            } else {
+                higher_tail.as_mut().unwrap().next = Some(inner);
+                higher_tail = higher_tail.unwrap().next.as_mut();
+            }
+            head = next
+        }
+        lower_tail.as_mut().unwrap().next = higher.unwrap().next.take();
+        lower.unwrap().next.take()
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_86() {
+        assert_eq!(
+            Solution::partition(linked![1,4,3,2,5,2], 3),
+            linked![1,2,2,4,3,5]
+        );
+        assert_eq!(
+            Solution::partition(linked![1,4,3,2,5,2], 8),
+            linked![1,4,3,2,5,2]
+        );
+        assert_eq!(
+            Solution::partition(linked![], 0),
+            linked![]
+        );
+    }
+}

src/util/linked_list.rs

@@ -23,4 +23,10 @@ pub fn to_list(vec: Vec<i32>) -> Option<Box<ListNode>> {
         current = Some(Box::new(node));
     }
     current
-}
+}
+
+#[macro_export]
+macro_rules! linked {
+    ($($e:expr),*) => {to_list(vec![$($e.to_owned()), *])};
+    ($($e:expr,)*) => {to_list(vec![$($e.to_owned()), *])};
+}

src/util/mod.rs

@@ -1,3 +1,4 @@
+#[macro_use]
 pub mod linked_list;
 #[macro_use]
 pub mod vec_string;