如何将一组矩形分组为连接区域的“岛”？

Question

问题

我有一个java.awt.Rectangles 数组。对于不熟悉这个类的人来说，重要的信息是它们提供了一个.intersects(Rectangle b) 函数。

我想编写一个函数，接收这个Rectangles 数组，并将其分解为相连的矩形组。

比如说，这些是我的矩形（构造函数接受参数x、y、width、height）：

Rectangle[] rects = new Rectangle[]
{
    new Rectangle(0, 0, 4, 2), //A
    new Rectangle(1, 1, 2, 4), //B
    new Rectangle(0, 4, 8, 2), //C
    new Rectangle(6, 0, 2, 2) //D
}

快速绘图显示 A 与 B 相交， B 与 C 相交。 D 与任何东西都不相交。一幅乏味的 ascii 艺术作品也可以完成这项工作：

┌───────┐   ╔═══╗
│A╔═══╗ │   ║ D ║
└─╫───╫─┘   ╚═══╝
  ║ B ║                 
┌─╫───╫─────────┐
│ ╚═══╝ C       │
└───────────────┘

因此，我的函数的输出应该是：

new Rectangle[][]{
    new Rectangle[] {A,B,C},
    new Rectangle[] {D}
}

失败的代码

这是我解决问题的尝试：

public List<Rectangle> getIntersections(ArrayList<Rectangle> list, Rectangle r)
{
    List<Rectangle> intersections = new ArrayList<Rectangle>();
    for(Rectangle rect : list)
    {

        if(r.intersects(rect))
        {
            list.remove(rect);
            intersections.add(rect);
            intersections.addAll(getIntersections(list, rect));
        }
    }
    return intersections;
}

public List<List<Rectangle>> mergeIntersectingRects(Rectangle... rectArray)
{
    List<Rectangle> allRects = new ArrayList<Rectangle>(rectArray);
    List<List<Rectangle>> groups = new ArrayList<ArrayList<Rectangle>>();
    for(Rectangle rect : allRects)
    {
        allRects.remove(rect);
        ArrayList<Rectangle> group = getIntersections(allRects, rect);
        group.add(rect);
        groups.add(group);
    }
    return groups;
}

不幸的是，这里似乎有一个无限递归循环。我没有受过教育的猜测是 java 不喜欢我这样做：

for(Rectangle rect : allRects)
{
    allRects.remove(rect);
    //...
}

谁能解释一下这个问题？

Answer 1

我没有使用我的 java foo，但我想问题是您在迭代列表时要从列表中删除项目。根据容器类型的实现，这可能会有很大的问题。有更多 Java 知识的人可能能够证实或否认这一点。

这个SO Question 似乎证实了我的怀疑。

在谷歌上搜索了一下，似乎 java 迭代器支持删除方法，所以不是

allRects.remove(rect);

你应该使用迭代器，然后使用

rect_i.remove();

同样的

list.remove(rect);

虽然我认为这仍然会给你带来麻烦，因为你正在修改调用堆栈中较低级别的同一个列表。

我的版本：

ArrayList<Rectangle> rects = new ArrayList<Rectangle>(rectArray);
ArrayList<ArrayList<Rectangle>> groups = new ArrayList<ArrayList<Rectangle>>();
while (!rects.isEmpty)
{
    ArrayList<Rectangle> group = new ArrayList<Rectangle>();
    ArrayList<Rectangle> queue = new ArrayList<Rectangle>();
    queue.add(rects.remove(0));
    while (!queue.isEmpty)
    {
        rect_0 = queue.remove(0);
        rect_i = rects.iterator();
        while (rect_i.hasNext())
        {
            Rectangle rect_1 = rect_i.next();
            if (rect_0.intersects(rect_1))
            {
                queue.add(rect_1);
                rect_i.remove();
            }
        }
        group.add(rect_0);
    }
    groups.add(group);
}

注意：我认为代码现在是正确的，但我只是根据参考文档编写的，而且我不是 Java 编码器，因此您可能需要调整。

顺便说一句，如果您需要检查一小部分矩形列表，这种类型的朴素算法很好，但如果您想对非常大的列表执行此操作，那么您将希望使用更高效的算法。这种简单的算法是 O(n^2)，这是一种更智能的算法，它首先按字典顺序对所有矩形角进行排序，然后执行平面扫描并在扫描线上进行范围相交检查，这将产生一个相对简单的 O(n log n) 算法。

Answer 2

你不能从你迭代的列表中删除一个对象，不管是否是迭代器对象，你需要找到另一种方法

Answer 3

（评论太长了）

快速绘图不显示 A 与 B 相交：A 的高度为 4，而 B 从 Y 位置 5 开始，它们怎么可能相交！？

您可以使用以下打印出'false'的内容来验证它：

System.out.println( new Rectangle(0, 0, 2, 4).intersects( new Rectangle(1, 5, 4, 2) ) );

那么您的方法签名不完整，您的代码示例也是如此。

如果您稍微澄清一下您的问题并给出一个可行的、正确的示例，那么我为您提供了一个非常好的解决方案。

Answer 4

好吧，我想我明白了。这个算法效率相当低，根据 wich 的计算 O(n^3)，但它似乎确实有效。

我在getIntersections() 中使用Set 而不是List 来避免对同一个矩形进行两次计数（尽管我认为这实际上没有必要）。我猜你的最终结果甚至可能是Set<Set<Rectangle>>，但算法应该差不多。我还在任何地方都使用了Lists 而不是数组，因为我认为数组很难看，但如果需要，它很容易转换回来。集合newRectanglesToBeAdded 让我们决定是否需要继续循环，并且还阻止我们在迭代列表时添加到列表中（这与尝试从列表中删除内容一样糟糕，而我们'重新迭代它）。我认为这不是最优雅的解决方案，但它似乎有效（至少对于您提供的测试数据而言）。

  public static Set<Rectangle> getIntersections(List<Rectangle> list,
      Rectangle r) {
    Set<Rectangle> intersections = new HashSet<Rectangle>();
    intersections.add(r);

    Set<Rectangle> newIntersectionsToBeAdded = new HashSet<Rectangle>();

    do {
      newIntersectionsToBeAdded.clear();
      for (Rectangle r1 : list) {
        for (Rectangle r2 : intersections) {
          if (!intersections.contains(r1) && r2.intersects(r1)) {
            newIntersectionsToBeAdded.add(r1);
          }
        }
      }
      intersections.addAll(newIntersectionsToBeAdded);
    } while (!newIntersectionsToBeAdded.isEmpty());
    return intersections;
  }

  public static List<Set<Rectangle>> mergeIntersectingRects(List<Rectangle> allRects) {
    List<Set<Rectangle>> grouped = new ArrayList<Set<Rectangle>>();
    while (!allRects.isEmpty()) {
      Set<Rectangle> intersections = getIntersections(allRects, allRects.get(0));
      grouped.add(intersections);
      allRects.removeAll(intersections);
    }
    return grouped;
  }

Answer 5

你想要的是找到connected components。也就是说，想象一个图，其顶点对应于矩形，如果对应的矩形相交，则两个顶点之间有一条边。然后，你想找到和label这个图的连通分量。

仅查找边（确定每对矩形是否相交）需要 O(n²) 时间，之后您可以使用 depth-first search 或 breadth-first search 来查找额外 O(E) 时间内的所有组件，其中 E 2.

在伪代码（将其转换为 Java 的简单练习）中，它可能看起来像这样：

# r is the list of rectangles
n = length of r (number of rectangles)

#Determine "neighbors" of each vertex
neighbors = (array of n lists, initially empty)
for i in 1 to n:
    for j in 1 to n:
        if i!=j and r[i].intersects(r[j]):
            neighbors[i].append(j)

#Now find the connected components
components = (empty list of lists)
done = (array of n "False"s)
for i in 1 to n:
    if done[i]: continue
    curComponent = (empty list)
    queue = (list containing just i)
    while queue not empty:
        r = pop(head of queue)
        for s in neighbors[r]:
            if not done[s]:
                done[s] = True
                queue.push(s)
                curComponent.push(s)
    #Everything connected to i has been found
    components.push(curComponent)

return components

我正在预先计算邻居并使用“完成”标签来保存 O(n) 因素并使整个事情 O(n²)。事实上，这个算法是针对一般图的，但是因为你的图比较特殊——来自矩形——你可以做得更好：实际上可以在 O(n log n) 时间内解决这个问题，使用segment trees .

Answer 6

Connected components.

或者，因为你只有矩形，你可以设计一个非常有效的sweep line algorithm。

我希望最好的算法至少花费O( n^2 ) 时间，因为给定n 矩形有O( n^2 ) 可能的交叉点，任何计算你想要的算法都需要在某个点考虑所有交叉点。

Answer 7

如果您需要 O(n log n) 算法，Imai 和 Asano 在Finding the connected components and a maximum clique of an intersection graph of rectangles in the plane 中展示了一个。

注意：我仍在研究自己的平面扫描算法，以在 O(n log n) 时间内找到集合。

Answer 8

这是我最终寻求的解决方案。谁能猜猜它的效率？

包java.util;

import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.List;

public class RectGroup extends ArrayList<Rectangle> implements List<Rectangle>
{
    public RectGroup(Rectangle... rects)
    {
            super(rects);
    }

    public RectGroup()
    {
        super();
    }

    public boolean intersects(Rectangle rect)
    {
        for(Rectangle r : this)
            if(rect.intersects(r))
                return true;

        return false;
    }

    public List<RectGroup> getDistinctGroups()
    {
        List<RectGroup> groups = new ArrayList<RectGroup>();
        // Create a list of groups to hold grouped rectangles.

        for(Rectangle newRect : this)
        {
            List<RectGroup> newGroupings = new ArrayList<RectGroup>();
            // Create a list of groups that the current rectangle intersects.

            for(RectGroup group : groups)
                if(group.intersects(newRect))
                    newGroupings.add(group);
            // Find all intersecting groups

            RectGroup newGroup = new RectGroup(newRect);
            // Create a new group

            for(List<Rectangle> oldGroup : newGroupings)
            {
                groups.remove(oldGroup);
                newGroup.addAll(oldGroup);
            }
            // And merge all the intersecting groups into it

            groups.add(newGroup);
            // Add it to the original list of groups
        }
        return groups;
    }
}