寻找拼图解决方案的算法

Question

我正在尝试制作一个游戏，玩家必须在游戏板上从头到尾找到自己的方式。

如你所见，这个游戏板包含一堆红色的圆形障碍物。 为了赢得比赛，玩家必须移除最少量的障碍物。 所以我的问题是，我如何以编程方式找出要删除的最小障碍，释放路径？ 自由路径将被视为之间的空间，圆圈不重叠且不接触。

所以我真正需要的是要移除的最小圆圈量，我不需要实际的路径。 是否有捷径可寻？

并且为了补充对该游戏板的理解，每个圆圈具有相同的半径，并且受到黑线的限制。

而且，没有必要沿直线移动。

Answer 1

它是图论maximum flow问题。

假设每个圆都是图中的一个节点。 另外还介绍了2个特殊节点： TOP和BOTTOM 。 如果这些节点与TOP / BOTTOM侧相交，则将这些节点连接起来。 如果圆相交，则将与圆相对应的节点相互连接。

现在您需要在此图中找到最小切割，将TOP作为源 ，将BOTTOM作为接收器 ，反之亦然。 您可以使用Max-flow_min-cut_theorem来解决它。 它说的是Minimum-cut problem与Max-flow问题等价。 您可以在TopCoder上找到有关如何解决Max-Flow problem详细信息。

由于我们只能通过每个节点一次，我们应该将节点转换为容量的有向边，其中每个节点具有节点内和节点外。 max-flow算法将解决结果图上的问题，并考虑到我们正在删除圆而不是圆之间的连接这一事实。 对于此问题，删除图形中的节点而不是边缘总是更好的决定，因为我们总是可以通过删除节点来删除任何边缘。 另外删除节点可能导致删除多个边缘。

顺便说一句，在Uva Online Judge上也可以找到类似的问题。 尝试在法官身上解决这个问题是个好主意，然后你就会确定你的解决方案是正确的。

Answer 2

在试图想象列昂尼德所写的内容时，我制作了以下图表。

Answer 3

对于图形转换，这样的事情可能会起作用。

如果两个圆重叠，则在两个圆之间做一个墙（蓝线）。 不要忘记添加顶部和底部边框。 这会产生几个区域。 这些将是图表的所有节点。

接下来，我们必须找到边缘，从一个节点到另一个节点的成本。 拿两个相邻区域（共用一堵墙）。然后通过蛮力，或者你想出的聪明方法，确定从这个区域移动到另一个区域的成本。 如果删除圆圈，则表示删除了转到该圆圈的所有墙壁。 如果这使得两个区域成为一个区域，则边缘的成本为1.如果需要移除两个圆（它们具有的所有墙）以组合这两个区域，则成本为2.等等。

绘制了一些边缘（绿色）。 我们必须从起始区域到结束区域。 你现在有一个日常加权图。

我认为这可以改进很多，但我把它留作练习=）

在这种情况下，最小值为3。

警告，图片是手工绘制的，我确实忘记了几个墙壁，边缘和区域。 仅用于说明目的。

Answer 4

好吧所以我决定在pygame中对此进行可视化。

事实证明这比我想象的要困难得多 。

其他建议中的想法是使用Max Flow 。 从源到汇的流动瓶颈是流量最密集的地方。 如果我们在这个密集的瓶颈处将图形切成两半（即在最小切割处 ），那么我们有最小的圆圈数。 它发生了maxflow = min-cut。

这是我采取的步骤：

1. 创建pygame世界我可以随机生成圆圈

2. 使功能能够计算出圆圈之间的所有碰撞：

这涉及按x坐标对圆圈进行排序。 现在为了找到Circle [0]的所有碰撞，我继续沿着阵列测试进行碰撞，直到找到一个x值超过2 *半径大于circle [0] sx值的圆圈，然后我可以弹出圆圈[0] ]并重复这个过程..

3. 创建源节点和汇聚节点 ，找出需要连接的圈子。

步骤4-5在“ findflow（）函数”中执行

4. 创建表示带节点的圆的基本无向网络X图。 仅在相应的圆碰撞时才连接节点。

5. 这就是它开始变得艰难的地方..我从我的无向图中创建了一个新的有向图 。 因为我需要通过圆（即节点）而不是边缘来计算流量，所以我需要将每个节点分成两个节点，边缘位于两个节点之间。

   假设我将节点X连接到节点Y（Y < - > X）（在原始图中）。

   我将X更改为Xa和Xb，以便Xa连接到Xb（Xa> Xb），Y也变为（Ya-> Yb）。

   我还需要添加（Yb-> Xa）和（Xb-> Ya）来表示X和Y之间的原始连接。

无向图中的所有边都被赋予容量= 1 （例如，您只能跨过一次圆）

6. 我现在应用networkx。 我的新有向图上的ford_fulkerson（）算法。 这找到了flowValue和flowGraph。

flowValue是一个整数。 它是最小切割（或从源到下沉的最大流量）。 这是我们一直在寻找的答案 。 它代表我们需要删除的最小圈数。

奖金分配：

我想...为什么要停在这里，要删除的圈数很好，但我想知道我需要删除的确切圆圈。 要做到这一点，我需要找出在flowGraph上实际发生最小切割的位置。 我设法弄清楚如何做到这一点，但是我的实现在某个地方有一个bug，所以它有时会略微错误地选择，所以得到错误的圈子。

为了找到最小切割，我们将使用步骤6中生成的flowGraph。 这个想法是这个图的瓶颈将是最小的。 如果我们尝试从源头到水槽的流动，我们将卡在瓶颈上，因为瓶颈周围的所有边缘都将达到最大容量。 所以我们只是使用DFS（ 深度优先搜索 ）尽可能地向下流动。 DFS仅允许沿流程图中未达到最大容量的边移动 。 （例如，他们的流量为0而不是1）。 使用源代码中的DFS，我记下了我可以看到的所有节点，将它们存储在self.seen中。 现在在DFS之后，对于所见的所有节点，我检查节点是否具有到DFS中未见的节点的最大容量边缘。 所有这些节点都在最小切割上。

这是我运行的模拟之一的图片：

并且删除了圆圈后，我用油漆填充它（您可能需要放大一点以确定圆圈之间确实存在间隙）：

学习：

即使在python中速度也可以，运行1000圈即可。

这比我想象的要困难，我仍然有一个错误，试图使用DFS找到原始的圆圈。 （如果有人可以帮助找到那个很棒的bug）。

一开始代码很优雅，虽然我不断添加黑客来改变可视化等。

工作代码（除了DFS中的轻微偶然错误）：

__author__ = 'Robert'
import pygame
import networkx

class CirclesThing():
    def __init__(self,width,height,number_of_circles):
        self.removecircles = False #display removable circles as green.
        self.width = width
        self.height = height

        self.number_of_circles = number_of_circles
        self.radius = 40

        from random import randint
        self.circles = sorted(set((randint(self.radius,width-self.radius),randint(2*self.radius,height-2*self.radius)) for i in range(self.number_of_circles)))

        self.sink = (self.width/2, self.height-10)
        self.source = (self.width/2, 10)

        self.flowValue,self.flowGraph = self.find_flow()

        self.seen = set()
        self.seen.add(self.source)
        self.dfs(self.flowGraph,self.source)

        self.removable_circles = set()
        for node1 in self.flowGraph:
            if node1 not in self.seen or node1==self.source:
                continue
            for node2 in self.flowGraph[node1]:
                if self.flowGraph[node1][node2]==1:
                    if node2 not in self.seen:
                        self.removable_circles.add(node1[0])


    def find_flow(self):
        "finds the max flow from source to sink and returns the amount, along with the flow graph"
        G = networkx.Graph()
        for node1,node2 in self.get_connections_to_source_sink()+self.intersect_circles():
            G.add_edge(node1,node2,capacity=1)

        G2 = networkx.DiGraph()
        for node in G:
            if node not in (self.source,self.sink):
                G2.add_edge((node,'a'),(node,'b'),capacity=1) #each node is split into two new nodes. We add the edge between the two new nodes flowing from a to b.

        for edge in G.edges_iter():
            if self.source in edge or self.sink in edge:
                continue #add these edges later
            node1,node2 = edge
            G2.add_edge((node1,'b'),(node2,'a'),capacity=1) #if we flow through a circle (from node1a to node1b) we need to be able to flow from node1b to all node1's children
            G2.add_edge((node2,'b'),(node1,'a'),capactiy=1) #similarly for node2..

        for node in G[self.source]:
            G2.add_edge(self.source,(node,'a'))
        for node in G[self.sink]:
            G2.add_edge((node,'b'),self.sink)

        flowValue, flowGraph = networkx.ford_fulkerson(G2,self.source,self.sink)

        return flowValue, flowGraph


    def dfs(self,g,v):
        "depth first search from source of flowGraph. Don't explore any nodes that are at maximum capacity. (this means we can't explore past the min cut!)"
        for node in g[v]:
            if node not in self.seen:
                self.seen.add(node)
                if g[v][node]!=1 or v==self.source:
                    self.dfs(g,node)

    def display(self):
        self.draw_circles()
        self.draw_circles(circle_radius=5, circle_colour=(255,0,0))
        if not self.removecircles:
            lines = self.intersect_circles()
            self.draw_lines(lines)
        self.draw_source_sink()

    def draw_circles(self,circle_radius=None,circle_colour=(0,0,255),circles=None):
        if circle_radius is None:
            circle_radius = self.radius
        if circles is None:
            circles = self.circles

        circle_thickness = 2
        for pos in circles:
            cc = circle_colour if pos not in self.removable_circles else (100,200,0) #change colour of removable circles
            ct = circle_thickness if pos not in self.removable_circles else 4 #thicken removable circles
            if pos not in self.removable_circles or not self.removecircles:
                pygame.draw.circle(screen, cc, pos, circle_radius, ct)

    def intersect_circles(self):
        colliding_circles = []
        for i in range(len(self.circles)-1):
            for j in range(i+1,len(self.circles)):
                x1,y1 = self.circles[i]
                x2,y2 = self.circles[j]
                if x2-x1>2*self.radius+5: #add 5 to make a more obvious gap visually
                    break #can't collide anymore.
                if (x2-x1)**2 + (y2-y1)**2 <= (2*self.radius)**2+5:
                    colliding_circles.append(((x1,y1),(x2,y2)))
        return colliding_circles

    def draw_lines(self,lines,line_colour=(255, 0, 0)):
        for point_pair in lines:
            point1,point2 = point_pair
            try:
                tot = self.flowGraph[(point1,'b')][(point2,'a')] + self.flowGraph[(point2,'b')][(point1,'a')] #hack, does anything flow between the two circles?
            except KeyError:
                tot = 0
            thickness = 1 if tot==0 else 3
            lc = line_colour if tot==0 else (0,90,90)
            pygame.draw.line(screen, lc, point1, point2, thickness)

    def draw_source_sink(self):
        self.draw_circles(circles=(self.sink,self.source),circle_radius=15,circle_colour=(0,255,0))

        bottom_line = ((0,self.height-3*self.radius),(self.width,self.height-3*self.radius))
        top_line = ((0,3*self.radius),(self.width,3*self.radius))

        self.draw_lines([top_line, bottom_line],line_colour=(60,60,60))

        if not self.removecircles:
            self.draw_lines(self.get_connections_to_source_sink(),line_colour=(0,255,0))

    def get_connections_to_source_sink(self):
        connections = []
        for x,y in self.circles:
            if y<4*self.radius:
                connections.append((self.source,(x,y)))
            elif y>height-4*self.radius:
                connections.append((self.sink,(x,y)))
        return connections

    def get_caption(self):
        return "flow %s, circles removes %s" %(self.flowValue,len(self.removable_circles))



time_per_simulation = 5 #5 seconds
width, height = 1400, 600
background_colour = (255,255,255)
screen = pygame.display.set_mode((width, height))

screen.fill(background_colour)
from pygame.locals import USEREVENT
pygame.time.set_timer(USEREVENT+1,time_per_simulation*1000)

simulations = 0
simulations_max = 20

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == USEREVENT+1:
            if simulations % 2 ==0:
                world = CirclesThing(width,height,120) #new world
            else:
                world.removecircles = True #current world without green circles

            screen.fill(background_colour)
            world.display()
            pygame.display.set_caption(world.get_caption())
            pygame.display.flip()

            if simulations>=2*simulations_max:
                running = False
            simulations+=1

            if False:
                pygame.image.save(screen,'sim%s.bmp'%simulations)

Answer 5

一种选择是首先删除具有最多重叠或触摸次数的圆圈。 在您移除每个之后，检查它是否是解决方案，如果不是继续删除。

var circle;
circle = findMostOverlapCircle();
while(circle != null) {
    circle.remove();
    circle = findMostOverlapCircle();
}