finish 78,79,89,90,93

Author: BaffinLee

001-100/78. Subsets.md

@@ -30,7 +30,29 @@ Output:
 ## Solution
 
 ```javascript
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var subsets = function(nums) {
+  var res = [];
+  helper(nums, res, [], 0);
+  return res;
+};
 
+var helper = function (nums, res, arr, start) {
+  var len = nums.length;
+  
+  res.push(Array.from(arr));
+  
+  if (start === len) return;
+  
+  for (var i = start; i < len; i++) {
+    arr.push(nums[i]);
+    helper(nums, res, arr, i + 1);
+    arr.pop();
+  }
+};
 ```
 
 **Explain:**
@@ -39,5 +61,5 @@ nope.
 
 **Complexity:**
 
-* Time complexity : O(n).
-* Space complexity : O(n).
+* Time complexity :
+* Space complexity :

001-100/79. Word Search.md

@@ -0,0 +1,138 @@
+# 79. Word Search
+
+- Difficulty: Medium.
+- Related Topics: Array, Backtracking.
+- Similar Questions: Word Search II.
+
+## Problem
+
+Given a 2D board and a word, find if the word exists in the grid.
+
+The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.
+
+**Example:**
+
+```
+board =
+[
+  ['A','B','C','E'],
+  ['S','F','C','S'],
+  ['A','D','E','E']
+]
+
+Given word = "ABCCED", return true.
+Given word = "SEE", return true.
+Given word = "ABCB", return false.
+```
+
+## Solution 1
+
+```javascript
+/**
+ * @param {character[][]} board
+ * @param {string} word
+ * @return {boolean}
+ */
+var exist = function(board, word) {
+  var len1 = board.length;
+  var len2 = (board[0] || []).length;
+  var len3 = word.length;
+  var visited = null;
+  
+  if (!len1 || !len2 || !len3) return false;
+  
+  for (var i = 0; i < len1; i++) {
+    for (var j = 0; j < len2; j++) {
+      visited = Array(len1).fill(0).map(_ => Array(len2));
+      if (helper(board, word, i, j, 0, visited)) return true;
+    }
+  }
+  
+  return false;
+};
+
+var helper = function (board, word, m, n, k, visited) {
+  if (k === word.length) return true;
+  if (m < 0 || m >= board.length) return false;
+  if (n < 0 || n >= board[m].length) return false;
+  if (visited[m][n]) return false;
+  if (board[m][n] !== word[k]) return false;
+  
+  var res = false;
+  
+  visited[m][n] = true;
+  
+  res = helper(board, word, m - 1, n, k + 1, visited)
+        || helper(board, word, m + 1, n, k + 1, visited)
+        || helper(board, word, m, n - 1, k + 1, visited)
+        || helper(board, word, m, n + 1, k + 1, visited);
+  
+  if (!res) visited[m][n] = false;
+  
+  return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(3 * n * n * k). `n` 为 `board 字符总数`， `k` 为 `word` 长度。
+* Space complexity : O(n).
+
+## Solution 2
+
+```javascript
+/**
+ * @param {character[][]} board
+ * @param {string} word
+ * @return {boolean}
+ */
+var exist = function(board, word) {
+  var len1 = board.length;
+  var len2 = (board[0] || []).length;
+  var len3 = word.length;
+  
+  if (!len1 || !len2 || !len3) return false;
+  
+  for (var i = 0; i < len1; i++) {
+    for (var j = 0; j < len2; j++) {
+      if (helper(board, word, i, j, 0)) return true;
+    }
+  }
+  
+  return false;
+};
+
+var helper = function (board, word, m, n, k) {
+  if (k === word.length) return true;
+  if (m < 0 || m >= board.length) return false;
+  if (n < 0 || n >= board[m].length) return false;
+  if (board[m][n] !== word[k]) return false;
+  
+  var res = false;
+  var char = board[m][n];
+  
+  board[m][n] = '#';
+  
+  res = helper(board, word, m - 1, n, k + 1)
+        || helper(board, word, m + 1, n, k + 1)
+        || helper(board, word, m, n - 1, k + 1)
+        || helper(board, word, m, n + 1, k + 1);
+  
+  if (!res) board[m][n] = char;
+  
+  return res;
+};
+```
+
+**Explain:**
+
+上一方法的优化，用过的字符不再用 visited 数组存储，直接修改用过的字符为 `#`。
+
+**Complexity:**
+
+* Time complexity : O(3 * n * k). `n` 为 `board 字符总数`， `k` 为 `word` 长度。
+* Space complexity : O(1).

001-100/89. Gray Code.md

@@ -0,0 +1,92 @@
+# 89. Gray Code
+
+- Difficulty: Medium.
+- Related Topics: Backtracking.
+- Similar Questions: 1-bit and 2-bit Characters.
+
+## Problem
+
+The gray code is a binary numeral system where two successive values differ in only one bit.
+
+Given a non-negative integer **n** representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.
+
+For example, given **n** = 2, return ```[0,1,3,2]```. Its gray code sequence is:
+
+```
+00 - 0
+01 - 1
+11 - 3
+10 - 2
+```
+
+**Note:**
+
+For a given **n**, a gray code sequence is not uniquely defined.
+
+For example, ```[0,2,3,1]``` is also a valid gray code sequence according to the above definition.
+
+For now, the judge is able to judge based on one instance of gray code sequence. Sorry about that.
+
+## Solution 1
+
+```javascript
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var grayCode = function(n) {
+  var res = [0];
+  helper(n, res, 0);
+  return res;
+};
+
+var helper = function (n, res, num) {
+  if (num >= n) return;
+  var len = res.length;
+  for (var i = len - 1; i >= 0; i--) {
+    res.push(res[i] + len);
+  }
+  helper(n, res, num + 1);
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(2^n).
+* Space complexity : O(2^n).
+
+## Solution 2
+
+```javascript
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var grayCode = function(n) {
+  var res = [0];
+  var len = 1;
+  
+  for (var i = 0; i < n; i++) {
+    len = res.length;
+    for (var j = len - 1; j >= 0; j--) {
+      res.push(res[j] + len);
+    }
+  }
+  
+  return res;
+};
+
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(2^n).
+* Space complexity : O(2^n).

001-100/90. Subsets II.md

@@ -0,0 +1,62 @@
+# 90. Subsets II
+
+- Difficulty: Medium.
+- Related Topics: Array, Backtracking.
+- Similar Questions: Subsets.
+
+## Problem
+
+Given a collection of integers that might contain duplicates, ****nums****, return all possible subsets (the power set).
+
+**Note:** The solution set must not contain duplicate subsets.
+
+**Example:**
+
+```
+Input: [1,2,2]
+Output:
+[
+  [2],
+  [1],
+  [1,2,2],
+  [2,2],
+  [1,2],
+  []
+]
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var subsetsWithDup = function(nums) {
+  var res = [];
+  nums.sort((a, b) => a - b);
+  helper(nums, 0, res, []);
+  return res;
+};
+
+var helper = function (nums, start, res, now) {
+  res.push(Array.from(now));
+  
+  for (var i = start; i < nums.length; i++) {
+    if (i === start || nums[i] !== nums[i - 1]) {
+      now.push(nums[i]);
+      helper(nums, i + 1, res, now);
+      now.pop();
+    }
+  }
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity :
+* Space complexity :