add 152;162;173;179;213;463;654;792

Author: leopsidom

152.maximum-product-subarray.rs

@@ -0,0 +1,32 @@
+/*
+ * @lc app=leetcode id=152 lang=rust
+ *
+ * [152] Maximum Product Subarray
+ */
+
+// @lc code=start
+use std::cmp;
+use std::mem;
+
+impl Solution {
+    pub fn max_product(nums: Vec<i32>) -> i32 {
+        let mut imax = nums[0];
+        let mut imin = nums[0];
+        
+        let mut ans = nums[0];
+
+        for i in 1..nums.len() {
+            if nums[i] < 0 {
+                mem::swap(&mut imax, &mut imin);
+            }
+            imax = cmp::max(nums[i], imax * nums[i]);
+            imin = cmp::min(nums[i], imin * nums[i]);
+
+            ans = cmp::max(ans, imax);
+        }
+
+        ans
+    }
+}
+// @lc code=end
+

162.find-peak-element.rs

@@ -0,0 +1,14 @@
+/*
+ * @lc app=leetcode id=162 lang=rust
+ *
+ * [162] Find Peak Element
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn find_peak_element(nums: Vec<i32>) -> i32 {
+        
+    }
+}
+// @lc code=end
+

173.binary-search-tree-iterator.rs

@@ -0,0 +1,79 @@
+/*
+ * @lc app=leetcode id=173 lang=rust
+ *
+ * [173] Binary Search Tree Iterator
+ */
+
+// @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;
+
+struct BSTIterator {
+    stack: Vec<Option<Rc<RefCell<TreeNode>>>>
+}
+
+
+/** 
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl BSTIterator {
+
+    fn new(mut root: Option<Rc<RefCell<TreeNode>>>) -> Self {
+        let mut stack = vec![];
+
+        while let Some(node) = root.clone() {
+            stack.push(root.clone());
+            root = node.borrow().left.clone();
+        }
+
+        BSTIterator { stack }
+    }
+    
+    /** @return the next smallest number */
+    fn next(&mut self) -> i32 {
+        let mut root = self.stack.pop().unwrap();
+        let node = root.unwrap();
+        let ans = node.borrow().val;
+        root = node.borrow().right.clone();
+
+        while let Some(node) = root.clone() {
+            self.stack.push(root.clone());
+            root = node.borrow().left.clone();
+        }
+
+        ans
+    }
+    
+    /** @return whether we have a next smallest number */
+    fn has_next(&self) -> bool {
+        self.stack.len() > 0
+    }
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * let obj = BSTIterator::new(root);
+ * let ret_1: i32 = obj.next();
+ * let ret_2: bool = obj.has_next();
+ */
+// @lc code=end
+

179.largest-number.rs

@@ -0,0 +1,72 @@
+/*
+ * @lc app=leetcode id=179 lang=rust
+ *
+ * [179] Largest Number
+ */
+
+// @lc code=start
+use std::cmp;
+use std::mem;
+use std::char;
+
+impl Solution {
+    pub fn largest_number(nums: Vec<i32>) -> String {
+        let mut num_str = vec![];
+        
+        for mut num in nums {
+            let mut v_num = vec![];
+
+            if num == 0 {
+                v_num.push(0);
+            } else {
+                while num > 0 {
+                    v_num.push(num % 10);
+                    num /= 10;
+                }
+            }
+            v_num.reverse();
+
+            num_str.push(v_num);
+        }
+
+        fn compare<'a>(a: &'a [i32], b: &'a [i32]) -> cmp::Ordering {
+            let na = a.len();
+            let nb = b.len();
+
+            let n = cmp::min(na, nb);
+
+            for i in 0..n {
+                if a[i] < b[i] {
+                    return cmp::Ordering::Greater;
+                } else if a[i] > b[i] {
+                    return cmp::Ordering::Less;
+                }
+            }
+
+            if na == nb {
+                cmp::Ordering::Equal
+            } else if na > nb {
+                compare(&a[n..], &b[..])
+            } else {
+                compare(&a[..], &b[n..])
+            }
+        }
+
+        num_str.sort_by(|a, b| compare(&a[..], &b[..]));
+
+        let mut ans = String::new();
+
+        for v in num_str {
+            for d in v {
+                ans.push(char::from_digit(d as u32, 10).unwrap());
+            }
+        }
+
+        let trim_ans = ans.trim_left_matches('0').to_string();
+
+        if trim_ans.len() > 0 { trim_ans } 
+        else { "0".to_string() }
+    }
+}
+// @lc code=end
+

213.house-robber-ii.rs

@@ -0,0 +1,14 @@
+/*
+ * @lc app=leetcode id=213 lang=rust
+ *
+ * [213] House Robber II
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn rob(nums: Vec<i32>) -> i32 {
+        
+    }
+}
+// @lc code=end
+

463.island-perimeter.rs

@@ -0,0 +1,74 @@
+/*
+ * @lc app=leetcode id=463 lang=rust
+ *
+ * [463] Island Perimeter
+ */
+
+// @lc code=start
+use std::collections::HashSet;
+
+impl Solution {
+    pub fn island_perimeter(grid: Vec<Vec<i32>>) -> i32 {
+        let R = grid.len();
+        if R == 0 { return 0; }
+        let C = grid[0].len();
+        let mut seen = HashSet::new();
+        let mut ans = 0;
+
+        fn dfs(
+            coord: (usize, usize), 
+            seen: &mut HashSet<(usize, usize)>, 
+            R: usize, C: usize, 
+            ans: &mut u32,
+            grid: &Vec<Vec<i32>>
+        ) {
+            seen.insert(coord);
+            // println!("{:?}", coord);
+            // *n_nodes += 1;
+            let (x, y) = coord;
+
+            let mut neis = vec![];
+            if x > 0 {
+                neis.push((x-1, y));
+            } else { *ans += 1; }
+
+            if x < R - 1 {
+                neis.push((x+1, y));
+            } else { *ans += 1; }
+
+            if y > 0 {
+                neis.push((x, y-1));
+            } else { *ans += 1; }
+
+            if y < C - 1 {
+                neis.push((x, y+1));
+            } else { *ans += 1; }
+
+            for (i, j) in neis {
+                // println!("seen {:?} contains {:?}? {}", seen, (i, j), seen.contains(&(i, j)));
+                if grid[i][j] == 1 {
+                    if !seen.contains(&(i, j)) {
+                        dfs((i, j), seen, R, C, ans, grid);
+                    }
+                } else {
+                    *ans += 1;
+                }
+            }
+        }
+
+        for i in 0..R {
+            for j in 0..C {
+                if grid[i][j] == 1 {
+                    if !seen.contains(&(i, j)) {
+                        dfs((i, j), &mut seen, R, C, &mut ans, &grid);
+                    }
+                }
+            }
+        }
+
+        // println!("{}, {}", n_nodes, n_edges);
+        ans as i32
+    }
+}
+// @lc code=end
+

654.maximum-binary-tree.rs

@@ -0,0 +1,51 @@
+/*
+ * @lc app=leetcode id=654 lang=rust
+ *
+ * [654] Maximum Binary 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 construct_maximum_binary_tree(nums: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
+        fn helper(nums: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
+            if nums.len() == 0 { return None; }
+
+            let mut maxidx = 0;
+            for i in 0..nums.len() {
+                if nums[i] > nums[maxidx] {
+                    maxidx = i;
+                }
+            }
+
+            let mut tree_node = TreeNode::new(nums[maxidx]);
+            tree_node.left = helper(&nums[..maxidx]);
+            tree_node.right = helper(&nums[maxidx+1..]);
+
+            Some(Rc::new(RefCell::new(tree_node)))
+        }
+
+        helper(&nums[..])
+    }
+}
+// @lc code=end
+

792.number-of-matching-subsequences.rs

@@ -0,0 +1,38 @@
+/*
+ * @lc app=leetcode id=792 lang=rust
+ *
+ * [792] Number of Matching Subsequences
+ */
+
+// @lc code=start
+impl Solution {
+    pub fn num_matching_subseq(s: String, words: Vec<String>) -> i32 {
+        fn is_subseq(word1: &str, word2: &str) -> bool {
+            let mut iter1 = word1.chars();
+            let mut iter2 = word2.chars();
+
+            while let Some(ch1) = iter1.next() {
+                loop { 
+                    if let Some(ch2) = iter2.next() {
+                        if ch1 == ch2 { break; }
+                    } else {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        let mut ans = 0;
+        for word2 in words {
+            if is_subseq(&word2, &s) {
+                ans += 1;
+            }
+        }
+
+        ans
+    }
+}
+// @lc code=end
+