finish 91,92,94,95,96

Author: BaffinLee

001-100/91. Decode Ways.md

@@ -0,0 +1,74 @@
+# 91. Decode Ways
+
+- Difficulty: Medium.
+- Related Topics: String, Dynamic Programming.
+- Similar Questions: Decode Ways II.
+
+## Problem
+
+A message containing letters from ```A-Z``` is being encoded to numbers using the following mapping:
+
+```
+'A' -> 1
+'B' -> 2
+...
+'Z' -> 26
+```
+
+Given a **non-empty** string containing only digits, determine the total number of ways to decode it.
+
+**Example 1:**
+
+```
+Input: "12"
+Output: 2
+Explanation: It could be decoded as "AB" (1 2) or "L" (12).
+```
+
+**Example 2:**
+
+```
+Input: "226"
+Output: 3
+Explanation: It could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var numDecodings = function(s) {
+  var len = s.length;
+  var tmp = 0;
+  var tmp1 = 1;
+  var tmp2 = 0;
+  var num1 = 0;
+  var num2 = 0;
+  
+  if (s === '' || s[0] === '0') return 0;
+  
+  for (var i = 1; i <= len; i++) {
+    num1 = Number(s.substr(i - 1, 1));
+    num2 = Number(s.substr(i - 2, 2));
+    if (num1 !== 0) tmp += tmp1;
+    if (10 <= num2 && num2 <= 26) tmp += tmp2;
+    tmp2 = tmp1;
+    tmp1 = tmp;
+    tmp = 0;
+  }
+  
+  return tmp1;
+};
+```
+
+**Explain:**
+
+每个点可由前面一个点 decode 1 一个数字到达或前面两个点 decode 2 个数字到达。
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

001-100/92. Reverse Linked List II.md

@@ -0,0 +1,84 @@
+# 92. Reverse Linked List II
+
+- Difficulty: Medium.
+- Related Topics: Linked List.
+- Similar Questions: Reverse Linked List.
+
+## Problem
+
+Reverse a linked list from position **m** to **n**. Do it in one-pass.
+
+**Note: **1 ≤ **m** ≤ **n** ≤ length of list.
+
+**Example:**
+
+```
+Input: 1->2->3->4->5->NULL, m = 2, n = 4
+Output: 1->4->3->2->5->NULL
+```
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} m
+ * @param {number} n
+ * @return {ListNode}
+ */
+var reverseBetween = function(head, m, n) {
+  var newHead = new ListNode(0);
+  var now = newHead;
+  var tmp = null;
+  var reverseLast = null;
+  var reverseHead = null;
+  var reverseNow = null;
+  var i = 0;
+  
+  newHead.next = head;
+  
+  while (now) {
+    tmp = now.next;
+    
+    if (i === m - 1) {
+      reverseHead = now;
+    }
+    
+    if (i === m) {
+      reverseLast = now;
+      reverseNow = now;
+    }
+    
+    if (i > m && i <= n) {
+      now.next = reverseNow;
+      reverseNow = now;
+    }
+    
+    if (i === n) {
+      reverseLast.next = tmp;
+      reverseHead.next = reverseNow;
+    }
+    
+    now = tmp;
+    i++;
+  }
+  
+  return newHead.next;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

001-100/94. Binary Tree Inorder Traversal.md

@@ -0,0 +1,103 @@
+# 94. Binary Tree Inorder Traversal
+
+- Difficulty: Medium.
+- Related Topics: Hash Table, Stack, Tree.
+- Similar Questions: Validate Binary Search Tree, Binary Tree Preorder Traversal, Binary Tree Postorder Traversal, Binary Search Tree Iterator, Kth Smallest Element in a BST, Closest Binary Search Tree Value II, Inorder Successor in BST, Minimum Distance Between BST Nodes.
+
+## Problem
+
+Given a binary tree, return the **inorder** traversal of its nodes' values.
+
+**Example:**
+
+```
+Input: [1,null,2,3]
+   1
+    \
+     2
+    /
+   3
+
+Output: [1,3,2]
+```
+
+**Follow up:** Recursive solution is trivial, could you do it iteratively?
+
+## Solution 1
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var inorderTraversal = function(root) {
+  var res = [];
+  helper(root, res);
+  return res;
+};
+
+var helper = function (root, res) {
+  if (!root) return;
+  if (root.left) helper(root.left, res);
+  res.push(root.val);
+  if (root.right) helper(root.right, res);
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).
+
+## Solution 2
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var inorderTraversal = function(root) {
+  var stack = [];
+  var now = root;
+  var res = [];
+  
+  while (now || stack.length) {
+    while (now) {
+      stack.push(now);
+      now = now.left;
+    }
+    now = stack.pop();
+    res.push(now.val);
+    now = now.right;
+  }
+  
+  return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

001-100/95. Unique Binary Search Trees II.md

@@ -0,0 +1,80 @@
+# 95. Unique Binary Search Trees II
+
+- Difficulty: Medium.
+- Related Topics: Dynamic Programming, Tree.
+- Similar Questions: Unique Binary Search Trees, Different Ways to Add Parentheses.
+
+## Problem
+
+Given an integer **n**, generate all structurally unique **BST's** (binary search trees) that store values 1 ... **n**.
+
+**Example:**
+
+```
+Input: 3
+Output:
+[
+  [1,null,3,2],
+  [3,2,null,1],
+  [3,1,null,null,2],
+  [2,1,3],
+  [1,null,2,null,3]
+]
+Explanation:
+The above output corresponds to the 5 unique BST's shown below:
+
+   1         3     3      2      1
+    \       /     /      / \      \
+     3     2     1      1   3      2
+    /     /       \                 \
+   2     1         2                 3
+```
+
+## Solution
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number} n
+ * @return {TreeNode[]}
+ */
+var generateTrees = function(n) {
+  if (n < 1) return [];
+  return generate(1, n);
+};
+
+var generate = function (l, r) {
+  var nodes = [];
+  var node = null;
+  var left = [];
+  var right = [];
+  for (var i = l; i <= r; i++) {
+    left = generate(l, i - 1);
+    right = generate(i + 1, r);
+    for (var j = 0; j < left.length; j++) {
+      for (var k = 0; k < right.length; k++) {
+        node = new TreeNode(i);
+        node.left = left[j];
+        node.right = right[k];
+        nodes.push(node);
+      }
+    }
+  }
+  return nodes.length ? nodes : [null];
+};
+```
+
+**Explain:**
+
+例如：有 `5` 个节点，选取其中 `1` 个作为 `root`，还剩 `4` 个。则左右可分为 `(0, 4), (1, 3), (2, 2), (3, 1), (4, 0)` 等几种情况，左右的分配用递归得到即可。
+
+**Complexity:**
+
+* Time complexity :
+* Space complexity :

001-100/96. Unique Binary Search Trees.md

@@ -0,0 +1,52 @@
+# 96. Unique Binary Search Trees
+
+- Difficulty: Medium.
+- Related Topics: Dynamic Programming, Tree.
+- Similar Questions: Unique Binary Search Trees II.
+
+## Problem
+
+Given **n**, how many structurally unique **BST's** (binary search trees) that store values 1 ... **n**?
+
+**Example:**
+
+```
+Input: 3
+Output: 5
+Explanation:
+Given n = 3, there are a total of 5 unique BST's:
+
+   1         3     3      2      1
+    \       /     /      / \      \
+     3     2     1      1   3      2
+    /     /       \                 \
+   2     1         2                 3
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var numTrees = function(n) {
+  var dp = [1, 1];
+  for (i = 2; i <= n; i++) {
+    dp[i] = 0;
+    for (j = 1; j <= i; j++) {
+      dp[i] += dp[i - j] * dp[j - 1];
+    }
+  }
+  return dp[n];
+};
+```
+
+**Explain:**
+
+例如：有 `3` 个节点，取 `1` 个作为 `root`，还剩 `2` 个。可以左边 `0` 个，右边 `2` 个；左边 `1` 个，右边 `1` 个；左边 `2` 个，右边 `0` 个。即：`F(3) = F(0) * F(2) + F(1) * F(1) + F(2) * F(0)`。其中 `F(0) = F(1) = 1` 。
+
+**Complexity:**
+
+* Time complexity :
+* Space complexity :