add 57;72;76;84;85;97

Author: leopsidom

57.insert-interval.rs

@@ -0,0 +1,49 @@
+/*
+ * @lc app=leetcode id=57 lang=rust
+ *
+ * [57] Insert Interval
+ */
+
+// @lc code=start
+use std::mem;
+use std::cmp;
+
+impl Solution {
+    pub fn insert(mut intervals: Vec<Vec<i32>>, new_interval: Vec<i32>) -> Vec<Vec<i32>> {
+        let N = intervals.len();
+        if N == 0 { return vec![new_interval]; }
+
+        let mut ans = vec![];
+        let mut i = 0;
+
+        while i < N && intervals[i][1] < new_interval[0] {
+            ans.push(mem::replace(&mut intervals[i], vec![]));
+            i += 1;
+        }
+
+        if i < N {
+            let left = cmp::min(intervals[i][0], new_interval[0]);
+            let mut right = new_interval[1];
+
+            while i < N && intervals[i][0] <= new_interval[1] {
+                if intervals[i][1] > right {
+                    right = intervals[i][1];
+                }
+                i += 1;
+            }
+
+            ans.push(vec![left, right]);
+        } else {
+            ans.push(new_interval);
+        }
+
+        while i < N {
+            ans.push(mem::replace(&mut intervals[i], vec![]));
+            i += 1;
+        }
+        
+        ans
+    }
+}
+// @lc code=end
+

72.edit-distance.rs

@@ -0,0 +1,40 @@
+/*
+ * @lc app=leetcode id=72 lang=rust
+ *
+ * [72] Edit Distance
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn min_distance(word1: String, word2: String) -> i32 {
+        let chars1: Vec<char> = word1.chars().collect();
+        let chars2: Vec<char> = word2.chars().collect();
+
+        let N1 = chars1.len();
+        let N2 = chars2.len();
+
+        let mut dp = vec![vec![0; N2+1]; N1+1];
+
+        for i in 0..N1+1 {
+            for j in 0..N2+1 {
+                if i == 0 {
+                    dp[i][j] = j;
+                } else if j == 0 {
+                    dp[i][j] = i;
+                } else if chars1[i-1] == chars2[j-1] {
+                    dp[i][j] = dp[i-1][j-1];
+                } else {
+                    dp[i][j] = *[
+                        dp[i][j-1], 
+                        dp[i-1][j], 
+                        dp[i-1][j-1]
+                    ].iter().min().unwrap() + 1;
+                }
+            }
+        }
+
+        dp[N1][N2] as i32
+    }
+}
+// @lc code=end
+

76.minimum-window-substring.rs

@@ -0,0 +1,62 @@
+/*
+ * @lc app=leetcode id=76 lang=rust
+ *
+ * [76] Minimum Window Substring
+ */
+
+// @lc code=start
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_window(s: String, t: String) -> String {
+        let mut t_cnt: HashMap<char, i32> = HashMap::new();
+        let mut s_cnt: HashMap<char, i32> = HashMap::new();
+
+        let s_chars = s.chars().collect::<Vec<char>>();
+
+        for ch in t.chars() {
+            *t_cnt.entry(ch).or_insert(0) += 1;
+        }
+
+        let mut n = t_cnt.len();
+        let mut left = 0;
+        let mut right = 0;
+        let mut ans = s.clone();
+        let mut has_window = false;
+
+        while right < s_chars.len() {
+
+            let counter = s_cnt.entry(s_chars[right]).or_insert(0);
+            *counter += 1;
+            if counter == t_cnt.get(&s_chars[right]).unwrap_or(&0) {
+                n -= 1;
+            }
+
+            while n == 0 {
+                has_window = true;
+                let ch = s_chars[left];
+
+                let count = s_cnt.get_mut(&ch).unwrap();
+                if t_cnt.contains_key(&ch) && count == t_cnt.get(&ch).unwrap() {
+                    if right - left < ans.len() {
+                        ans = s_chars[left..right+1].iter().collect::<String>();
+                    }
+                    n += 1;
+                }
+                
+                *count -= 1;
+                left += 1;
+            }
+            right += 1;
+        }
+
+        if !has_window {
+            "".to_owned()
+        } else {
+            ans
+        }
+
+    }
+}
+// @lc code=end
+

84.largest-rectangle-in-histogram.rs

@@ -0,0 +1,46 @@
+/*
+ * @lc app=leetcode id=84 lang=rust
+ *
+ * [84] Largest Rectangle in Histogram
+ */
+
+// @lc code=start
+use std::cmp;
+
+impl Solution {
+    pub fn largest_rectangle_area(heights: Vec<i32>) -> i32 {
+        let N = heights.len();
+
+        let mut less_from_left = vec![0; N];
+        let mut less_from_right = vec![0; N];
+
+        for i in 0..N {
+            let mut p = i as i32 - 1;
+
+            while p >= 0 && heights[p as usize] >= heights[i] {
+                p = less_from_left[p as usize];
+            }
+
+            less_from_left[i] = p;
+        }
+
+        for i in (0..N).rev() {
+            let mut p = i as i32 + 1;
+
+            while p < N as i32 && heights[p as usize] >= heights[i] {
+                p = less_from_right[p as usize];
+            }
+
+            less_from_right[i] = p;
+        }
+
+        let mut ans = 0;
+        for i in 0..N {
+            ans = cmp::max(ans, heights[i] * (less_from_right[i] - less_from_left[i] - 1));
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

85.maximal-rectangle.rs

@@ -0,0 +1,69 @@
+/*
+ * @lc app=leetcode id=85 lang=rust
+ *
+ * [85] Maximal Rectangle
+ */
+
+// @lc code=start
+use std::cmp;
+
+impl Solution {
+    pub fn maximal_rectangle(matrix: Vec<Vec<char>>) -> i32 {
+        let R = matrix.len();
+        if R == 0 { return 0; }
+        let C = matrix[0].len();
+
+        let mut cols = vec![0; C+1];
+        let mut ans = 0;
+
+        for i in 0..R {
+            for j in 0..C {
+                if matrix[i][j] == '1' {
+                    cols[j+1] += 1;
+                } else {
+                    cols[j+1] = 0;
+                }
+            }
+
+            ans = cmp::max(ans, Self::largest_rectangle_area(&cols));
+        }
+
+        ans
+    }
+
+    pub fn largest_rectangle_area(heights: &Vec<i32>) -> i32 {
+        let N = heights.len();
+
+        let mut less_from_left = vec![0; N];
+        let mut less_from_right = vec![0; N];
+
+        for i in 0..N {
+            let mut p = i as i32 - 1;
+
+            while p >= 0 && heights[p as usize] >= heights[i] {
+                p = less_from_left[p as usize];
+            }
+
+            less_from_left[i] = p;
+        }
+
+        for i in (0..N).rev() {
+            let mut p = i as i32 + 1;
+
+            while p < N as i32 && heights[p as usize] >= heights[i] {
+                p = less_from_right[p as usize];
+            }
+
+            less_from_right[i] = p;
+        }
+
+        let mut ans = 0;
+        for i in 0..N {
+            ans = cmp::max(ans, heights[i] * (less_from_right[i] - less_from_left[i] - 1));
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

97.interleaving-string.rs

@@ -0,0 +1,45 @@
+/*
+ * @lc app=leetcode id=97 lang=rust
+ *
+ * [97] Interleaving String
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn is_interleave(s1: String, s2: String, s3: String) -> bool {
+        let chars1 = s1.chars().collect::<Vec<char>>();
+        let chars2 = s2.chars().collect::<Vec<char>>();
+        let chars3 = s3.chars().collect::<Vec<char>>();
+
+        let n1 = chars1.len();
+        let n2 = chars2.len();
+        let n3 = chars3.len();
+
+        if n1 + n2 != n3 { return false; }
+
+        let mut dp = vec![vec![false; n2+1]; n1+1];
+
+        for i in 0..n1+1 {
+            for j in 0..n2+1 {
+                if i == 0 {
+                    if j == 0 {
+                        dp[i][j] = true;
+                    } else {
+                        dp[i][j] = dp[i][j-1] && chars2[j-1] == chars3[i+j-1];
+                    }
+                } else {
+                    if j == 0 {
+                        dp[i][j] = dp[i-1][j] && chars1[i-1] == chars3[i+j-1];
+                    } else {
+                        dp[i][j] = (dp[i][j-1] && chars2[j-1] == chars3[i+j-1]) ||
+                            (dp[i-1][j] && chars1[i-1] == chars3[i+j-1]);
+                    }
+                }
+            }
+        }
+
+        dp[n1][n2]
+    }
+}
+// @lc code=end
+

99.recover-binary-search-tree.rs

@@ -0,0 +1,34 @@
+/*
+ * @lc app=leetcode id=99 lang=rust
+ *
+ * [99] Recover Binary Search Tree
+ */
+
+// @lc code=start
+// 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::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn recover_tree(root: &mut Option<Rc<RefCell<TreeNode>>>) {
+        
+    }
+}
+// @lc code=end
+