题目简介

本题为2018年GATE计算机科学模拟题中的第26题。这题主要考察了程序员对最大流问题的理解，要求使用已知的最大流算法求出给定图形的最大流。

问题描述

给出一个带权有向图，必须找到该图的最大流。请使用已知的最大流算法。

输入格式

输入文件的第一行包含两个整数，分别为节点数和边数。节点编号从1到N。接下来的M行每行由三个整数组成，表示一个有向边及其边权大小。每个整数之间用空格分隔。

输出格式

程序应输出一个整数，表示该图中的最大流。

示例输入

4 5
1 2 2
1 3 1
2 3 1
2 4 1
3 4 2

示例输出

3

最大流算法简介

最大流问题是一个经典的图论问题，旨在寻找一个网络中从源到汇的最大流。最大流问题可以用多种算法有效地解决，其中最常见的算法是Ford-Fulkerson算法和Edmonds-Karp算法。

Ford-Fulkerson算法

Ford-Fulkerson算法是一个极其基础的算法，其思想在于通过不断地寻找增广路，来逐步增加流的总量。约定增广路是流量全都阐述的路径，每一条增广路必须要包含源点，并且沿着它的初始流量中的最小容量继续流动。如果不存在增广路，则已经找到了最大流量。

Edmonds-Karp算法

Edmonds-Karp算法是在Ford-Fulkerson算法的基础上发展的，它采用广度优先搜索来寻找增广路径，可以保证时间复杂度为O(VE^2)，是一个较优的解法。

代码实现

在本题中，我们可以使用任何一种最大流算法进行解决。以下是使用Edmonds-Karp算法的实现过程。

class Graph:
    def __init__(self, graph):
        self.graph = graph
        self.ROW = len(graph)

        def BFS(self, s, t, parent):
            visited = [False] * (self.ROW)

            queue = []

            queue.append(s)
            visited[s] = True

            while queue:
                u = queue.pop(0)

                for ind, val in enumerate(self.graph[u]):
                    if visited[ind] == False and val > 0:
                        queue.append(ind)
                        visited[ind] = True
                        parent[ind] = u

        def get_maximum_flow(self, source, sink):
            parent = [-1] * (self.ROW)

            max_flow = 0

            while BFS(self, source, sink, parent):

                path_flow = float("Inf")
                s = sink
                while s != source:
                    path_flow = min(path_flow, self.graph[parent[s]][s])
                    s = parent[s]

                max_flow += path_flow

                v = sink
                while v != source:
                    u = parent[v]
                    self.graph[u][v] -= path_flow
                    self.graph[v][u] += path_flow
                    v = parent[v]

            return max_flow

if __name__ == '__main__':
    graph = [[0, 2, 1, 0],
             [0, 0, 1, 1],
             [0, 0, 0, 2],
             [0, 0, 0, 0]]

    g = Graph(graph)

    source = 0
    sink = 3

    print("Maximum Flow is ", g.get_maximum_flow(source, sink))

代码实现中，我们首先定义了一个Graph类，用于表示输入的带权有向图。通过BFS来寻找增广路，并将算法的返回值最大流存储在max_flow之中，最后将其返回。