do hard

Author: RUAN0007

Basic.md

@@ -269,7 +269,7 @@ with_stock_balances[i][k] = max(with_stock_balances[i-1][k], no_stock_balances[i
   * Similar to [84. Largest Rectangle in Histogram](src/problem/p0084_largest_rectangle_in_histogram.rs), solved with monotonic stack. 
 * [87. Scramble String](src/problem/p0087_scramble_string.rs)
   * Bottom-up approach with the increment on the substring length
-  * To redo and review with top-down approach with memoization.
+  * TODO: review with top-down approach with memoization.
 * [135. Candy](src/problem/p0135_candy.rs)
   * Smart tricks
 * [149. Max Points on a Line](src/problem/p0149_max_points_on_a_line.rs)
@@ -309,6 +309,23 @@ with_stock_balances[i][k] = max(with_stock_balances[i-1][k], no_stock_balances[i
   * Prepare a vector of prefix sum S
   * For each i, count j > i s.t S\[j\]-S\[i\] within the range
     * Leverage the MergeSort, similar to [315. Count of Smaller Numbers After Self](src/problem/p0315_count_of_smaller_numbers_after_self.rs).
+* [330. Patching Array](src/problem/p0330_patching_array.rs)
+  * Smart Tricks by Recursion: Assume the previous i number can attain \[0,next_miss]),
+    * If num[i] <= next_miss:the range can be augment to [0, next_miss+num[i]) by considering num[i].
+    * Else:pad the array with next_muss to augment into [0, next_miss*2)
+* [335. Self Crossing](src/problem/p0335_self_crossing.rs)
+  * Assume edge i to be first crossed, enumerate three canonical scenarios, in which the edge is crossed by i+4,i+5,and i+6.
+  * Relate the scenario with the edge length conditions.
+* [336. Palindrome Pairs](src/problem/p0336_palindrome_pairs.rs)
+  * Build a trie for the reversed strings
+* [352. Data Stream as Disjoint Intervals](src/problem/p0352_data_stream_as_disjoint_intervals.rs)
+  * Ordered BTree Map
+* [354. Russian Doll Envelopes](src/problem/p0354_russian_doll_envelopes.rs)
+  * Longest Increasing Subsequence
+* [363. Max Sum of Rectangle No Larger Than K](src/problem/p0363_max_sum_of_rectangle_no_larger_than_k.rs)
+  * Two related subproblems: 
+    * Max Sum Submatrix (KaDane's Algorithm)
+    * Subarray with the sum no larger than k (Compute during the Merge Sort, similar to [327. Count of Range Sum](src/problem/p0327_count_of_range_sum.rs))
 
 # [Collected Template](src/problem/p0000_template.rs)
 * Data structure:

src/problem/mod.rs

@@ -211,3 +211,9 @@ mod p0315_count_of_smaller_numbers_after_self;
 mod p0321_create_maximum_number;
 mod p0327_count_of_range_sum;
 mod p0329_longest_increasing_path_in_a_matrix;
+mod p0330_patching_array;
+mod p0335_self_crossing;
+mod p0336_palindrome_pairs;
+mod p0352_data_stream_as_disjoint_intervals;
+mod p0354_russian_doll_envelopes;
+mod p0363_max_sum_of_rectangle_no_larger_than_k;

src/problem/p0000_template.rs

@@ -966,44 +966,36 @@ impl MapUtil {
         map.insert(3, "a".to_owned());
         map.insert(5, "b".to_owned());
         map.insert(8, "c".to_owned());
+
+        use std::ops::Range; // [start, end)
+        use std::ops::RangeInclusive; // [start, end]
+
+        use std::ops::RangeTo; // (-inf, end)
+        use std::ops::RangeToInclusive; // (-inf, end]
+        use std::ops::RangeFrom; // [start, +inf)
+        use std::ops::RangeFull; // [-inf, +inf]
         // key, value typed with &
-        for (key, value) in map.range((Included(&4), Included(&8))) {
-            // println!("{}: {}", key, value);
+        // for (key, value) in map.range(Range{start:3, end:7}) {
+        for (key, value) in map.range(RangeInclusive::new(3, 5)) {
+            println!("{}: {}", key, value);
         }
 
-        for (key, value) in map.range_mut((Included(&4), Included(&8))) {
+        for (key, value) in map.range_mut(RangeFull) {
             // *key = 1; key is always immutable. 
-            *value = "asdf".to_owned();
+            *value = "d".to_owned();
             // println!("{}: {}", key, value);
         }
 
-        // Fast Init
-        let a: HashSet<i32> = [1, 2, 3].iter().cloned().collect();
-        let b: HashSet<i32> = [4, 2, 3, 4].iter().cloned().collect();
+        // last key less 
+        assert_eq!(map.range(RangeTo{end : 5}).next_back(), Some((&3, &"d".to_owned())));
 
-        // Can be seen as `a - b`.
-        // x typed as &
-        for x in a.difference(&b) {
-            // println!("{}", x); // Print 1
-        }
-
-        let diff: HashSet<i32> = a.difference(&b).cloned().collect();
-        assert_eq!(diff, [1].iter().cloned().collect());
-
-        // Note that difference is not symmetric,
-        // and `b - a` means something else:
-        // no cloned to get a set of reference.
-        let diff: HashSet<&i32> = b.difference(&a).collect();
-        assert_eq!(diff, [4].iter().collect());
-
-        let intersection: HashSet<i32> = a.intersection(&b).cloned().collect();
-        assert_eq!(intersection, [2,3].iter().cloned().collect());
-
-        let union: HashSet<i32> = a.union(&b).cloned().collect();
-        assert_eq!(union, [1,2,3,4].iter().cloned().collect());
-        assert!(!a.is_subset(&b));
-        assert!(!a.is_superset(&b));
+        // last key less or equal to
+        assert_eq!(map.range(RangeToInclusive{end : 5}).next_back(), Some((&5, &"d".to_owned())));
 
+        // first key greater or equal to
+        assert_eq!(map.range(RangeFrom{start : 7}).next(), Some((&8, &"d".to_owned())));
+        assert_eq!(map.range(RangeFrom{start : 8}).next(), Some((&8, &"d".to_owned())));
+        assert_eq!(map.range(RangeFrom{start : 9}).next(), None);
     }
 
     pub fn hashset_misc() {
@@ -1047,6 +1039,35 @@ impl MapUtil {
         // first and last
         assert_eq!(set.iter().next(), Some(&3));
         assert_eq!(set.iter().next_back(), Some(&8));
+
+
+        // Fast Init
+        let a: HashSet<i32> = [1, 2, 3].iter().cloned().collect();
+        let b: HashSet<i32> = [4, 2, 3, 4].iter().cloned().collect();
+
+        // Can be seen as `a - b`.
+        // x typed as &
+        for x in a.difference(&b) {
+            // println!("{}", x); // Print 1
+        }
+
+        let diff: HashSet<i32> = a.difference(&b).cloned().collect();
+        assert_eq!(diff, [1].iter().cloned().collect());
+
+        // Note that difference is not symmetric,
+        // and `b - a` means something else:
+        // no cloned to get a set of reference.
+        let diff: HashSet<&i32> = b.difference(&a).collect();
+        assert_eq!(diff, [4].iter().collect());
+
+        let intersection: HashSet<i32> = a.intersection(&b).cloned().collect();
+        assert_eq!(intersection, [2,3].iter().cloned().collect());
+
+        let union: HashSet<i32> = a.union(&b).cloned().collect();
+        assert_eq!(union, [1,2,3,4].iter().cloned().collect());
+        assert!(!a.is_subset(&b));
+        assert!(!a.is_superset(&b));
+
     }
 }
 struct Util(i32, i32);

src/problem/p0330_patching_array.rs

@@ -0,0 +1,74 @@
+/**
+ * [330] Patching Array
+ *
+ * Given a sorted integer array nums and an integer n, add/patch elements to the array such that any number in the range [1, n] inclusive can be formed by the sum of some elements in the array.
+ * Return the minimum number of patches required.
+ *  
+ * Example 1:
+ * 
+ * Input: nums = [1,3], n = 6
+ * Output: 1
+ * Explanation:
+ * Combinations of nums are [1], [3], [1,3], which form possible sums of: 1, 3, 4.
+ * Now if we add/patch 2 to nums, the combinations are: [1], [2], [3], [1,3], [2,3], [1,2,3].
+ * Possible sums are 1, 2, 3, 4, 5, 6, which now covers the range [1, 6].
+ * So we only need 1 patch.
+ * 
+ * Example 2:
+ * 
+ * Input: nums = [1,5,10], n = 20
+ * Output: 2
+ * Explanation: The two patches can be [2, 4].
+ * 
+ * Example 3:
+ * 
+ * Input: nums = [1,2,2], n = 5
+ * Output: 0
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= nums.length <= 1000
+ * 	1 <= nums[i] <= 10^4
+ * 	nums is sorted in ascending order.
+ * 	1 <= n <= 2^31 - 1
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/patching-array/
+// discuss: https://leetcode.com/problems/patching-array/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn min_patches(nums: Vec<i32>, n: i32) -> i32 {
+        let mut miss_count : i32 = 0;
+        let mut next_miss : i64 = 1;
+        let n = n as i64;
+        let mut i : usize = 0;
+        while next_miss <= n {
+            if i < nums.len() && nums[i] as i64 <= next_miss {
+                next_miss += nums[i] as i64;
+                i+=1;
+            } else {
+                miss_count += 1;
+                next_miss *= 2;
+            }
+        }
+        miss_count
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_330() {
+        assert_eq!(Solution::min_patches(vec![1,3], 6), 1);
+        assert_eq!(Solution::min_patches(vec![1,5,10], 20), 2);
+    }
+}

src/problem/p0335_self_crossing.rs

@@ -0,0 +1,72 @@
+/**
+ * [335] Self Crossing
+ *
+ * You are given an array of integers distance.
+ * You start at point (0,0) on an X-Y plane and you move distance[0] meters to the north, then distance[1] meters to the west, distance[2] meters to the south, distance[3] meters to the east, and so on. In other words, after each move, your direction changes counter-clockwise.
+ * Return true if your path crosses itself, and false if it does not.
+ *  
+ * Example 1:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/selfcross1-plane.jpg" style="width: 400px; height: 435px;" />
+ * Input: distance = [2,1,1,2]
+ * Output: true
+ * 
+ * Example 2:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/selfcross2-plane.jpg" style="width: 400px; height: 435px;" />
+ * Input: distance = [1,2,3,4]
+ * Output: false
+ * 
+ * Example 3:
+ * <img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/selfcross3-plane.jpg" style="width: 400px; height: 435px;" />
+ * Input: distance = [1,1,1,1]
+ * Output: true
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= distance.length <= 500
+ * 	1 <= distance[i] <= 500
+ * 
+ *  
+ * Follow up: Could you write a one-pass algorithm with O(1) extra space?
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/self-crossing/
+// discuss: https://leetcode.com/problems/self-crossing/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn is_self_crossing(d: Vec<i32>) -> bool {
+        for i in (0..d.len()) {
+            if 3 <= i && d[i-2] <= d[i] && d[i-1] <= d[i-3] {
+                return true;
+            }
+
+            if 4 <= i && d[i-1] == d[i-3] && d[i] + d[i-4] >= d[i-2] {
+                return true;
+            }
+
+            if 5 <= i && d[i-2] > d[i-4] && d[i-4]+d[i]>=d[i-2] && d[i-3]>d[i-1] && d[i-5]+d[i-1]>=d[i-3]{
+                return true;
+            }
+
+        }
+        false
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_335() {
+        assert!(Solution::is_self_crossing(vec![2,1,1,2]));
+        assert!(!Solution::is_self_crossing(vec![1,2,3,4]));
+        assert!(Solution::is_self_crossing(vec![1,1,1,1]));
+    }
+}