GitBook: [master] 52 pages modified

Author: just4once

README.md

@@ -1,7 +1,3 @@
----
-description: This is my notes for doing Leetcode problem.
----
-
 # README
 
 

SUMMARY.md

@@ -259,28 +259,15 @@
     * [328-odd-even-linked-list](leetcode/linked-list/328-odd-even-linked-list.md)
     * [369-plus-one-linked-list](leetcode/linked-list/369-plus-one-linked-list.md)
     * [109-convert-sorted-list-to-binary-search-tree](leetcode/linked-list/109-convert-sorted-list-to-binary-search-tree.md)
-  * [divide-and-conquer](leetcode/divide-and-conquer.md)
-  * [math](leetcode/math-1.md)
-  * [array](leetcode/array-1.md)
-  * [binary-search](leetcode/binary-search-1.md)
-  * [linked-list](leetcode/linked-list-1.md)
-  * [bit-manipulation](leetcode/bit-manipulation.md)
-  * [two-pointers](leetcode/two-pointers-1.md)
   * [bit-manipulation](leetcode/bit-manipulation-1/README.md)
     * [260-single-number-iii](leetcode/bit-manipulation-1/260-single-number-iii.md)
     * [137-single-number-ii](leetcode/bit-manipulation-1/137-single-number-ii.md)
   * [dynamic-programing](leetcode/dynamic-programing/README.md)
     * [174-dungeon-game](leetcode/dynamic-programing/174-dungeon-game.md)
-  * [string](leetcode/string-1.md)
-  * [hash-table](leetcode/hash-table-1.md)
-  * [dynamic-programing](leetcode/dynamic-programing-1.md)
 * [other](other/README.md)
   * [euclidean-algorithm](other/euclidean-algorithm.md)
   * [rabin-karp-rolling-hash](other/rabin-karp-rolling-hash.md)
   * [summation-identities](other/summation-identities.md)
-* [template](template.md)
-* [LeetCode](leetcode-1.md)
-* [other](other-1.md)
 * [template](template-1/README.md)
   * [leetcode](template-1/leetcode.md)
 

leetcode-1.md

@@ -1,2 +1,4 @@
 # leetcode
 
+
+

leetcode/README.md

@@ -32,20 +32,11 @@ The median is (2 + 3)/2 = 2.5
    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
-         ```
+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
 
+   ```text
          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
@@ -55,33 +46,36 @@ The median is (2 + 3)/2 = 2.5
 
       [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
+   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. Observe that index\(L\) = \(N - 1\) / 2, and index\(R\) = N / 2
+   2. There are 2N1 + 2N2 + 2 position altogether. Because we made two cuts on two arrays, there should be N1 + N2 on each side
+   3. If we made the cut C2 = K in A2, then the C1 = N1 + N2 - K.
+   4. Then we have two L's and two R's 1. \`\`\`text \[\# 1 \# 2 \# 3 \# \(4/4\) \# 5 \#\]
 
-          [# 1 / 1 # 1 # 1 #]
-         ```
+      ```text
+      [# 1 / 1 # 1 # 1 #]
+      ```
+
+      ```text
       2. ```text
           L1 = A1[(C1-1)/2]; R1 = A1[C1/2];
           L2 = A2[(C2-1)/2]; R2 = A2[C2/2];
-         ```
-      3. ```text
+      ```
+
+      1. ```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
+      2. 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
+      3. 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.
+
+   5. 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
 

leetcode/array-1.md

@@ -23,14 +23,14 @@ How many possible unique paths are there?
    2. Now for two dimensional array, the ways to get there will be way\[left\] and way\[top\]
    3. Time complexity O\(mn\)
    4. Space complexity O\(mn\)
-2. DP - Optimized Space
-   1. W
+2. DP - Optimized Space 1. W
 
-      e can save the space by using one dimensional array
+   e can save the space by using one dimensional array
+
+   1. We can choose the smaller one to save the space, for now we just stick with columns n
+   2. Time complexity O\(mn\)
+   3. Space complexity O\(n\)
 
-   2. We can choose the smaller one to save the space, for now we just stick with columns n
-   3. Time complexity O\(mn\)
-   4. Space complexity O\(n\)
 3. Math formula
    1. There are total of m + n - 2 steps, m -1 down and n - 1 right
    2. This question is essentially asking how many ways we can get by performing m - 1 down steps out of total m + n - 2 moves

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

@@ -6,7 +6,7 @@
 
 Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.
 
-**Note:**    
+**Note:**  
 You may assume that nums1 has enough space \(size that is greater or equal to m + n\) to hold additional elements from nums2. The number of elements initialized in nums1 and nums2 are m and n respectively.
 
 **Example:**

leetcode/array/062-unique-paths.md

@@ -1,2 +1,4 @@
 # array
 
+
+

leetcode/array/088-merge-sorted-array.md

@@ -6,7 +6,7 @@
 
 Given a binary search tree, write a function kthSmallest to find the kth smallest element in it.
 
-**Note:** 
+**Note:**
 
 You may assume k is always valid, 1 ≤ k ≤ BST's total elements.
 

leetcode/array/README.md

@@ -18,7 +18,7 @@ k = 2
 
 The answer is 2. Because the sum of rectangle \[\[0, 1\], \[-2, 3\]\] is 2 and 2 is the max number no larger than k \(k = 2\).
 
-**Note:** 
+**Note:**
 
 1. The rectangle inside the matrix must have an area > 0.
 2. What if the number of rows is much larger than the number of columns?

leetcode/binary-search-1.md

@@ -6,8 +6,7 @@
 
 Given a list of non-overlapping axis-aligned rectangles rects, write a function pick which randomly and uniformily picks an integer point in the space covered by the rectangles.
 
-**Note:**    
-
+**Note:**
 
 1. An integer point is a point that has integer coordinates. 
 2. A point on the perimeter of a rectangle is included in the space covered by the rectangles. 
@@ -37,7 +36,7 @@ Output:
 [null,[-1,-2],[2,0],[-2,-1],[3,0],[-2,-2]]
 ```
 
-**Explanation of Input Syntax:** 
+**Explanation of Input Syntax:**
 
 The input is two lists: the subroutines called and their arguments. Solution's constructor has one argument, the array of rectangles rects. pick has no arguments. Arguments are always wrapped with a list, even if there aren't any.
 

leetcode/binary-search/230-kth-smallest-element-in-a-bst.md

@@ -6,8 +6,7 @@
 
 Given an array w of positive integers, where w\[i\] describes the weight of index i, write a function pickIndex which randomly picks an index in proportion to its weight.
 
-**Note:**    
-
+**Note:**
 
 1. 1 <= w.length <= 10000
 2. 1 <= w\[i\] <= 10^5
@@ -31,8 +30,7 @@ Input:
 Output: [null,0,1,1,1,0]
 ```
 
-**Explanation of Input Syntax:**    
-
+**Explanation of Input Syntax:**
 
 The input is two lists: the subroutines called and their arguments. Solution's constructor has one argument, the array w. pickIndex has no arguments. Arguments are always wrapped with a list, even if there aren't any.
 

leetcode/binary-search/363-max-sum-of-rectangle-no-larger-than-k.md

@@ -17,8 +17,7 @@ when length is 6, maximum average value is 9.16667.
 Thus return 12.75.
 ```
 
-**Note:**    
-
+**Note:**
 
 1. 1 <= k <= n <= 10,000.
 2. Elements of the given array will be in range \[-10,000, 10,000\].

leetcode/binary-search/497-random-point-in-non-overlapping-rectangles.md

@@ -20,8 +20,7 @@ Input: [1,2,3,4,5], k=4, x=-1
 Output: [1,2,3,4]
 ```
 
-**Note:**    
-
+**Note:**
 
 1. The value k is positive and will always be smaller than the length of the sorted array.
 2. Length of the given array is positive and will not exceed 104

leetcode/binary-search/528-random-pick-with-weight.md

@@ -35,8 +35,7 @@ The Multiplication Table:
 The 6-th smallest number is 6 (1, 2, 2, 3, 4, 6).
 ```
 
-**Note:**    
-
+**Note:**
 
 1. The m and n will be in the range \[1, 30000\].
 2. The k will be in the range \[1, m \* n\]

leetcode/binary-search/644-maximum-average-subarray-ii.md

@@ -24,8 +24,7 @@ Output: -1
 Explanation: 2 does not exist in nums so return -1
 ```
 
-**Note:**    
-
+**Note:**
 
 1. You may assume that all elements in the array are unique.
 2. The value of each element in the array will be in the range \[-9999, 9999\].

leetcode/binary-search/658-find-k-closest-elements.md

@@ -22,7 +22,7 @@ Output: -1
 Explanation: 2 does not exist in nums so return -1
 ```
 
-**Note:** 
+**Note:**
 
 1. You may assume that all elements in nums are unique.
 2. n will be in the range \[1, 10000\].

leetcode/binary-search/668-kth-smallest-number-in-multiplication-table.md

@@ -6,8 +6,7 @@ Given a blacklist B containing unique integers from \[0, N\), write a function t
 
 Optimize it such that it minimizes the call to system’s Math.random\(\).
 
-**Note:**    
-
+**Note:**
 
 1. 1 <= N <= 1000000000
 2. 0 <= B.length < min\(100000, N\)
@@ -49,8 +48,7 @@ Input:
 Output: [null,1,3,1]
 ```
 
-**Explanation of Input Syntax:**    
-
+**Explanation of Input Syntax:**
 
 The input is two lists: the subroutines called and their arguments. Solution's constructor has two arguments, N and the blacklist B. pick has no arguments. Arguments are always wrapped with a list, even if there aren't any.
 

leetcode/binary-search/702-search-in-a-sorted-array-of-unknown-size.md

@@ -17,8 +17,7 @@ Explanation:
 The repeated subarray with maximum length is [3, 2, 1].
 ```
 
-**Note:**    
-
+**Note:**
 
 1. 1 <= len\(A\), len\(B\) <= 1000
 2. 0 <= A\[i\], B\[i\] < 100

leetcode/binary-search/704-binary-search.md

@@ -21,8 +21,7 @@ Here are all the pairs:
 Then the 1st smallest distance pair is (1,1), and its distance is 0.
 ```
 
-**Note:**    
-
+**Note:**
 
 1. 2 <= len\(nums\) <= 10000.
 2. 0 <= nums\[i\] < 1000000.

leetcode/binary-search/710-random-pick-with-blacklist.md

@@ -42,8 +42,7 @@ target = "k"
 Output: "c"
 ```
 
-**Note:**    
-
+**Note:**
 
 1. letters has a length in range \[2, 10000\].
 2. letters consists of lowercase letters, and contains at least 2 unique letters.

leetcode/binary-search/718-maximum-length-of-repeated-subarray.md

@@ -1,2 +1,4 @@
 # binary-search
 
+
+

leetcode/binary-search/719-find-k-th-smallest-pair-distance.md

@@ -1,2 +1,4 @@
 # bit-manipulation
 
+
+

leetcode/binary-search/744-find-smallest-letter-greater-than-target.md

@@ -1,2 +1,4 @@
 # dynamic-programing
 
+
+

leetcode/binary-search/README.md

@@ -1,2 +1,4 @@
 # hash-table
 
+
+