每秒扩展 1 个单位的 N 个圆中至少有 K 个重叠的最短时间

问题描述

在平面直角坐标系中，有 N 个圆，每个圆以 (x, y) 为圆心，r 为半径。假设每秒钟，这 N 个圆都会向外扩展 1 个单位长度，目标是求出最少多少秒能够使得至少有 K 个圆有相交的部分。

解决方案

该问题可以使用二分答案来求解。二分答案的范围应该是 0 到最终圆的半径之和 R。对于二分出的答案 T，我们可以以每个圆的当前状态，也就是半径为 r + T 的状态，对所有圆进行判断是否存在至少 K 个圆重叠的情况。

为了判断两个圆是否重叠，我们可以计算他们中心之间的距离，并判断两个圆的半径之和是否大于等于该距离。如果大于等于，则两个圆重叠。

代码示例

/**
 * 判断是否存在至少 K 个圆相交的情况
 *
 * @param circles 圆列表
 * @param n 圆个数
 * @param r 扩展的半径
 * @param k 至少需要重叠的圆数
 * @return 存在至少 K 个圆相交的情况，则返回 true，否则返回 false
 */
bool check(Circle *circles, int n, double r, int k)
{
    // 已经扩展出的圆的半径
    double radius[MAXN];
    memset(radius, 0, sizeof(radius));

    int cnt = 0;
    for (int i = 0; i < n; i++) {
        if (radius[i] + r + EPS >= circles[i].r) {
            // 当前圆已经和至少一个圆相交
            cnt++;
            if (cnt >= k) {
                return true;
            }
        }

        // 扩展圆的半径
        radius[i] += r;

        for (int j = i + 1; j < n; j++) {
            double dist = hypot(circles[i].x - circles[j].x, circles[i].y - circles[j].y);
            if (radius[i] + radius[j] + EPS >= dist && radius[j] + dist + EPS >= radius[i] && radius[i] + dist + EPS >= radius[j]) {
                // 两个圆相交
                cnt++;
                if (cnt >= k) {
                    return true;
                }
            }
        }
    }

    return false;
}

/**
 * 每秒钟扩展 1 个单位的 N 个圆中至少有 K 个圆相交的最短时间
 *
 * @param circles 圆列表
 * @param n 圆个数
 * @param k 至少需要重叠的圆数
 * @return 最短的时间，如果不存在则返回 -1
 */
double solve(Circle *circles, int n, int k)
{
    // 二分答案
    double l = 0, r = circles[0].r;
    for (int i = 1; i < n; i++) {
        r += circles[i].r;
    }

    while (r - l > EPS) {
        double mid = (l + r) / 2;

        if (check(circles, n, mid, k)) {
            r = mid;
        } else {
            l = mid;
        }
    }

    if (r < circles[0].r || fabs(r - circles[0].r) < EPS) {
        // 不存在重叠的情况
        return -1;
    } else {
        return r;
    }
}

时间复杂度

时间复杂度为 O(N^2 log R)，其中 N 是圆的个数，R 是最终圆的半径之和。在实际使用中，应该开启 O2 优化以避免超时。