finish 29,30,31,76,118,155

BaffinLee · BaffinLee · commit 1acf84d89eda · 2018-05-14T21:44:37.000+08:00
diff --git a/001-100/29. Divide Two Integers.md b/001-100/29. Divide Two Integers.md
@@ -35,14 +35,42 @@ Output: -2
 ## Solution
 
 ```javascript
-
+/**
+ * @param {number} dividend
+ * @param {number} divisor
+ * @return {number}
+ */
+var divide = function(dividend, divisor) {
+  var did = Math.abs(dividend);
+  var dis = Math.abs(divisor);
+  var sign = (divisor > 0 && dividend > 0) || (divisor < 0 && dividend < 0);
+  var res = 0;
+  var arr = [dis];
+  
+  if (dividend === 0 || did < dis) return 0;
+  if (divisor === -1 && dividend === -2147483648) return 2147483647;
+  if (dis === 1) return divisor > 0 ? dividend : -dividend;
+
+  while (arr[arr.length - 1] < did) arr.push(arr[arr.length - 1] + arr[arr.length - 1]);
+  
+  for (var i = arr.length - 1; i >= 0; i--) {
+    if (did >= arr[i]) {
+      did -= arr[i];
+      res += i === 0 ? 1 : 2 << (i - 1);
+    }
+  }
+
+  return sign ? res : -res;
+};
 ```
 
 **Explain:**
 
-nope.
+1. 要注意 `-2147483648 / -1` 越界的情况
+2. 核心就是 `dividend -= divisor << i; result += 2 << (i - 1);`
+3. 其它语言有 `long`、`long long` 类型可以保证 `divisor << i` 不越界，但是 js 没有。比如 `2 << 29` 是 `1073741824`，`2 << 30` 就越界了，不会得到预期的结果。我这里是用加法提前计算好 `divisor << i`。
 
 **Complexity:**
 
-* Time complexity : O(n).
-* Space complexity : O(n).
+* Time complexity : O(log(n)).
+* Space complexity : O(log(n)).
diff --git a/001-100/30. Substring with Concatenation of All Words.md b/001-100/30. Substring with Concatenation of All Words.md
@@ -0,0 +1,79 @@
+# 30. Substring with Concatenation of All Words
+
+- Difficulty: Hard.
+- Related Topics: Hash Table, Two Pointers, String.
+- Similar Questions: Minimum Window Substring.
+
+## Problem
+
+You are given a string, **s**, and a list of words, **words**, that are all of the same length. Find all starting indices of substring(s) in **s** that is a concatenation of each word in **words** exactly once and without any intervening characters.
+
+**Example 1:**
+
+```
+Input:
+  s = "barfoothefoobarman",
+  words = ["foo","bar"]
+Output: [0,9]
+Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
+The output order does not matter, returning [9,0] is fine too.
+```
+
+**Example 2:**
+
+```
+Input:
+  s = "wordgoodstudentgoodword",
+  words = ["word","student"]
+Output: []
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @param {string[]} words
+ * @return {number[]}
+ */
+var findSubstring = function(s, words) {
+  var sLen = s.length;
+  var wLen = words.length;
+  var wordLen = (words[0] || '').length;
+  
+  if (!sLen || !wLen || !wordLen) return [];
+  
+  var count = 0;
+  var tmp = '';
+  var map1 = {};
+  var map2 = {};
+  var res = [];
+  
+  for (var i = 0; i < wLen; i++) {
+    map1[words[i]] = (map1[words[i]] || 0) + 1;
+  }
+  
+  out: for (var j = 0; j <= sLen - (wLen * wordLen); j++) {
+    map2 = {};
+    count = 0;
+    while (count < wLen) {
+      tmp = s.substr(j + (count * wordLen), wordLen);
+      if (map1[tmp] === undefined || map1[tmp] === map2[tmp]) continue out;
+      map2[tmp] = (map2[tmp] || 0) + 1;
+      count++;
+    }
+    res.push(j);
+  }
+  
+  return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(m*n).
+* Space complexity : O(m).
diff --git a/001-100/31. Next Permutation.md b/001-100/31. Next Permutation.md
@@ -0,0 +1,70 @@
+# 31. Next Permutation
+
+- Difficulty: Medium.
+- Related Topics: Array.
+- Similar Questions: Permutations, Permutations II, Permutation Sequence, Palindrome Permutation II.
+
+## Problem
+
+Implement **next permutation**, which rearranges numbers into the lexicographically next greater permutation of numbers.
+
+If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).
+
+The replacement must be **in-place** and use only constant extra memory.
+
+Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
+
+```1,2,3``` → ```1,3,2```
+
+```3,2,1``` → ```1,2,3```
+
+```1,1,5``` → ```1,5,1```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var nextPermutation = function(nums) {
+  var len = nums.length;
+  var i = len - 2;
+  var j = len - 1;
+  
+  while (i >= 0 && nums[i] >= nums[i + 1]) i--;
+  
+  if (i >= 0) {
+    while (j > i && nums[j] <= nums[i]) j--;
+    swap(nums, i, j);
+    reverse(nums, i + 1, len - 1);
+  } else {
+    reverse(nums, 0, len - 1);
+  }
+};
+
+var swap = function (arr, from, to) {
+  var tmp = arr[from];
+  arr[from] = arr[to];
+  arr[to] = tmp;
+};
+
+var reverse = function (arr, start, end) {
+  while (start < end) {
+    swap(arr, start, end);
+    start++;
+    end--;
+  }
+};
+```
+
+**Explain:**
+
+1. 从后往前找，直到 `nums[i] < nums[i + 1]`
+2. 找到 `i` 后，从后往前找，直到 `nums[j] > nums[i]`，交换 `nums[i]`、`nums[j]`，然后把 `i` 后的倒置一下
+3. 没找到 `i` 的话，直接倒置一下
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).
diff --git a/001-100/76. Minimum Window Substring.md b/001-100/76. Minimum Window Substring.md
@@ -0,0 +1,87 @@
+# 76. Minimum Window Substring
+
+- Difficulty: Hard.
+- Related Topics: Hash Table, Two Pointers, String.
+- Similar Questions: Substring with Concatenation of All Words, Minimum Size Subarray Sum, Sliding Window Maximum, Permutation in String, Smallest Range, Minimum Window Subsequence.
+
+## Problem
+
+Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).
+
+**Example:**
+
+```
+Input: S = "ADOBECODEBANC", T = "ABC"
+Output: "BANC"
+```
+
+**Note:**
+
+- If there is no such window in S that covers all characters in T, return the empty string ```""```.
+- If there is such window, you are guaranteed that there will always be only one unique minimum window in S.
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {string}
+ */
+var minWindow = function(s, t) {
+  var map = {};
+  var sLen = s.length;
+  var tLen = t.length;
+  var count = tLen;
+  var min = Number.MAX_SAFE_INTEGER;
+  var head = 0;
+  var left = 0;
+  var right = 0;
+
+  if (!sLen || !tLen) return '';
+
+  for (var i = 0; i < tLen; i++) {
+    if (map[t[i]] === undefined) {
+      map[t[i]] = 1
+    } else {
+      map[t[i]]++;
+    }
+  }
+
+  while (right < sLen) {
+    if (map[s[right]] !== undefined) {
+      if (map[s[right]] > 0) count--;
+      map[s[right]]--;
+    }
+    
+    right++;
+    
+    while (count === 0) {
+      if (right - left < min) {
+        min = right - left;
+        head = left;
+      }
+      
+      if (map[s[left]] !== undefined) {
+        if (map[s[left]] === 0) count++;
+        map[s[left]]++;
+      }
+      
+      left++;
+    }
+  }
+  
+  return min === Number.MAX_SAFE_INTEGER ? '' : s.substr(head, min);
+};
+```
+
+**Explain:**
+
+see [Here is a 10-line template that can solve most 'substring' problems](https://leetcode.com/problems/minimum-window-substring/discuss/26808/Here-is-a-10-line-template-that-can-solve-most-'substring'-problems).
+
+用哈希表保存各字符的数量，双指针表示当前窗口，用计数器来判断是否符合条件。符合条件后，记录窗口位置、最小值；更新双指针、计数器。
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).
diff --git a/101-200/118. Pascal's Triangle.md b/101-200/118. Pascal's Triangle.md
@@ -0,0 +1,61 @@
+# 118. Pascal's Triangle
+
+- Difficulty: Easy.
+- Related Topics: Array.
+- Similar Questions: Pascal's Triangle II.
+
+## Problem
+
+Given a non-negative integer **numRows**, generate the first **numRows** of Pascal's triangle.
+
+![](https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif)
+
+In Pascal's triangle, each number is the sum of the two numbers directly above it.
+
+**Example:**
+
+```
+Input: 5
+Output:
+[
+     [1],
+    [1,1],
+   [1,2,1],
+  [1,3,3,1],
+ [1,4,6,4,1]
+]
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number} numRows
+ * @return {number[][]}
+ */
+var generate = function(numRows) {
+  var i = 0;
+  var j = 0;
+  var res = [];
+  for (i = 0; i < numRows; i++) {
+    res.push(Array(i + 1));
+    for (j = 0; j <= i; j++) {
+      if (j === 0 || j === i) {
+        res[i][j] = 1;
+      } else {
+        res[i][j] = res[i - 1][j - 1] + res[i - 1][j];
+      }
+    }
+  }
+  return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n^2).
+* Space complexity : O(n^2).
diff --git a/101-200/155. Min Stack.md b/101-200/155. Min Stack.md
