在二维坐标系中查找分隔线

Question

我目前正在寻找一种在二维坐标中找到分离线的好算法。

这是我所拥有的：

所以这里的算法应该返回我有 3 条不同的分隔线，然后我希望能够在稍后的执行过程中知道一个点属于哪条线。

有没有人想办法解决这个问题？

注意：区域和线条在内存中由布尔值的二维数组表示。颜色是数据的注释部分。

Answer 1

这是我想出的一个例子：（在 Playground 中使用 Swift 2 Xcode 7 beta 2 进行测试）

struct Point{
    var x, y: Int

    init(_ x: Int, _ y: Int) {
        self.x = x
        self.y = y
    }

    /**
    get points around it (Xs around P)
    if all {
        XXX
        XPX
        XXX
    } else {
        OXO
        XPX
        OXO
    }
    **/
    func pointsAround(all all: Bool = true) -> [Point] {
        if all {
            return Array(-1...1).flatMap{ x in
                (-1...1).flatMap{ y in
                    if x == 0 && y == 0 {
                        return nil
                    }
                    return Point(self.x + x, self.y + y)
                }
            }
        }
        return Array(-1...1).flatMap{ x in
            (-1...1).flatMap{ y in
                if abs(x) == abs(y) {
                    return nil
                }
                return Point(self.x + x, self.y + y)
            }
        }
    }
}

func distinguishAreas(var array: [[Bool]]) -> [[Point]] {
    // result
    var points = [[Point]]()

    let width = array.count
    let height = array[0].count
    // returns array[x][y] but with savety check (otherwise false)
    func getBool(x: Int, _ y: Int) -> Bool {
        guard 0..<width ~= x && 0..<height ~= y else { return false }
        return array[x][y]
    }

    // points where to check array
    var crawlers = [Point]()

    // loop through whole array
    for x in 0..<array.count {
        for y in 0..<array[0].count where array[x][y] {
            // if point (array[x][x]) is true

            // new point where to check
            crawlers = [Point(x, y)]

            // points to append (one area)
            var newPoints = [Point]()
            // loop as long as area is not "eaten" by crawlers
            while crawlers.count != 0 {

                // crawlers "eat" area and remove some of themselves
                crawlers = crawlers.filter{
                    let temp = array[$0.x][$0.y]
                    array[$0.x][$0.y] = false
                    return temp
                }

                newPoints += crawlers

                // make new crawlers around old crawlers and only where area is
                // passing false to p.pointsAround is mouch faster than true
                crawlers = crawlers.flatMap{ p in
                    p.pointsAround(all: false).filter{ getBool($0.x, $0.y) }
                }
            }
            points.append(newPoints)
        }
    }
    return points
}

编辑：在评论 // crawlers "eat" area and remove some of themselves 下进行了更改，这使得算法在大面积上更有效

Answer 2

您需要的似乎是图的连接组件，其中每个单元格都是一个顶点，如果顶点共享一条边，则它们是连接的。有几种算法可用于查找连通分量，其中最著名的是广度优先搜索和深度优先搜索。

这些算法中的每一个都可以返回组件的数量（“行”），并且还允许为每个单元分配它所属的组件的数量。