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:

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.
3. ith rectangle = rects[i] = [x1,y1,x2,y2], where [x1, y1] are the integer coordinates of the bottom-left corner, and [x2, y2] are the integer coordinates of the top-right corner.
4. length and width of each rectangle does not exceed 2000.
5. 1 <= rects.length <= 100
6. pick return a point as an array of integer coordinates [p_x, p_y]
7. pick is called at most 10000 times.

Input: 
["Solution","pick","pick","pick"]
[[[[1,1,5,5]]],[],[],[]]
Output: 
[null,[4,1],[4,1],[3,3]]

Input: 
["Solution","pick","pick","pick","pick","pick"]
[[[[-2,-2,-1,-1],[1,0,3,0]]],[],[],[],[],[]]
Output: 
[null,[-1,-2],[2,0],[-2,-1],[3,0],[-2,-2]]

// Author: Huahua
// Running time: 92 ms
class Solution {
public:
  Solution(vector<vector<int>> rects): rects_(std::move(rects)) {
    sums_ = vector<int>(rects_.size());
    for (int i = 0; i < rects_.size(); ++i) {
      sums_[i] = (rects_[i][2] - rects_[i][0] + 1) * (rects_[i][3] - rects_[i][1] + 1);
      if (i > 0) sums_[i] += sums_[i - 1];
    }
  }

  vector<int> pick() {
    const int s = nextInt(sums_.back()) + 1;
    int index = lower_bound(sums_.begin(), sums_.end(), s) - sums_.begin();
    const auto& rect = rects_[index];
    return {rect[0] + nextInt(rect[2] - rect[0] + 1),
            rect[1] + nextInt(rect[3] - rect[1] + 1)};
  }
    
private:  
  vector<int> sums_;
  vector<vector<int>> rects_;
  
  // Returns a random int in [0, n - 1]
  int nextInt(int n) {
    return rand() / static_cast<double>(RAND_MAX) * n;
  }
};

The post 花花酱 LeetCode 882. Random Point in Non-overlapping Rectangles appeared first on Huahua's Tech Road.

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:

1. 1 <= w.length <= 10000
2. 1 <= w[i] <= 10^5
3. pickIndex will be called at most 10000 times.

Example 1:

Input: 
["Solution","pickIndex"]
[[[1]],[]]
Output: [null,0]

Input: 
["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
[[[1,3]],[],[],[],[],[]]
Output: [null,0,1,1,1,0]

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.

Solution: Binary Search

1. Convert PDF to CDF
2. Uniformly sample a value s in [1, sum(weights)].
3. Use binary search to find first index such that PDF[index] >= s.

Time complexity: Init O(n), query O(logn)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 184 ms
class Solution {
public:
  Solution(vector<int> w) { 
    sums_ = std::move(w);
    for (int i = 1; i < sums_.size(); ++i)
      sums_[i] += sums_[i - 1];
  }

  int pickIndex() {
    int s = rand() / static_cast<double>(RAND_MAX) * sums_.back() + 1;
    return lower_bound(sums_.begin(), sums_.end(), s) - sums_.begin();
    // or
    // int l = 0;
    // int r = sums_.size();
    // while (l < r) {
    //   int m = (r - l) / 2 + l;
    //   if (sums_[m] < s)
    //     l = m + 1;
    //   else
    //     r = m;
    // }
    // return l;
  }
private:  
  vector<int> sums_;
};

Related Problems

• 花花酱 LeetCode 882. Random Point in Non-overlapping Rectangles

The post 花花酱 LeetCode 880. Random Pick with Weight appeared first on Huahua's Tech Road.

https://leetcode.com/problems/random-pick-index/description/

Given an array of integers with possible duplicates, randomly output the index of a given target number. You can assume that the given target number must exist in the array.

Note:
The array size can be very large. Solution that uses too much extra space will not pass the judge.

Example:

int[] nums = new int[] {1,2,3,3,3};
Solution solution = new Solution(nums);

// pick(3) should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning.
solution.pick(3);

// pick(1) should return 0. Since in the array only nums[0] is equal to 1.
solution.pick(1);

Solution: Reservoir sampling

https://en.wikipedia.org/wiki/Reservoir_sampling

Time complexity: O(query * n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 92 ms
class Solution {
public:
  Solution(vector<int> nums) {
    nums_ = std::move(nums);
  }

  int pick(int target) {
    int n = 0;    
    int index = -1;
    for (int i = 0; i < nums_.size(); ++i) {
      if (nums_[i] != target) continue;
      ++n;
      if (rand() % n == 0) index = i;
    }
    return index;
  }
private:
  vector<int> nums_;
};

The post 花花酱 LeetCode 398. Random Pick Index appeared first on Huahua's Tech Road.