Added tasks 79-221

Author: javadev

README.md

@@ -0,0 +1,92 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/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
+
+```dart
+class Solution {
+  bool backtrace(List<List<String>> board, List<List<bool>> visited,
+      String word, int index, int x, int y) {
+    if (index == word.length) {
+      return true;
+    }
+    if (x < 0 || x >= board.length || y < 0 || y >= board[0].length ||
+        visited[x][y]) {
+      return false;
+    }
+    visited[x][y] = true;
+
+    if (word[index] == board[x][y]) {
+      bool res =
+          backtrace(board, visited, word, index + 1, x, y + 1) ||
+              backtrace(board, visited, word, index + 1, x, y - 1) ||
+              backtrace(board, visited, word, index + 1, x + 1, y) ||
+              backtrace(board, visited, word, index + 1, x - 1, y);
+
+      if (!res) {
+        visited[x][y] = false;
+      }
+      return res;
+    } else {
+      visited[x][y] = false;
+      return false;
+    }
+  }
+
+  bool exist(List<List<String>> board, String word) {
+    List<List<bool>> visited = List.generate(
+        board.length, (_) => List.filled(board[0].length, false));
+
+    for (int i = 0; i < board.length; i++) {
+      for (int j = 0; j < board[0].length; j++) {
+        if (backtrace(board, visited, word, 0, i, j)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+}
+```

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

@@ -0,0 +1,100 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/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
+
+```dart
+class Solution {
+  int largestRectangleArea(List<int> heights) {
+    return largestArea(heights, 0, heights.length);
+  }
+
+  int largestArea(List<int> a, int start, int limit) {
+    if (a.isEmpty) {
+      return 0;
+    }
+    if (start == limit) {
+      return 0;
+    }
+    if (limit - start == 1) {
+      return a[start];
+    }
+    if (limit - start == 2) {
+      int maxOfTwoBars = a[start] > a[start + 1] ? a[start] : a[start + 1];
+      int areaFromTwo = (a[start] < a[start + 1] ? a[start] : a[start + 1]) * 2;
+      return maxOfThreeNums(maxOfTwoBars, areaFromTwo, 0);
+    }
+    if (checkIfSorted(a, start, limit)) {
+      int maxWhenSorted = 0;
+      for (int i = start; i < limit; i++) {
+        if (a[i] * (limit - i) > maxWhenSorted) {
+          maxWhenSorted = a[i] * (limit - i);
+        }
+      }
+      return maxWhenSorted;
+    } else {
+      int minInd = findMinInArray(a, start, limit);
+      return maxOfThreeNums(
+          largestArea(a, start, minInd),
+          a[minInd] * (limit - start),
+          largestArea(a, minInd + 1, limit));
+    }
+  }
+
+  int findMinInArray(List<int> a, int start, int limit) {
+    int min = a[start];
+    int minIndex = start;
+    for (int index = start + 1; index < limit; index++) {
+      if (a[index] < min) {
+        min = a[index];
+        minIndex = index;
+      }
+    }
+    return minIndex;
+  }
+
+  bool checkIfSorted(List<int> a, int start, int limit) {
+    for (int i = start + 1; i < limit; i++) {
+      if (a[i] < a[i - 1]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  int maxOfThreeNums(int a, int b, int c) {
+    return a > b ? (a > c ? a : c) : (b > c ? b : c);
+  }
+}
+```

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

@@ -0,0 +1,110 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/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
+
+```dart
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *   int val;
+ *   TreeNode? left;
+ *   TreeNode? right;
+ *   TreeNode([this.val = 0, this.left, this.right]);
+ * }
+ */
+class Stack<T> {
+  final List<T> _items = [];
+
+  void push(T item) {
+    _items.add(item);
+  }
+
+  T pop() {
+    return _items.removeLast();
+  }
+
+  T peek() {
+    return _items.last;
+  }
+
+  bool get isEmpty {
+    return _items.isEmpty;
+  }
+
+  int get size {
+    return _items.length;
+  }
+}
+
+class Solution {
+
+  List<int> inorderTraversal(TreeNode? root) {
+    final result = List<int>.empty(growable: true);
+    final stack = Stack<TreeNode>();
+
+    while (root != null || !stack.isEmpty) {
+      while (root != null) {
+        stack.push(root);
+        root = root.left;
+      }
+      root = stack.pop();
+
+      result.add(root.val);
+
+      root = root.right;
+    }
+
+    return result;
+  }
+}
+```

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

@@ -0,0 +1,41 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Dart/LeetCode-in-Dart?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart)
+[![](https://img.shields.io/github/forks/LeetCode-in-Dart/LeetCode-in-Dart?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Dart/LeetCode-in-Dart/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
+
+```dart
+class Solution {
+  int numTrees(int n) {
+    int result = 1;
+    for (int i = 0; i < n; i++) {
+      result = result * (2 * n - i) ~/ (i + 1);
+    }
+    result ~/= (n + 1);
+    return result;
+  }
+}
+```