最大相交点 n 个圆

简介

在平面直角坐标系中有 n 个圆，求它们的最大相交点数量。

解法

对于每一个圆，我们可以通过将其投影到 x 轴上，得到它在 x 轴上的左右端点。这个过程可以使用勾股定理求出，圆心到 x 轴的距离即为右端点减去左端点的一半。

由此，我们可以将所有圆在 x 轴上的左右端点按从小到大排序，并依次将它们加入线段树中。当新加入一个圆时，在线段树中查找与它重叠的区间，并更新区间端点的最大值。具体来说，可以记录一棵线段树，线段树上每个节点维护一个区间，并记录该区间覆盖深度和左右端点的最大深度。

线段树的遍历从下往上进行，每次将当前节点的覆盖深度更新为左右儿子中的最大值，如果覆盖深度有变化，则更新当前节点的最大深度。这个过程保证了在加入圆之后，线段树上的每个节点都是被 at least one 圆覆盖的，那么相交点的数量就等于线段树上所有被覆盖深度为 n 的节点的最大深度之和。

复杂度分析

时间复杂度 O(nlogn)，其中 n 为圆的数量。排序的时间复杂度为 O(nlogn)，线段树的建立和遍历的时间复杂度均为 O(nlogn)。空间复杂度为 O(nlogn)，即线段树的空间复杂度。

示例代码

class Node:
    def __init__(self, l, r):
        self.cover = 0
        self.max_depth = 0
        self.l = l
        self.r = r
        self.left_child = None
        self.right_child = None


def build_tree(l, r):
    if l == r:
        return Node(l, r)

    mid = (l + r) // 2
    left_child = build_tree(l, mid)
    right_child = build_tree(mid + 1, r)
    node = Node(l, r)
    node.left_child = left_child
    node.right_child = right_child
    return node


def update(node, l, r, depth):
    if l > node.r or r < node.l:  # query range is out of current node's range
        return

    if l <= node.l and r >= node.r:  # current node's range is inside query range
        node.cover += depth
        # update depth if the range is fully covered
        if node.cover > 0:
            node.max_depth = node.r - node.l + 1
        else:
            node.max_depth = node.left_child.max_depth + node.right_child.max_depth
    else:
        mid = (node.l + node.r) // 2
        update(node.left_child, l, r, depth)
        update(node.right_child, l, r, depth)
        # update depth if the range is fully covered
        if node.cover == 0:
            node.max_depth = node.left_child.max_depth + node.right_child.max_depth


def circle_intersection(circles):
    # flatten circles into a 2d list of [center_x, center_y, radius]
    flattened_circles = []
    for circle in circles:
        flattened_circles.append([circle[0], circle[1], circle[2]])

    # project the circles onto x-axis and sort by ascending left endpoint of the projection
    flattened_circles = [[x - r, x + r] for x, _, r in flattened_circles]
    flattened_circles.sort()

    # build the segment tree
    all_left_endpoints = [interval[0] for interval in flattened_circles]
    all_right_endpoints = [interval[1] for interval in flattened_circles]
    root = build_tree(min(all_left_endpoints), max(all_right_endpoints))

    # update segment nodes and keep track of max_depth
    max_depth = 0
    for left, right in flattened_circles:
        left_index = all_left_endpoints.index(left)
        right_index = all_right_endpoints.index(right)
        update(root, left, right, 1)
        max_depth += root.max_depth

    return max_depth

参考资料

• Solution to Circle Intersection
• Solution to CF484D Gargari and Permutations