Leetcode 497. 非重叠矩形中的随机点

题目地址(497. 非重叠矩形中的随机点)

https://leetcode.cn/problems/random-point-in-non-overlapping-rectangles/

题目描述

给定一个由非重叠的轴对齐矩形的数组 rects ，其中 rects[i] = [ai, bi, xi, yi] 表示 (ai, bi) 是第 i 个矩形的左下角点，(xi, yi) 是第 i 个矩形的右上角点。设计一个算法来随机挑选一个被某一矩形覆盖的整数点。矩形周长上的点也算做是被矩形覆盖。所有满足要求的点必须等概率被返回。

在给定的矩形覆盖的空间内的任何整数点都有可能被返回。

请注意 ，整数点是具有整数坐标的点。

实现 Solution 类:

Solution(int[][] rects) 用给定的矩形数组 rects 初始化对象。
int[] pick() 返回一个随机的整数点 [u, v] 在给定的矩形所覆盖的空间内。

 

示例 1：

输入: 
["Solution", "pick", "pick", "pick", "pick", "pick"]
[[[[-2, -2, 1, 1], [2, 2, 4, 6]]], [], [], [], [], []]
输出: 
[null, [1, -2], [1, -1], [-1, -2], [-2, -2], [0, 0]]

解释：
Solution solution = new Solution([[-2, -2, 1, 1], [2, 2, 4, 6]]);
solution.pick(); // 返回 [1, -2]
solution.pick(); // 返回 [1, -1]
solution.pick(); // 返回 [-1, -2]
solution.pick(); // 返回 [-2, -2]
solution.pick(); // 返回 [0, 0]

 

提示：

1 <= rects.length <= 100
rects[i].length == 4
-109 <= ai < xi <= 109
-109 <= bi < yi <= 109
xi - ai <= 2000
yi - bi <= 2000
所有的矩形不重叠。
pick 最多被调用 104 次。

前置知识

• 前缀和+二分查找

思路

设n为矩形个数
直观想法，先在[0, n - 1]下标之间随机取一个矩形，然后再在该矩形中随机去一个点。矩形中随机取点可以在长和宽的范围上随机取一个值，对应出一个二维坐标就是该点。但是先在[0, n - 1]下标之间随机取一个矩形，不满足题目要求的等概率分布；下面是非严谨的数学的证明，因为面积大的矩形和面积的小的矩形概率被取到的概率都是1/n, 那对于大矩形来说平均到各个点的概率就要比小矩形的概率要小，不满足各个点等概率的要求。

因此每个矩形的被选到的概率不应该是1/n,应该按照每个矩形包含点的占比作为权重，这样后续平均到每个点的概率才相同；

因此可以预处理出每个矩形包含多少点，根据概率的几何模型,我们把包含x个点的矩形看作长度为x的线段，那么每个矩形的概率占比可以用下图表示。

根据几何模型，每条线段占总长度的比例就是每个矩形被抽中的概率。我们预处理出前缀和数组，其中 $sum[i]$代表前 $i$个矩形的点数之和（即下标范围$[0,i-1]$的点总和), 这样就与图上一维坐标一一对应。之后可以在 $[1,sum[n]]$ 范围内随机去一个点，看看这个点具体落在那个矩形对应的线段上，当前矩形就是被抽中的矩形。由于前缀$sum$数组的具有单调性，进行二分查找，该随机点落在那个矩形上。之后在该矩形中进行随机，得到最终的随机点。

关键点

• 按照每个矩形的包含点数目的占比作为概率权重进行抽样

代码

• 语言支持：C++, Java

C++ Code:

class Solution {
public:
    vector<vector<int>> rects;  // 备份(用作后续在矩形内查找点的)
    vector<int> sum;   // 前缀和数组
    int n;
    Solution(vector<vector<int>>& _rects) {
        rects = _rects;
        sum.push_back(0);
        n = rects.size();

        for(int i = 0; i < n; i ++)
        {
            int px = rects[i][2] - rects[i][0] + 1;  // 该矩形横坐标包含的点数
            int py = rects[i][3] - rects[i][1] + 1;  // 该举行纵坐标包含的点数
            sum.push_back(sum.back() + px * py);   // 前缀和累加
        }
    }
    
    vector<int> pick() {
        int l = 1, r = n;

        int v = rand() % sum.back() + 1;
        while(l < r)                  // 二分查找出小于等于随机值v的最后一个矩形
        {
            int mid = (l + r) >> 1;
            if(sum[mid] >= v)           r = mid;
            else                        l = mid + 1;
        }
        int idx = --l;

        int x = rects[idx][2] - rects[idx][0] + 1;  // 矩形横坐标的长度
        int y = rects[idx][3] - rects[idx][1] + 1;  // 矩形纵坐标的长度
        int dx = rand() % x;                    // 随机截取一段x
        int dy = rand() % y;                    // 随机截取一段y
        return {rects[idx][0] + dx, rects[idx][1] + dy};
    }
};

Java Code:

class Solution {
    int[][] rects;
    List<Integer> sum = new ArrayList();
    int n;
    public Solution(int[][] _rects) {
        n = _rects.length;
        rects = _rects;
        sum.add(0);

        for(int i = 0; i < n; i ++)
        {
            int px = rects[i][2] - rects[i][0] + 1;
            int py = rects[i][3] - rects[i][1] + 1;
            sum.add(sum.get(sum.size() - 1) + px * py);
        }
    }
    
    public int[] pick() {
        int l = 1, r = n;
        int maxv = sum.get(sum.size() - 1);
        int v = (new Random().nextInt(maxv)) + 1;
        while(l < r)
        {
            int mid = (l + r) >> 1;
            if(sum.get(mid) >= v)           r = mid;
            else                        l = mid + 1;
        }

        int idx = --l;
        int x = rects[idx][2] - rects[idx][0] + 1;
        int y = rects[idx][3] - rects[idx][1] + 1;
        int dx = new Random().nextInt(x);
        int dy = new Random().nextInt(y);
        return new int[] {rects[idx][0] + dx, rects[idx][1] + dy};

    }
}

复杂度分析

令 n 为数组长度。

• 时间复杂度：$O(mlog(n)),m是随机次数$
• 空间复杂度：$O(n)$