solve #84

Author: aylei

src/lib.rs

@@ -80,3 +80,8 @@ mod n0076_minimum_window_substring;
 mod n0077_combinations;
 mod n0078_subsets;
 mod n0079_word_search;
+mod n0080_remove_duplicates_from_sorted_array_ii;
+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;

src/n0079_word_search.rs

@@ -25,6 +25,7 @@ pub struct Solution {}
 
 // submission codes start here
 
+// TODO: use HashSet to record visited pos
 impl Solution {
     pub fn exist(board: Vec<Vec<char>>, word: String) -> bool {
         if board.is_empty() || word.len() < 1 { return false }

src/n0080_remove_duplicates_from_sorted_array_ii.rs

@@ -0,0 +1,66 @@
+/**
+ * [80] Remove Duplicates from Sorted Array II
+ *
+ * Given a sorted array nums, remove the duplicates <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> such that duplicates appeared at most twice and return the new length.
+ * 
+ * Do not allocate extra space for another array, you must do this by modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> with O(1) extra memory.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Given nums = [1,1,1,2,2,3],
+ * 
+ * Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.
+ * 
+ * It doesn't matter what you leave beyond the returned length.
+ * 
+ * Example 2:
+ * 
+ * 
+ * Given nums = [0,0,1,1,1,1,2,3,3],
+ * 
+ * Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.
+ * 
+ * It doesn't matter what values are set beyond the returned length.
+ * 
+ * 
+ * Clarification:
+ * 
+ * Confused why the returned value is an integer but your answer is an array?
+ * 
+ * Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.
+ * 
+ * Internally you can think of this:
+ * 
+ * 
+ * // nums is passed in by reference. (i.e., without making a copy)
+ * int len = removeDuplicates(nums);
+ * 
+ * // any modification to nums in your function would be known by the caller.
+ * // using the length returned by your function, it prints the first len elements.
+ * for (int i = 0; i < len; i++) {
+ *     print(nums[i]);
+ * }
+ * 
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
+        0
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_80() {
+    }
+}

src/n0081_search_in_rotated_sorted_array_ii.rs

@@ -0,0 +1,50 @@
+/**
+ * [81] Search in Rotated Sorted Array II
+ *
+ * Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+ * 
+ * (i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).
+ * 
+ * You are given a target value to search. If found in the array return true, otherwise return false.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: nums = [2,5,6,0,0,1,2], target = 0
+ * Output: true
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: nums = [2,5,6,0,0,1,2], target = 3
+ * Output: false
+ * 
+ * Follow up:
+ * 
+ * 
+ * 	This is a follow up problem to <a href="/problems/search-in-rotated-sorted-array/description/">Search in Rotated Sorted Array</a>, where nums may contain duplicates.
+ * 	Would this affect the run-time complexity? How and why?
+ * 
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn search(nums: Vec<i32>, target: i32) -> bool {
+        false
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_81() {
+    }
+}

src/n0082_remove_duplicates_from_sorted_list_ii.rs

@@ -0,0 +1,57 @@
+/**
+ * [82] Remove Duplicates from Sorted List II
+ *
+ * Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: 1->2->3->3->4->4->5
+ * Output: 1->2->5
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: 1->1->1->2->3
+ * Output: 2->3
+ * 
+ * 
+ */
+pub struct Solution {}
+use super::util::linked_list::{ListNode, to_list};
+
+// submission codes start here
+
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+// 
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+impl Solution {
+    pub fn delete_duplicates(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        None
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_82() {
+    }
+}

src/n0083_remove_duplicates_from_sorted_list.rs

@@ -0,0 +1,57 @@
+/**
+ * [83] Remove Duplicates from Sorted List
+ *
+ * Given a sorted linked list, delete all duplicates such that each element appear only once.
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: 1->1->2
+ * Output: 1->2
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: 1->1->2->3->3
+ * Output: 1->2->3
+ * 
+ * 
+ */
+pub struct Solution {}
+use super::util::linked_list::{ListNode, to_list};
+
+// submission codes start here
+
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+// 
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+impl Solution {
+    pub fn delete_duplicates(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        None
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_83() {
+    }
+}

src/n0084_largest_rectangle_in_histogram.rs

@@ -0,0 +1,72 @@
+/**
+ * [84] Largest Rectangle in Histogram
+ *
+ * Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.
+ * 
+ *  
+ * 
+ * <img src="https://assets.leetcode.com/uploads/2018/10/12/histogram.png" style="width: 188px; height: 204px;" /><br />
+ * <small>Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].</small>
+ * 
+ *  
+ * 
+ * <img src="https://assets.leetcode.com/uploads/2018/10/12/histogram_area.png" style="width: 188px; height: 204px;" /><br />
+ * <small>The largest rectangle is shown in the shaded area, which has area = 10 unit.</small>
+ * 
+ *  
+ * 
+ * Example:
+ * 
+ * 
+ * Input: [2,1,5,6,2,3]
+ * Output: 10
+ * 
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+// record the height and start position using 2 stack, thus we reuse the previously scanned information
+impl Solution {
+    pub fn largest_rectangle_area(heights: Vec<i32>) -> i32 {
+        let mut positions = Vec::new();
+        let mut hs = Vec::new();
+        let mut max_area = 0;
+        let len = heights.len();
+        for (i, h) in heights.into_iter().enumerate() {
+            let mut last_pop = None;
+            while hs.last().is_some() && *hs.last().unwrap() >= h {
+                max_area = i32::max(max_area, hs.last().unwrap() * ((i - positions.last().unwrap()) as i32));
+                hs.pop();
+                last_pop = positions.pop();
+            }
+            if last_pop.is_some() { positions.push(last_pop.unwrap()); } else { positions.push(i); }
+            hs.push(h);
+        }
+        // drain stack
+        while !hs.is_empty() {
+            max_area = i32::max(max_area, hs.last().unwrap() * ((len - positions.last().unwrap()) as i32));
+            positions.pop();
+            hs.pop();
+        }
+        max_area
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_84() {
+        assert_eq!(Solution::largest_rectangle_area(vec![2,1,5,6,2,3]), 10);
+        assert_eq!(Solution::largest_rectangle_area(vec![1,1,1,1,1,1,1,1]), 8);
+        assert_eq!(Solution::largest_rectangle_area(vec![2,2]), 4);
+        assert_eq!(Solution::largest_rectangle_area(vec![1,2,8,8,2,2,1]), 16);
+        assert_eq!(Solution::largest_rectangle_area(vec![2,1,2]), 3);
+        assert_eq!(Solution::largest_rectangle_area(vec![1,3,2,1,2]), 5);
+    }
+}