C语言经典算法之Ford-Fulkerson算法

最新推荐文章于 2024-04-12 19:46:37 发布

JJJ69

最新推荐文章于 2024-04-12 19:46:37 发布

阅读量1k

点赞数 19

分类专栏： C语言经典算法文章标签：算法 c语言深度优先开发语言数据结构图论

本文链接：https://blog.csdn.net/weixin_56154577/article/details/136064945

版权

C语言经典算法专栏收录该内容

160 篇文章 8 订阅

订阅专栏

前言

A.建议

1.学习算法最重要的是理解算法的每一步，而不是记住算法。

2.建议读者学习算法的时候，自己手动一步一步地运行算法。

B.简介

Ford-Fulkerson算法是解决网络流问题的经典方法，用于计算在一个带容量限制的有向图（网络）中从源点到汇点的最大流量。

一代码实现

#include <stdio.h>
#include <stdbool.h>

// 定义边的数据结构
typedef struct Edge {
    int from, to;
    int capacity, flow; // 边的容量和当前流
} Edge;

// 定义网络的数据结构
typedef struct Graph {
    int V, E; // 顶点数和边数
    Edge *edges; // 边的数组或邻接表
} Graph;

// 创建一个带有容量的新边
Edge createEdge(int from, int to, int capacity) {
    Edge e = {from, to, capacity, 0};
    return e;
}

// 初始化一个图并添加边
Graph initializeGraph(int V, Edge edges[], int E) {
    Graph g = {V, E, edges};
    return g;
}

// 找到从source到sink的增广路径，并返回路径上的剩余容量
int dfs(Graph *g, int source, int sink, bool visited[], int parent[]) {
    visited[source] = true;

    if (source == sink) 
        return INT_MAX;

    int minCapacity = INT_MAX;
    for (int i = 0; i < g->E; ++i) {
        Edge &e = g->edges[i];
        if (!visited[e.to] && e.flow < e.capacity) {
            int pathCapacity = dfs(g, e.to, sink, visited, parent);
            if (pathCapacity > 0) {
                minCapacity = min(minCapacity, pathCapacity);
            }
        }
    }

    if (minCapacity == INT_MAX)
        return 0;
    else {
        for (int i = 0; i < g->E; ++i) {
            Edge &e = g->edges[i];
            if (visited[e.from] && parent[e.from] == source && e.to != source) {
                int remainingFlow = min(minCapacity, e.capacity - e.flow);
                e.flow += remainingFlow;
                g->edges[i ^ 1].flow -= remainingFlow; // 更新反向边的流（假设每条正向边都有对应的反向边）
                if (remainingFlow == minCapacity) break;
            }
        }
        return minCapacity;
    }
}

// Ford-Fulkerson算法实现
int fordFulkerson(Graph *g, int source, int sink) {
    int maxFlow = 0;
    bool visited[g->V];
    int parent[g->V];

    while (true) {
        memset(visited, false, sizeof(visited));
        int augmentedFlow = dfs(g, source, sink, visited, parent);
        if (augmentedFlow == 0) break;
        maxFlow += augmentedFlow;
    }

    return maxFlow;
}

// 示例：使用上述函数创建、初始化图并计算最大流
int main() {
    // 假设我们已经有了边的列表及其容量
    Edge edges[] = {...}; // 这里应填充实际的边数据
    int V = ...; // 顶点数量
    int E = ...; // 边的数量

    Graph g = initializeGraph(V, edges, E);
    int maxFlow = fordFulkerson(&g, SOURCE_VERTEX, SINK_VERTEX);
    printf("The maximum flow is: %d\n", maxFlow);

    return 0;
}

注意：在上述代码中，为了简化示例，我们假设了每个边有一个与其相关的反向边，并且可以通过索引进行访问（例如，正向边为i时，反向边为）。在实际编程中，可能需要根据实际情况调整数据结构来存储和处理这些反向边。

此外，在实际应用中，为了提高效率，可以将深度优先搜索（DFS）替换为广度优先搜索（BFS），得到Edmonds-Karp算法，以更快地找到较短的增广路径。

二时空复杂度

A.时间复杂度

在最坏的情况下，Ford-Fulkerson算法的时间复杂度为O(VE^2)，其中V是图中顶点的数量，E是边的数量。这是因为每次执行增广路径搜索时（通常使用DFS或BFS），可能会遍历所有的边，并且在找到最大流之前可能需要进行多轮增广操作。如果每次都通过一个长度为E的路径来增加流量，那么最坏情况下，即网络中存在一条从源到汇的长链结构，需要进行V-1次增广操作，每轮增广操作中至少检查E条边。