% 调用最小费用最大流函数 [flow, cost_flow] = min_cost_max_flow(c, u, s, t);的具体代码

这里提供一个 MATLAB 的最小费用最大流函数的代码实现供参考：

function [flow, cost_flow] = min_cost_max_flow(c, u, s, t)
% c: cost matrix
% u: capacity matrix
% s: source node
% t: sink node

n = size(c, 1); % number of nodes
f = zeros(n); % flow matrix
cost_flow = 0; % total cost of flow

while true
    % use Bellman-Ford algorithm to find the shortest path from s to t
    dist = inf(1, n);
    dist(s) = 0;
    prev_node = zeros(1, n);
    prev_edge = zeros(1, n);
    in_queue = false(1, n);
    queue = s;
    while ~isempty(queue)
        node = queue(1);
        queue(1) = [];
        in_queue(node) = false;
        for i = 1:n
            if u(node, i) > f(node, i) && dist(i) > dist(node) + c(node, i)
                dist(i) = dist(node) + c(node, i);
                prev_node(i) = node;
                prev_edge(i) = 1; % forward edge
                if ~in_queue(i)
                    queue(end+1) = i;
                    in_queue(i) = true;
                end
            end
            if u(i, node) > f(i, node) && dist(i) > dist(node) + c(i, node)
                dist(i) = dist(node) + c(i, node);
                prev_node(i) = node;
                prev_edge(i) = -1; % backward edge
                if ~in_queue(i)
                    queue(end+1) = i;
                    in_queue(i) = true;
                end
            end
        end
    end
    
    % if there is no augmenting path, stop
    if dist(t) == inf
        break
    end
    
    % find the bottleneck capacity along the augmenting path
    path_flow = inf;
    node = t;
    while node ~= s
        prev = prev_node(node);
        if prev_edge(node) == 1
            path_flow = min(path_flow, u(prev, node) - f(prev, node));
        else
            path_flow = min(path_flow, f(node, prev));
        end
        node = prev;
    end
    
    % update the flow and cost matrices
    node = t;
    while node ~= s
        prev = prev_node(node);
        if prev_edge(node) == 1
            f(prev, node) = f(prev, node) + path_flow;
            cost_flow = cost_flow + c(prev, node) * path_flow;
        else
            f(node, prev) = f(node, prev) - path_flow;
            cost_flow = cost_flow - c(node, prev) * path_flow;
        end
        node = prev;
    end
end

% calculate the total flow
flow = sum(f(s, :));

end

其中，`c` 表示边的费用矩阵，`u` 表示边的容量矩阵，`s` 表示源点，`t` 表示汇点。函数返回最大流量 `flow` 和最小费用 `cost_flow`。