可以与单条直线相交的最大可能矩形数

Question

我发现了这个挑战问题，说明如下：

假设在 XY 平面上有 n 个矩形。编写一个程序，计算在该平面上绘制的单条直线所能穿过的矩形的最大可能数量。

我已经头脑风暴了很长时间，但找不到任何解决方案。 也许在某个阶段，我们使用了动态编程步骤，但不知道如何开始。

Answer 1

（编辑我之前考虑旋转飞机的答案。）

这是O(n^2) 算法的草图，它结合了 Gassa 的想法和 Evgeny Kluev 将双线排列作为排序角度序列的参考。

我们从一个双向连接的边列表或类似结构开始，允许我们在O(1) 时间分割一条边，以及一种在填充二维平面时遍历我们创建的面的方法。为简单起见，我们只使用下面矩形十二个角中的三个：

9|     (5,9)___(7,9)
8|         |   |
7|    (4,6)|   |
6|    ___C |   |
5|   |   | |   |
4|   |___| |   |
3|  ___    |___|(7,3)
2| |   |  B (5,3)
1|A|___|(1,1)
 |_ _ _ _ _ _ _ _
   1 2 3 4 5 6 7

我们根据以下变换在对偶平面中插入三个点（角）：

point p => line p* as a*p_x - p_y
line l as ax + b => point l* as (a, -b)

让我们按A, B, C的顺序输入分数。我们先输入A => y = x - 1。由于到目前为止只有一条边，我们插入B => y = 5x - 3，它创建了顶点(1/2, -1/2)并分割了我们的边。 （这个解决方案的一个优雅方面是双平面中的每个顶点（点）实际上是通过矩形角的线的双点。观察1 = 1/2*1 + 1/2 和3 = 1/2*5 + 1/2，点(1,1) 和(5,3) .)

进入最后一点C => y = 4x - 6，我们现在寻找最左边的面（可能是一张不完整的面）相交的地方。这次搜索是O(n) 时间，因为我们必须尝试每张脸。我们找到并创建顶点(-3, -18)，分割5x - 3 的下边缘并向上遍历边缘以在顶点(5/3, 2/3) 处分割x - 1 的右半部分。每次插入都有O(n) 时间，因为我们必须首先找到最左边的面，然后遍历每个面以分割边并标记顶点（线的交点）。

我们现在有双平面：

在构造线排列后，我们开始在三个示例点（矩形角）上进行迭代。重建与一个点相关的排序角度序列的部分魔法是将角度（每个角度对应于双平面中的有序线交点）划分为与右侧点对应的角度（具有更大的 x 坐标）和左边的那些并连接两个序列以获得从-90度到-270度的有序序列。 （右侧的点转换为相对于固定点具有正斜率的线；左侧的点具有负斜率。顺时针旋转您的服务/屏幕，直到(C*) 4x - 6 的线变为水平线，您会看到@ 987654343@ 现在有正斜率，A* 有负斜率。）

为什么有效？如果将原平面中的点p 转换为对偶平面中的线p*，则从左到右遍历该对偶线对应于在同样通过@ 的原始平面中绕p 旋转一条线987654348@。双线通过 x 坐标标记了这条旋转线的所有斜率，从负无穷（垂直）到零（水平）到无穷（再次垂直）。

(让我们总结一下矩形计数逻辑，在迭代角度序列的同时更新当前矩形的count_array：如果是1，则增加当前交叉点计数；如果是4并且线不是直接在一个角上，将其设置为 0 并减少当前的交叉点计数。）

Pick A, lookup A*
=> x - 1.

Obtain the concatenated sequence by traversing the edges in O(n)
=> [(B*) 5x - 3, (C*) 4x - 6] ++ [No points left of A]

Initialise an empty counter array, count_array of length n-1

Initialise a pointer, ptr, to track rectangle corners passed in
the opposite direction of the current vector.

Iterate:
  vertex (1/2, -1/2)
  => line y = 1/2x + 1/2 (AB)

  perform rectangle-count-logic

  if the slope is positive (1/2 is positive):
    while the point at ptr is higher than the line:
      perform rectangle-count-logic

  else if the slope is negative:
    while the point at ptr is lower than the line:
      perform rectangle-count-logic

  => ptr passes through the rest of the points up to the corner
     across from C, so intersection count is unchanged

  vertex (5/3, 2/3)
  => line y = 5/3x - 2/3 (AC)

我们可以看到(5,9) 位于通过AC (y = 5/3x - 2/3) 的线的上方，这意味着此时我们将计算与最右边矩形的交点，但尚未重置它的计数，这条线总共有 3 个矩形。

我们还可以在对偶平面的图中看到，其他角度序列：

for point B => B* => 5x - 3: [No points right of B] ++ [(C*) 4x - 6, (A*) x - 1]

for point C => C* => 4x - 6: [(B*) 5x - 3] ++ [(A*) x - 1]
(note that we start at -90 deg up to -270 deg)

Answer 2

下面的算法怎么样：

RES = 0 // maximum number of intersections
CORNERS[] // all rectangles corners listed as (x, y) points

for A in CORNERS
    for B in CORNERS // optimization: starting from corner next to A
        RES = max(RES, CountIntersectionsWithLine(A.x, A.y, B.x, B.y))

return RES

换句话说，从每个矩形角开始画线到另一个矩形角，并找到最大的交点数。正如@weston 所建议的，我们可以通过从A 旁边的角落开始内循环来避免计算同一行两次。

Answer 3

解决方案

在图中所有线的空间中，经过一个角的线正是那些即将减少数量或交点的线。换句话说，它们各自形成一个局部最大值。

对于每条至少经过一个角的线，存在一条经过两个具有相同交叉点数的角的关联线。

结论是我们只需要检查由两个矩形角形成的线，因为它们形成了一个完全代表我们问题的局部最大值的集合。从那些我们选择交叉点最多的那个。

时间复杂度

此解决方案首先需要恢复通过两个角的所有线。这样的行数是O(n^2)。

然后我们需要计算给定直线和矩形之间的交叉点数。这显然可以通过比较每个矩形在 O(n) 中完成。

可能有更有效的方法来进行，但我们知道这个算法最多O(n^3)。

Python3 实现

这是该算法的 Python 实现。我更注重可读性而不是效率，但它完全符合上述定义。

def get_best_line(rectangles):
    """
    Given a set of rectangles, return a line which intersects the most rectangles.
    """

    # Recover all corners from all rectangles
    corners = set()
    for rectangle in rectangles:
        corners |= set(rectangle.corners)

    corners = list(corners)

    # Recover all lines passing by two corners
    lines = get_all_lines(corners)

    # Return the one which has the highest number of intersections with rectangles
    return max(
        ((line, count_intersections(rectangles, line)) for line in lines),
        key=lambda x: x[1])

此实现使用以下帮助程序。

def get_all_lines(points):
    """
    Return a generator providing all lines generated
    by a combination of two points out of 'points'
    """
    for i in range(len(points)):
        for j in range(i, len(points)):
            yield Line(points[i], points[j])

def count_intersections(rectangles, line):
    """
    Return the number of intersections with rectangles
    """
    count = 0

    for rectangle in rectangles:
        if line in rectangle:
           count += 1

    return count

这里是用作矩形和线条数据结构的类定义。

import itertools
from decimal import Decimal

class Rectangle:
    def __init__(self, x_range, y_range):
        """
        a rectangle is defined as a range in x and a range in y.
        By example, the rectangle (0, 0), (0, 1), (1, 0), (1, 1) is given by
        Rectangle((0, 1), (0, 1))
        """
        self.x_range = sorted(x_range)
        self.y_range = sorted(y_range)

    def __contains__(self, line):
        """
        Return whether 'line' intersects the rectangle.
        To do so we check if the line intersects one of the diagonals of the rectangle
        """
        c1, c2, c3, c4 = self.corners

        x1 = line.intersect(Line(c1, c4))
        x2 = line.intersect(Line(c2, c3))

        if x1 is True or x2 is True \
                or x1 is not None and self.x_range[0] <= x1 <= self.x_range[1] \
                or x2 is not None and self.x_range[0] <= x2 <= self.x_range[1]:

            return True

        else:
            return False

    @property
    def corners(self):
        """Return the corners of the rectangle sorted in dictionary order"""
        return sorted(itertools.product(self.x_range, self.y_range))


class Line:
    def __init__(self, point1, point2):
        """A line is defined by two points in the graph"""
        x1, y1 = Decimal(point1[0]), Decimal(point1[1])
        x2, y2 = Decimal(point2[0]), Decimal(point2[1])
        self.point1 = (x1, y1)
        self.point2 = (x2, y2)

    def __str__(self):
        """Allows to print the equation of the line"""
        if self.slope == float('inf'):
            return "y = {}".format(self.point1[0])

        else:
            return "y = {} * x + {}".format(round(self.slope, 2), round(self.origin, 2))

    @property
    def slope(self):
        """Return the slope of the line, returning inf if it is a vertical line"""
        x1, y1, x2, y2 = *self.point1, *self.point2

        return (y2 - y1) / (x2 - x1) if x1 != x2 else float('inf')

    @property
    def origin(self):
        """Return the origin of the line, returning None if it is a vertical line"""
        x, y = self.point1

        return y - x * self.slope if self.slope != float('inf') else None

    def intersect(self, other):
        """
        Checks if two lines intersect.
        Case where they intersect: return the x coordinate of the intersection
        Case where they do not intersect: return None
        Case where they are superposed: return True
        """

        if self.slope == other.slope:

            if self.origin != other.origin:
                return None

            else:
                return True

        elif self.slope == float('inf'):
            return self.point1[0]

        elif other.slope == float('inf'):
            return other.point1[0]

        elif self.slope == 0:
            return other.slope * self.origin + other.origin

        elif other.slope == 0:
            return self.slope * other.origin + self.origin

        else:
            return (other.origin - self.origin) / (self.slope - other.slope)

示例

这是上述代码的一个工作示例。

rectangles = [
    Rectangle([0.5, 1], [0, 1]),
    Rectangle([0, 1], [1, 2]),
    Rectangle([0, 1], [2, 3]),
    Rectangle([2, 4], [2, 3]),
]

# Which represents the following rectangles (not quite to scale)
#
#  *
#  *   
#
# **     **
# **     **
#
# **
# **

我们可以清楚地看到，一个最优解应该找到一条经过三个矩形的直线，而这确实是它输出的内容。

print('{} with {} intersections'.format(*get_best_line(rectangles)))
# prints: y = 0.50 * x + -5.00 with 3 intersections

Answer 4

如果考虑角度为 Θ 的旋转线，并且将所有矩形投影到这条线上，则得到 N 条线段。通过增加横坐标并对端点进行排序并保持从左到右遇到的间隔计数（跟踪端点是开始还是结束），很容易获得与这条线垂直的矩形的最大数量。这以绿色显示。

现在两个矩形被所有线以两个内切线之间的角度相交[红色示例]，因此要考虑所有“事件”角度（即可以观察到计数变化的所有角度) 是这些 N(N-1) 个角度。

那么暴力破解方案就是

• 对于所有的极限角（O(N²)），

  • 将矩形投影到旋转线上（O(N) 次操作），

  • 计算重叠并保留最大的（O(N Log N) 进行排序，然后 O(N) 进行计数）。

这总共需要 O(N³Log N) 次操作。

假设如果我们可以增量地进行排序，则不需要对每个角度都重新进行全部排序，我们可以希望将复杂度降低到 O(N³)。这需要检查。

---

注意：

限制线条通过一个矩形角的解决方案是错误的。如果你从一个矩形的四个角到另一个矩形的整个范围绘制楔形，即使有一条穿过它们三个的线，也会有空白空间可以放置一个不会被触及的整个矩形。

Answer 5

我们可以有一个 O(n^2 (log n + m)) 动态规划方法，通过调整 Andriy Berestovskyy 的想法，即稍微迭代角以将当前角与所有其他矩形的关系插入到每个 @987654324 的间隔树中@ 迭代周期。

将为我们正在尝试的角落创建一棵新树。对于每个矩形的四个角，我们将遍历其他每个矩形。我们将插入的是标记成对矩形的最远角相对于当前固定角创建的弧的角度。

在下面的示例中，对于固定的下矩形的角R，在插入中间矩形的记录时，我们将插入标记从p2 到p1 与R 相关的弧的角度（关于(37 deg, 58 deg))。然后当我们检查与R相关的高矩形时，我们将插入标记弧的角度区间，从p4到p3与R相关（大约(50 deg, 62 deg)）。

当我们插入下一条弧线记录时，我们将对照所有相交区间对其进行检查，并保留最多相交的记录。

（请注意，由于我们的目的是 360 度圆上的任何弧都有对应的旋转 180 度，因此我们可能需要进行任意截断（欢迎任何替代见解）。例如，这意味着来自45 度到 315 度会分成两部分：[0, 45] 和 [135, 180]。任何非分割弧只能与其中一个相交，但无论哪种方式，我们都可能需要一个额外的哈希来确保矩形是没有重复计算。）

Answer 6

这是一个 O(n^2 log n) 解决方案的草图。

首先，预赛与其他答案共享。 当我们有一条线穿过一些矩形时，我们可以将它平移到任何两侧，直到它穿过某个矩形的一个角。 之后，我们将该角固定为旋转中心，并将线旋转到两侧中的任何一个，直到它穿过另一个角。 在整个过程中，我们的直线和矩形边之间的所有交点都在这些边上，所以交叉点的数量保持不变，直线穿过的矩形数量也是如此。 因此，我们可以只考虑通过两个矩形角的线，其上限为 O(n^2)，与任意线的无限空间相比，这是一个值得欢迎的改进。

那么，我们如何有效地检查所有这些行？ 首先，让我们有一个外循环，它固定一个点 A，然后考虑所有通过 A 的线。 A有O(n)个选择。

现在，我们已经固定了一个点 A，并且想要考虑所有通过所有其他角 B 的线 AB。 为了做到这一点，首先根据 AB 的极角，或者换句话说，轴 Ox 和向量 AB 之间的角度对所有其他角 B 进行排序。 角度是从 -PI 到 +PI 或从 0 到 2 PI 或以其他方式测量的，我们切割圆以对角度进行排序的点可以是任意的。 排序在 O(n log n) 内完成。

现在，我们有点 B₁, B₂, ..., B_k 按 A 点周围的极角排序 (它们的数字 k 类似于 4n-4，所有矩形的所有角，除了点 A 是角的那个）。 首先，查看线 AB₁ 并计算该线在 O(n) 中穿过的矩形数量。 之后，考虑将 AB₁ 旋转到 AB₂，然后 AB₂ 到 AB₃，一直到AB_k。 轮换期间发生的事件如下：

• 当我们旋转到 AB_i，并且 B_i 是我们顺序中某个矩形的第一个角时，交叉的矩形数量增加 1旋转线一碰到 B_i。

• 当我们旋转到 AB_j，并且 B_j 是我们顺序中某个矩形的最后一个角时，交叉的矩形数量减少 1线一转过 B_j.

在排序之后，但在考虑有序事件之前，可以通过一些 O(n) 预处理来确定哪些角是第一个和最后一个。

简而言之，我们可以旋转到下一个此类事件并更新在 O(1) 中交叉的矩形数量。 总共有 k = O(n) 个事件。 剩下要做的是在整个算法中跟踪这个数量的全局最大值。 答案就是这个最大值。

整个算法的运行时间为 O(n * (n log n + n + n))，也就是 O(n^2 log n)，正如宣传的那样。