1

我正在尝试使用Ford Fulkerson算法在网络中找到最大流量，它适用于非循环图但是如果有一个循环它会永远循环。这是我用来查找最大流量的代码：

class Edge (object):
    reverse = None
    def __init__ (self, u, v, w):
        self.source = u
        self.sink = v  
        self.capacity = w
        self.flow = 0

class FlowNetwork (object):
    def __init__ (self, path):
        rows = len (path)
        cols = len (path[0])
        self.graph = {self.vname (x, rows): [] for x in range (rows)}
        for r in range (rows):
            for c in range (cols):
                if path[r][c] > 0:
                    u = self.vname (r, rows)
                    v = self.vname (c, rows)
                    edge = Edge (u, v, path[r][c])
                    reverse = Edge (v, u, 0)
                    edge.reverse = reverse
                    reverse.reverse = edge
                    self.graph[u].append (edge)
                    self.graph[v].append (reverse)

    def vname (self, x, t):
        return 's' if x == 0 else 't' if x == t - 1 else 'v' + str (x)

    def dfs (self, source, sink):
        queue = [[x] for x in self.graph[source]]
        while queue:
            path = queue.pop (0)
            vertex = path[-1]
            if vertex.sink == sink: return path
            for edge in self.graph[vertex.sink]:
                if edge.capacity - edge.flow > 0:
                    if edge not in path and edge.reverse not in path:
                        queue.append ([x for x in path] + [edge])

    def maxFlow (self, source, sink):
        path = self.dfs (source, sink)
        while path != None:
            flow = min ([edge.capacity - edge.flow for edge in path])
            for edge in path:
                edge.flow += flow
                edge.reverse.flow -= flow
            path = self.dfs (source, sink)
        return sum (edge.flow for edge in self.graph[source])

例如，如果我使用上面的程序来解决以下网络：

带圈的图

它将无限期地运行，我如何找到此类网络中的最大流量？

更新：

我忘记在上面的代码中跟踪深度优先搜索 dfs 函数中的访问边，所以我修复了它：

def dfs (self, source, sink):
    queue = [[x] for x in self.graph[source]]
    visited = []
    while queue:
        path = queue.pop (0)
        vertex = path[-1]
        if vertex.sink == sink: return path
        for edge in self.graph[vertex.sink]:
            if edge not in visited and edge.capacity - edge.flow > 0:
                if edge not in path and edge.reverse not in path:
                    queue.append ([x for x in path] + [edge])
                    visited.append (edge)

但是它仍然无限循环。

4

0 回答 0