图的最大流最小割

最大流最小割问题是图论中经典的问题，它描述了在一个有向图中从源点到汇点的最大流量，同时求出最小割。这个问题有多种解决方法，其中一种常见的方法是使用Ford-Fulkerson算法。

Ford-Fulkerson算法的基本思想是不断增加流量，直到无法再增加为止。具体步骤如下：

1. 初始化流量为0。
2. 在剩余网络中找到一条增广路径。增广路径是一条从源点到汇点的路径，路径上的边都有剩余容量（即流量小于容量的边）。
3. 在增广路径上找到最小的剩余容量，记为minFlow。
4. 更新增广路径上的所有边的流量，将其增加minFlow。
5. 更新剩余容量，即将增广路径上的所有边的剩余容量减去minFlow。
6. 重复步骤2-5，直到没有增广路径为止。
7. 最终的流量即为最大流，剩余网络中的剩余容量即为最小割。

下面是使用C++代码实现的Ford-Fulkerson算法：

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

// 通过广度优先搜索找增广路径
bool bfs(vector<vector<int>>& graph, vector<int>& parent, int source, int sink) {
    int n = graph.size();
    vector<bool> visited(n, false);
    queue<int> q;
    q.push(source);
    visited[source] = true;
    parent[source] = -1;

    while (!q.empty()) {
        int u = q.front();
        q.pop();

        for (int v = 0; v < n; v++) {
            if (!visited[v] && graph[u][v] > 0) {
                q.push(v);
                visited[v] = true;
                parent[v] = u;
            }
        }
    }

    return visited[sink];
}

// 使用Ford-Fulkerson算法求解最大流最小割
int fordFulkerson(vector<vector<int>>& graph, int source, int sink) {
    int n = graph.size();
    vector<int> parent(n);
    int maxFlow = 0;

    while (bfs(graph, parent, source, sink)) {
        int minFlow = INT_MAX;

        // 找增广路径上的最小剩余容量
        for (int v = sink; v != source; v = parent[v]) {
            int u = parent[v];
            minFlow = min(minFlow, graph[u][v]);
        }

        // 更新增广路径上的所有边的流量
        for (int v = sink; v != source; v = parent[v]) {
            int u = parent[v];
            graph[u][v] -= minFlow;
            graph[v][u] += minFlow;
        }

        maxFlow += minFlow;
    }

    return maxFlow;
}

int main() {
    int n, m, source, sink;
    cin >> n >> m >> source >> sink;

    // 构建图的邻接矩阵表示
    vector<vector<int>> graph(n, vector<int>(n, 0));
    for (int i = 0; i < m; i++) {
        int u, v, capacity;
        cin >> u >> v >> capacity;
        graph[u][v] = capacity;
    }

    int maxFlow = fordFulkerson(graph, source, sink);
    cout << "Maximum flow: " << maxFlow << endl;

    return 0;
}

以上代码使用邻接矩阵来表示图，其中n代表节点数，m代表边数，source代表源点，sink代表汇点。通过输入构建图后，调用fordFulkerson函数求解最大流，并输出结果。

希望以上解释和代码能帮助到你理解最大流最小割问题和Ford-Fulkerson算法。