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

Auto commit by GitBook Editor

Author: just4once

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

@@ -4,7 +4,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. 
@@ -42,14 +42,14 @@ The input is two lists: the subroutines called and their arguments. Solution's c
 ### Thought Process {#thought-process}
 
 1. Binary Search
-   1. Since the rectangles are non-overlapping, we can use each rectangle's area divided by total as probability of being picked
-   2. Unfortunately some rectangles have zero area, therefore we need to use count of points instead
-   3. In the process of counting, we accumulated the count and save it to presum array
-   4. After generating r in the range of \[0, totalCount\), we use it to find out which rectangle is picked through process of binary search through presum array
-
-   1. After locating the rectangle, we can either generate 
-   2. Time complexity O\(n\), where n is number of rectangles
-   3. Space complexity O\(n\)
+   1. To get a random point, we have to locate one rectangle then pick from it
+   2. Initial thought using area fails due to some rectangles have area of 0, we use count of points instead
+   3. As we count through each rectangles, we accumulate the count in presum array and record total counts
+   4. Then we generate a number, r,  in \[0, totalCount\), we perform binary search to locate the rectangle that contains it \(using number in \[1, totalCount\] will keep binary search traditional\)
+   5. After locating the rectangle, we can either generate a point in x plus a point in y or use r generated above to get the final result
+   6. The second way avoid extra random point generation, and the formula is x = x0 + \(r % c\), and y = y0 + \(r / c\) where r is reset to zero-based and rectangle-based by r - presum\[prev\] + 1 and c points count
+   7. Time complexity O\(n\)
+   8. Space complexity O\(n\)
 2. asd
 
 ### Solution
@@ -71,11 +71,11 @@ class Solution {
             a[i] = totalArea;
         }
     }
-    
+
     private int getArea(int[] rect) {
         return (rect[2] - rect[0]) * (rect[3] - rect[1]);
     }
-    
+
     public int[] pick() {
         int i = binarySearch(a, rand.nextInt(totalArea) + 1);
         int x = rand.nextInt(rects[i][2] - rects[i][0] + 1) + rects[i][0];