Revert "GitBook: [master] 232 pages modified"

This reverts commit 819e306.

Author: just4once

SUMMARY.md

@@ -1,16 +1,16 @@
 # array
 
 * Two sum, k sum
-  * [001-Two Sum]()
-  * [015-3Sum]()
-  * [016-3Sum Closest ]()
-  * [018-4Sum]()
+  * [001-Two Sum](array/001-two-sum.md)
+  * [015-3Sum](array/015-3sum.md)
+  * [016-3Sum Closest ](array/016-3sum-closest.md)
+  * [018-4Sum](array/018-4sum.md)
 * Backtrack
-  * [039-Combination Sum]()
-  * [040-Combination Sum II]()
+  * [039-Combination Sum](array/039-combination-sum.md)
+  * [040-Combination Sum II](array/040-combination-sum-ii.md)
 * Dynamic Programing
-  * [118-Pascal's Triangle]()
-  * [119-Pascal's Triangle II]()
-  * [120-Triangle]()
+  * [118-Pascal's Triangle](array/118-pascals-triangle.md)
+  * [119-Pascal's Triangle II](array/119-pascals-triangle-ii.md)
+  * [120-Triangle](array/120-triangle.md)
 * asdasd
 

leetcode/array-1.md

@@ -0,0 +1,54 @@
+# 001-two-sum
+
+## Question {#question}
+
+[https://leetcode.com/problems/two-sum/description/](https://leetcode.com/problems/two-sum/description/)
+
+Given an array of integers, return **indices** of the two numbers such that they add up to a specific target.
+
+You may assume that each input would have **exactly** one solution, and you may not use the same element twice.
+
+**Example:**
+
+```text
+Given nums = [2, 7, 11, 15], target = 9,
+
+Because nums[0] + nums[1] = 2 + 7 = 9,
+return [0, 1].
+```
+
+## Thought Process {#thought-process}
+
+1. Brute Force
+   1. Use every element as an anchor and search its right element
+   2. The time complexity is O\(n^2\) = \(n - 1\) + \(n - 2\) + ... + 1
+   3. The space complexity is O\(1\)
+2. Optimal \(Hash Map\)
+   1. Leverage the power of hashmap and store the number and its index in the map
+   2. When the map contain target - curNum, we know the search is complete
+   3. The time complexity is O\(n\)
+   4. The space complexity is O\(n\)
+
+## Solution {#solution}
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        if (nums == null) return null;
+        int[] result = new int[2];
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            if (map.containsKey(target - nums[i])) {
+                result[0] = map.get(target - nums[i]);
+                result[1] = i;
+                return result;
+            }
+            map.put(nums[i], i);
+        }
+        return result;
+    }
+}
+```
+
+## Additional {#additional}
+

leetcode/array/001-two-sum.md

@@ -0,0 +1,154 @@
+# 004-median-of-two-sorted-arrays
+
+## Question {#question}
+
+[https://leetcode.com/problems/median-of-two-sorted-arrays/description/](https://leetcode.com/problems/median-of-two-sorted-arrays/description/)
+
+There are two sorted arrays **nums1** and **nums2** of size m and n respectively.
+
+Find the median of the two sorted arrays. The overall run time complexity should be O\(log \(m+n\)\).
+
+**Example 1:**
+
+```text
+nums1 = [1, 3]
+nums2 = [2]
+
+The median is 2.0
+```
+
+**Example 2:**
+
+```text
+nums1 = [1, 2]
+nums2 = [3, 4]
+
+The median is (2 + 3)/2 = 2.5
+```
+
+## Thought Process {#thought-process}
+
+1. Brute Force
+   1. Knowing the length of both array, we can use a counter to count the element until it reach n/2 for odd number or n/2 + 1, and taking average for the second case
+   2. Time complexity will be O\(m+ n\)
+   3. Space complexity will be O\(1\)
+2. Optimal \(Binary Search\) 1. Because the question warrants O\(log\(m+n\)\), binary search is probably the desired approach 2. Looking back at the definition of median of an array, it's located in the middle 3. If we can cut an array into two puts, and call the element immediately left to the cut L, and right to the cut the R, we can find the median easily by average them 1. \[2 3 / 5 7\] -> median = \(3+5\)/2 2. \[2 3 \(4/4\) 5 7\] -> median = \(4 + 4\) / 2 = 4
+   1. The index can be listed as follow
+      1. ```text
+         N        Index of L / R
+         1               0 / 0
+         2               0 / 1
+         3               1 / 1  
+         4               1 / 2      
+         5               2 / 2
+         6               2 / 3
+         7               3 / 3
+         8               3 / 4
+         ```
+
+         The formula is derived as \(L + R\)/2 = \(A\[\(N-1\)/2\] + A\[N/2\]\)/2
+
+      2. For two arrays, we need to add some padding to make the index more consistent
+   2. ```text
+      [6 9 13 18]  ->   [# 6 # 9 # 13 # 18 #]    (N = 4)
+      position index     0 1 2 3 4 5  6 7  8     (N_Position = 9)
+
+      [6 9 11 13 18]->   [# 6 # 9 # 11 # 13 # 18 #]   (N = 5)
+      position index      0 1 2 3 4 5  6 7  8 9 10    (N_Position = 11)
+      ```
+
+      There are always 2N + 1 position and the cut is always at N position
+
+   3. Observe that index\(L\) = \(N - 1\) / 2, and index\(R\) = N / 2
+   4. There are 2N1 + 2N2 + 2 position altogether. Because we made two cuts on two arrays, there should be N1 + N2 on each side
+   5. If we made the cut C2 = K in A2, then the C1 = N1 + N2 - K.
+   6. Then we have two L's and two R's
+      1. ```text
+          [# 1 # 2 # 3 # (4/4) # 5 #]    
+
+          [# 1 / 1 # 1 # 1 #]
+         ```
+      2. ```text
+          L1 = A1[(C1-1)/2]; R1 = A1[C1/2];
+          L2 = A2[(C2-1)/2]; R2 = A2[C2/2];
+         ```
+      3. ```text
+             L1 = A1[(7-1)/2] = A1[3] = 4; R1 = A1[7/2] = A1[3] = 4;
+             L2 = A2[(2-1)/2] = A2[0] = 1; R2 = A1[2/2] = A1[1] = 1;
+         ```
+      4. We need to make sure L1 <= R1 && L1 <= R2 && L2 <= R1 && L2 <= R2
+         1. Since arrays are sorted, we can drop L1 <= R1 and L2 <= R2 conditions, just focus on L1 <= R2 and L2 <= R1
+         2. If L1 > R2, we have too many large elements on left of A1, we need to move C1 to left or C2 to the right
+         3. If L2 > R1, we have too many large elements on left of A2, we need to move C2 to the left
+      5. Because C1 and C2 are mutually determinable, we can just pick one. However, it's much more practical to use the shorter array as the basis, since all cut position on it is possible median. On the longer array, the position too far to the left or right is simply impossible.
+   7. For instance, \[1\], \[2 3 4 5 6 7 8\]. 1. Corner cases are when C2 == 0 and C2 == 2N2, where we can insert a imaginary element A\[-1\] = INT\_MIN and A\[2N2\] = INT\_MAX
+
+## Solution
+
+Specifically address the odd length, return the min of right side, since right side has more elements.
+
+```java
+class Solution {
+    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        int N1 = nums1.length, N2 = nums2.length;
+        // We want to have smaller array as the second input
+        if (N1 < N2) return findMedianSortedArrays(nums2, nums1);
+        // The reason is that if we use pointers on the larger array,
+        // the index of smaller array might be larger than its length.
+        // The indice of smaller array are all potential cut.
+        // @param halfLen store how many element we need to have on each side
+        int lo = 0, hi = N2, halfLen = (N1 + N2) / 2;
+        double L1 = Double.NaN, L2 = Double.NaN, R1 = Double.NaN, R2 = Double.NaN;
+        while (lo <= hi) {
+            // These two variables are the indice of R1 and R2
+            // If the total length is odd, we will have an extra
+            // element on the right.
+            int mid2 = lo + (hi - lo) / 2;
+            int mid1 = halfLen - mid2;
+            L1 = mid1 == 0 ? Integer.MIN_VALUE : nums1[mid1 - 1];
+            L2 = mid2 == 0 ? Integer.MIN_VALUE : nums2[mid2 - 1];
+            R1 = mid1 == N1 ? Integer.MAX_VALUE : nums1[mid1];
+            R2 = mid2 == N2 ? Integer.MAX_VALUE : nums2[mid2];
+            if (L1 > R2) lo++;
+            else if (L2 > R1) hi--;
+            else {
+                if ((N1 + N2) % 2 == 1) return Math.min(R1, R2);
+                else break;
+            }
+        }
+        return (Math.max(L1, L2) + Math.min(R1, R2)) / 2;
+    }
+}
+```
+
+With position padding, the code is slightly simpler.
+
+```java
+class Solution {
+    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        int N1 = nums1.length, N2 = nums2.length;
+        // We want to have smaller array as the second input
+        if (N1 < N2) return findMedianSortedArrays(nums2, nums1);
+        // The reason is that if we use pointers on the larger array,
+        // the index of smaller array might be larger than its length.
+        // The indice of smaller array are all potential cut
+        int lo = 0, hi = 2 * N2;
+        double L1 = Double.NaN, L2 = Double.NaN, R1 = Double.NaN, R2 = Double.NaN;
+        while (lo <= hi) {
+            int mid2 = lo + (hi - lo) / 2;
+            int mid1 = N1 + N2 - mid2;
+            L1 = mid1 == 0 ? Integer.MIN_VALUE : nums1[(mid1 - 1)/2];
+            L2 = mid2 == 0 ? Integer.MIN_VALUE : nums2[(mid2 - 1)/2];
+            R1 = mid1 == 2 * N1 ? Integer.MAX_VALUE : nums1[mid1/2];
+            R2 = mid2 == 2 * N2 ? Integer.MAX_VALUE :nums2[mid2/2];
+            if (L1 > R2) lo = mid2 + 1;
+            else if (L2 > R1) hi = mid2 - 1;
+            else break;
+        }
+        return (Math.max(L1, L2) + Math.min(R1, R2)) / 2;
+    }
+}
+```
+
+## Additional {#additional}
+

leetcode/array/004-median-of-two-sorted-arrays.md

@@ -0,0 +1,47 @@
+# 011-container-with-most-water
+
+## Question {#question}
+
+[https://leetcode.com/problems/container-with-most-water/description/](https://leetcode.com/problems/container-with-most-water/description/)
+
+Given non-negative integers a1,a2, ...,an, where each represents a point at coordinate \(i,ai\).n vertical lines are drawn such that the two endpoints of line i is at \(i,ai\) and \(i, 0\). Find two lines, which together with x-axis forms a container, such that the container contains the most water.
+
+Note: You may not slant the container and n is at least 2.
+
+**Example:**
+
+![](../../.gitbook/assets/011.png)
+
+## Thought Process {#thought-process}
+
+1. Brute Force
+   1. Start with each vertical line as the container's left boundary
+   2. Pick every one of the remaining vertical line as the right boundary
+   3. Volume = \(x2 - x1\) \* min\(y2, y1\)
+   4. Time complexity is O\(n\)
+   5. Space complexity is O\(1\)
+2. Two pointers
+   1. Start with pointer at left and right, this could potentially by our largest container because the widest length
+   2. We compute the volume same way as before
+   3. Because only the larger height will be most useful in getting larger volume, we shrink the side that has lesser height
+   4. Time complexity is O\(n\)
+   5. Space complexity is O\(1\)
+
+## Solution
+
+```java
+class Solution {
+    public int maxArea(int[] height) {
+        int maxArea = 0, l = 0, r = height.length - 1;
+        while (l < r) {
+            maxArea = Math.max(maxArea, Math.min(height[l], height[r]) * (r - l));
+            if (height[l] > height[r]) r--;
+            else l++;
+        }
+        return maxArea;
+    }
+}
+```
+
+## Additional {#additional}
+

leetcode/array/011-container-with-most-water.md

@@ -0,0 +1,74 @@
+# 015-3sum
+
+## Question {#question}
+
+[https://leetcode.com/problems/3sum/description/](https://leetcode.com/problems/3sum/description/)
+
+Given an array S of n integers, are there elements a, b, c in S such that a+b+c= 0? Find all unique triplets in the array which gives the sum of zero.
+
+**Note:**The solution set must not contain duplicate triplets.
+
+**Example:**
+
+```text
+For example, given array S = [-1, 0, 1, 2, -1, -4],
+
+A solution set is:
+[
+  [-1, 0, 1],
+  [-1, -1, 2]
+]
+```
+
+## Thought Process {#thought-process}
+
+1. Brute force
+   1. Triple loop and use set to eliminate the duplicates by sorting the solution
+   2. Time complexity is O\(n^3\)
+   3. Space complexity is O\(1\)
+2. Two Pointers
+   1. Sort the array
+   2. Loop through the elements, if the current element is equal to the last element, we skip it to avoid duplicate solution
+   3. Set the pointer to the next element and the last element of remaining elements
+   4. Time complexity is O\(n^2\)
+   5. Space complexity is O\(1\)
+
+## Solution
+
+```java
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        if(nums == null || nums.length < 3) return result;
+        Arrays.sort(nums);
+        for(int i =0; i< nums.length - 2; i++){
+            if(nums[i] > 0) break;
+            if(i > 0 && nums[i] == nums[i-1]) continue;
+            int lo = i + 1;
+            int hi = nums.length - 1;
+            while(lo < hi){
+                int sum = nums[i] + nums[lo] + nums[hi];
+                if(sum == 0){
+                    List<Integer> sol = new ArrayList<>();
+                    sol.add(nums[i]);
+                    sol.add(nums[lo]);
+                    sol.add(nums[hi]);
+                    result.add(sol);
+                    while(lo < hi && nums[lo] == nums[lo+1]) lo++;
+                    while(lo < hi && nums[hi] == nums[hi-1]) hi--;
+                    lo++;
+             hi--;
+                } else if(sum < 0){
+                    lo++;
+                } else{
+                    hi--;
+                }
+            }
+        }
+        return result;
+    }
+}
+```
+
+## Additional {#additional}
+