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. 
@@ -45,51 +45,48 @@ The input is two lists: the subroutines called and their arguments. Solution's c
    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\)
+   4. Then we generate a number, r,  in \[0, total\) or better \[1, total\], this number is used to find the largest presum that are smaller or equal to r
    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
+   6. The second way avoid extra random point generation, and the formula is x = x0 + \(r % w\), and y = y0 + \(r / w\) where r is reset to zero-based and rectangle-based by presum\[i\] - r and w is width of rectangle
    7. Time complexity O\(n\)
    8. Space complexity O\(n\)
-2. asd
 
 ### Solution
 
 ```java
 class Solution {
-    private int totalArea;
+    private int total;
     private int[][] rects;
-    private int[] a;
+    private int[] presum;
     private Random rand;
 
     public Solution(int[][] rects) {
-        this.totalArea = 0;
+        this.total = 0;
         this.rects = rects;
-        this.a = new int[rects.length];
+        this.presum = new int[rects.length];
         this.rand = new Random();
         for (int i = 0; i < rects.length; i++) {
-            totalArea += getArea(rects[i]);
-            a[i] = totalArea;
+            total += (rects[i][2] - rects[i][0] + 1) * (rects[i][3] - rects[i][1] + 1) ;
+            presum[i] = total;
         }
     }
-
-    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];
-        int y = rand.nextInt(rects[i][3] - rects[i][1] + 1) + rects[i][1];
-        return new int[] {x, y};
+        int r = rand.nextInt(total) + 1;
+        int i = binarySearch(presum, r);
+        r = presum[i] - r;
+        int w = rects[i][2] - rects[i][0] + 1;
+        int x = rects[i][0] + r % w;
+        int y = rects[i][1] + r / w;
+        return new int[]{x, y};
     }
 
     private int binarySearch(int[] nums, int target) {
         int lo = 0, hi = nums.length - 1;
-        while (lo <= hi) {
+        while (lo < hi) {
             int mi = lo + (hi - lo) / 2;
-            if (nums[mi] == target) return mi;
-            else if (nums[mi] < target) lo = mi + 1;
-            else hi = mi - 1;
+            if (target > nums[mi]) lo = mi + 1;
+            else hi = mi;
         }
         return lo;
     }