Added tasks 84-153

Author: javadev

README.md

@@ -0,0 +1,145 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 79\. Word Search
+
+Medium
+
+Given an `m x n` grid of characters `board` and a string `word`, return `true` _if_ `word` _exists in the grid_.
+
+The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/word2.jpg)
+
+**Input:** board = \[\["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
+
+**Output:** true
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/word-1.jpg)
+
+**Input:** board = \[\["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
+
+**Output:** true
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2020/10/15/word3.jpg)
+
+**Input:** board = \[\["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
+
+**Output:** false
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n = board[i].length`
+*   `1 <= m, n <= 6`
+*   `1 <= word.length <= 15`
+*   `board` and `word` consists of only lowercase and uppercase English letters.
+
+**Follow up:** Could you use search pruning to make your solution faster with a larger `board`?
+
+## Solution
+
+```rust
+impl Solution {
+    pub fn exist(mut board: Vec<Vec<char>>, word: String) -> bool {
+        let mut word = Vec::from_iter(word.chars());
+        let mut map = [0; 58]; //A-65 z-122
+        for i in 0..board.len() {
+            for j in 0..board[0].len() {
+                map[(board[i][j] as u8 - 65) as usize] += 1;
+            }
+        }
+
+        for c in &word {
+            if map[(*c as u8 - 65) as usize] == 0 {
+                return false;
+            }
+        }
+
+        if map[(word[0] as u8 - 65) as usize] > map[(word[word.len() - 1] as u8 - 65) as usize] {
+            word.reverse();
+        }
+
+        for i in 0..board.len() {
+            for j in 0..board[0].len() {
+                if board[i][j] != word[0] {
+                    continue;
+                }
+                let mut p = 0;
+                let (mut k, mut l) = (i, j);
+                let mut dir = vec![-1; word.len() - 1];
+                loop {
+                    if p == word.len() - 1 {
+                        return true;
+                    }
+                    if dir[p] == -1 {
+                        board[k][l] = ' ';
+                        dir[p] = 0;
+                        if k > 0 && board[k - 1][l] == word[p + 1] {
+                            p += 1;
+                            k -= 1;
+                            continue;
+                        }
+                    }
+                    if dir[p] == 0 {
+                        dir[p] = 1;
+                        if l < board[k].len() - 1 && board[k][l + 1] == word[p + 1] {
+                            p += 1;
+                            l += 1;
+                            continue;
+                        }
+                    }
+                    if dir[p] == 1 {
+                        dir[p] = 2;
+                        if k < board.len() - 1 && board[k + 1][l] == word[p + 1] {
+                            p += 1;
+                            k += 1;
+                            continue;
+                        }
+                    }
+                    if dir[p] == 2 {
+                        dir[p] = 3;
+                        if l > 0 && board[k][l - 1] == word[p + 1] {
+                            p += 1;
+                            l -= 1;
+                            continue;
+                        }
+                    }
+                    while p > 0 && dir[p] == 3 {
+                        board[k][l] = word[p];
+                        dir[p] = -1;
+                        p -= 1;
+                        if dir[p] == 0 {
+                            k += 1;
+                            continue;
+                        }
+                        if dir[p] == 1 {
+                            l -= 1;
+                            continue;
+                        }
+                        if dir[p] == 2 {
+                            k -= 1;
+                            continue;
+                        }
+                        if dir[p] == 3 {
+                            l += 1;
+                            continue;
+                        }
+                    }
+                    if p == 0 && dir[p] == 3 {
+                        board[k][l] = word[p];
+                        break;
+                    }
+                }
+            }
+        }
+        false
+    }
+}
+```

src/main/rust/g0001_0100/s0079_word_search/readme.md

@@ -0,0 +1,96 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 84\. Largest Rectangle in Histogram
+
+Hard
+
+Given an array of integers `heights` representing the histogram's bar height where the width of each bar is `1`, return _the area of the largest rectangle in the histogram_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/histogram.jpg)
+
+**Input:** heights = [2,1,5,6,2,3]
+
+**Output:** 10
+
+**Explanation:** The above is a histogram where width of each bar is 1. 
+
+The largest rectangle is shown in the red area, which has an area = 10 units.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/histogram-1.jpg)
+
+**Input:** heights = [2,4]
+
+**Output:** 4
+
+**Constraints:**
+
+*   <code>1 <= heights.length <= 10<sup>5</sup></code>
+*   <code>0 <= heights[i] <= 10<sup>4</sup></code>
+
+## Solution
+
+```rust
+impl Solution {
+    pub fn largest_rectangle_area(heights: Vec<i32>) -> i32 {
+        Self::largest_area(&heights, 0, heights.len())
+    }
+
+    fn largest_area(heights: &[i32], start: usize, limit: usize) -> i32 {
+        if heights.is_empty() || start == limit {
+            return 0;
+        }
+        if limit - start == 1 {
+            return heights[start];
+        }
+        if limit - start == 2 {
+            let max_of_two_bars = heights[start].max(heights[start + 1]);
+            let area_from_two = heights[start].min(heights[start + 1]) * 2;
+            return max_of_two_bars.max(area_from_two);
+        }
+        if Self::check_if_sorted(heights, start, limit) {
+            let mut max_when_sorted = 0;
+            for i in start..limit {
+                max_when_sorted = max_when_sorted.max(heights[i] * (limit - i) as i32);
+            }
+            return max_when_sorted;
+        } else {
+            let min_ind = Self::find_min_in_array(heights, start, limit);
+            return Self::max_of_three_nums(
+                Self::largest_area(heights, start, min_ind),
+                heights[min_ind] * (limit - start) as i32,
+                Self::largest_area(heights, min_ind + 1, limit),
+            );
+        }
+    }
+
+    fn find_min_in_array(heights: &[i32], start: usize, limit: usize) -> usize {
+        let mut min = i32::MAX;
+        let mut min_index = 0;
+        for i in start..limit {
+            if heights[i] < min {
+                min = heights[i];
+                min_index = i;
+            }
+        }
+        min_index
+    }
+
+    fn check_if_sorted(heights: &[i32], start: usize, limit: usize) -> bool {
+        for i in start + 1..limit {
+            if heights[i] < heights[i - 1] {
+                return false;
+            }
+        }
+        true
+    }
+
+    fn max_of_three_nums(a: i32, b: i32, c: i32) -> i32 {
+        a.max(b).max(c)
+    }
+}
+```

src/main/rust/g0001_0100/s0084_largest_rectangle_in_histogram/readme.md

@@ -0,0 +1,87 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 94\. Binary Tree Inorder Traversal
+
+Easy
+
+Given the `root` of a binary tree, return _the inorder traversal of its nodes' values_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg)
+
+**Input:** root = [1,null,2,3]
+
+**Output:** [1,3,2] 
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Example 3:**
+
+**Input:** root = [1]
+
+**Output:** [1] 
+
+**Example 4:**
+
+![](https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg)
+
+**Input:** root = [1,2]
+
+**Output:** [2,1] 
+
+**Example 5:**
+
+![](https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg)
+
+**Input:** root = [1,null,2]
+
+**Output:** [1,2] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`
+
+**Follow up:** Recursive solution is trivial, could you do it iteratively?
+
+## Solution
+
+```rust
+// Definition for a binary tree node.
+// 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 inorder_traversal(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+       root.map(|root| {
+                let n = root.borrow();
+                let mut result = Self::inorder_traversal(n.left.clone());
+                result.push(n.val);
+                result.extend(Self::inorder_traversal(n.right.clone()));
+                result
+            })
+            .unwrap_or_default() 
+    }
+}
+```

src/main/rust/g0001_0100/s0094_binary_tree_inorder_traversal/readme.md

@@ -0,0 +1,42 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 96\. Unique Binary Search Trees
+
+Medium
+
+Given an integer `n`, return _the number of structurally unique **BST'**s (binary search trees) which has exactly_ `n` _nodes of unique values from_ `1` _to_ `n`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg)
+
+**Input:** n = 3
+
+**Output:** 5
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= n <= 19`
+
+## Solution
+
+```rust
+impl Solution {
+    pub fn num_trees(n: i32) -> i32 {
+        let mut result: i64 = 1;
+        for i in 0..n {
+            result *= 2 * (n as i64) - (i as i64);
+            result /= (i + 1) as i64;
+        }
+        result /= (n + 1) as i64;
+        result as i32
+    }
+}
+```