[flow, cost_flow] = min_cost_max_flow(c, u, s, t)的代码

这个函数是用来求解最小费用最大流问题的。下面是代码和参数说明：

def min_cost_max_flow(c, u, s, t):
    """
    求解最小费用最大流问题
    :param c: 二维数组，表示各个边的费用，c[i][j]表示从节点i到节点j的费用，如果没有边，则为float('inf')
    :param u: 二维数组，表示各个边的容量，u[i][j]表示从节点i到节点j的最大容量，如果没有边，则为0
    :param s: 源节点
    :param t: 汇节点
    :return: (max_flow, min_cost)，其中max_flow表示最大流量，min_cost表示最小费用
    """
    n = len(c)
    flow = 0
    cost = 0
    while True:
        # 使用Bellman-Ford算法求解最短路
        dist = [float('inf')] * n
        dist[s] = 0
        prev = [-1] * n
        q = [s]
        inqueue = [False] * n
        inqueue[s] = True
        while len(q) > 0:
            u = q.pop(0)
            inqueue[u] = False
            for v in range(n):
                if u == v or u == -1 or v == -1:
                    continue
                if u != s and prev[u] != v:
                    continue
                if u == s and v == t:
                    continue
                if u == s and c[u][v] == float('inf'):
                    continue
                if u != s and u != t and v != t and prev[u] != v:
                    continue
                if u != s and u != t and v == t and prev[u] != v:
                    continue
                if u == s and u != t and v != t and c[u][v] <= 0:
                    continue
                if u != s and u != t and v != t and (c[u][v] <= 0 or prev[u] == v):
                    continue
                new_dist = dist[u] + c[u][v]
                if new_dist < dist[v]:
                    dist[v] = new_dist
                    prev[v] = u
                    if not inqueue[v]:
                        q.append(v)
                        inqueue[v] = True
        if prev[t] == -1:
            break
        # 计算最大流量
        f = float('inf')
        v = t
        while v != s:
            u = prev[v]
            f = min(f, u[v])
            v = u
        flow += f
        # 计算最小费用
        v = t
        while v != s:
            u = prev[v]
            cost += f * c[u][v]
            u[v] -= f
            v = u
    return flow, cost

其中，参数c和u分别表示费用和容量的二维数组，s和t分别表示源节点和汇节点。函数返回两个值，第一个值是最大流量，第二个值是最小费用。

Bellman-Ford算法是用来求解最短路径的算法，这里用来求解费用的最短路径。在这个函数中，我们使用Bellman-Ford算法来求解从源节点到汇节点的最短路径，然后根据这个最短路径来更新流量和费用。循环直到没有增广路为止，此时就得到了最小费用最大流。