c: Ford - Fulkerson Algorithm

 

FordFulkersonAlgorithm.h
 
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/**
 * *****************************************************************************
 * @file        FordFulkersonAlgorithm.h
 * @brief       Ford - Fulkerson Algorithm in C Ford-Fulkerson算法（FFA）是一种 贪婪算法 ，用于计算流网络中的最大流量
 * IDE VSCODE C11
 * @author       (geovindu,Geovin Du,涂聚文)
 * @date        2023-09-26
 * @copyright   geovindu
 * *****************************************************************************
 */
#ifndef FORDFULKERSONALGORITHM_H
#define FORDFULKERSONALGORITHM_H
 
 
 
  
#include <stdio.h>
#include <stdlib.h>
 
#define A 0
#define B 1
#define C 2
#define MAX_NODES 10
#define O 1000000000
 
 
 
int flow[MAX_NODES][MAX_NODES];
int color[MAX_NODES];
int pred[MAX_NODES];
 
int head, tail;
int q[MAX_NODES + 2];
 
/**
 * @brief      
 *
 * @param       x
 * @param       y
 * @return      int
 */
int min(int x, int y);
 
/**
 * @brief      
 *
 * @param       x
 * @param       color
 */
void enqueue(int x,int color[MAX_NODES]);
 
/**
 * @brief      
 *
 * @param       color
 * @return      int
 */
int dequeue(int color[MAX_NODES]);
 
/**
 * @brief      
 *
 * @param       start
 * @param       target
 * @param       color
 * @param       pred
 * @param       flow
 * @param       capacity
 * @return      int
 */
int bfs(int start, int target,int color[MAX_NODES],int pred[MAX_NODES],int flow[MAX_NODES][MAX_NODES],int capacity[MAX_NODES][MAX_NODES]);
 
 
/**
 * @brief      
 *
 * @param       source
 * @param       sink
 * @param       capacity
 * @return      int
 */
int FordFulkerson(int source, int sink,int capacity[MAX_NODES][MAX_NODES]);
 
 
 
 
#endif

　　

FordFulkersonAlgorithm.c
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/**
 * *****************************************************************************
 * @file        FordFulkersonAlgorithm.c
 * @brief       Ford - Fulkerson Algorithm in C Ford-Fulkerson算法（FFA）是一种 贪婪算法 ，用于计算流网络中的最大流量
 * IDE VSCODE C11
 * @author       (geovindu,Geovin Du,涂聚文)
 * @date        2023-09-26
 * @copyright   geovindu
 * *****************************************************************************
 */
 
#include <stdio.h>
#include "include/FordFulkersonAlgorithm.h"
 
 
 
int fn=6;
int fe=7;
/**
 * @brief      
 *
 * @param       x
 * @param       y
 * @return      int
 */
int min(int x, int y) {
  return x < y ? x : y;
}
 
 
 
/**
 * @brief      
 *
 * @param       x
 * @param       color
 */
void enqueue(int x,int color[MAX_NODES]) {
  q[tail] = x;
  tail++;
  color[x] = B;
}
/**
 * @brief      
 *
 * @param       color
 * @return      int
 */
int dequeue(int color[MAX_NODES]) {
  int x = q[head];
  head++;
  color[x] = C;
  return x;
}
 
// Using BFS as a searching algorithm
/**
 * @brief      
 *
 * @param       start
 * @param       target
 * @param       color
 * @param       pred
 * @param       flow
 * @param       capacity
 * @return      int
 */
int bfs(int start, int target,int color[MAX_NODES],int pred[MAX_NODES],int flow[MAX_NODES][MAX_NODES],int capacity[MAX_NODES][MAX_NODES]) {
  int u, v;
  for (u = 0; u < fn; u++) {
    color[u] = A;
  }
  head = tail = 0;
  enqueue(start,color);
  pred[start] = -1;
  while (head != tail) {
    u = dequeue(color);
    for (v = 0; v < fn; v++) {
      if (color[v] == A && capacity[u][v] - flow[u][v] > 0) {
        enqueue(v,color);
        pred[v] = u;
      }
    }
  }
  return color[target] == C;
}
 
// Applying fordfulkerson algorithm
/**
 * @brief      
 *
 * @param       source
 * @param       sink
 * @param       capacity
 * @return      int
 */
int FordFulkerson(int source, int sink,int capacity[MAX_NODES][MAX_NODES]) {
  int i, j, u;
  int max_flow = 0;
  for (i = 0; i < fn; i++) {
    for (j = 0; j < fn; j++) {
      flow[i][j] = 0;
    }
  }
 
  // Updating the residual values of edges
  while (bfs(source, sink,color,pred,flow,capacity)) {
    int increment = O;
    for (u = fn - 1; pred[u] >= 0; u = pred[u]) {
      increment = min(increment, capacity[pred[u]][u] - flow[pred[u]][u]);
    }
    for (u = fn - 1; pred[u] >= 0; u = pred[u]) {
      flow[pred[u]][u] += increment;
      flow[u][pred[u]] -= increment;
    }
    // Adding the path flows
    max_flow += increment;
  }
  return max_flow;
}

　　

调用：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//14 Ford - Fulkerson algorith
 /**/
 
 printf("\n14 Ford - Fulkerson algorith \n");
 
 int capacity[10][10];
 for (int i = 0; i < n; i++) {
     for (int j = 0; j < n; j++) {
     capacity[i][j] = 0;
     }
 }
 capacity[0][1] = 8;
 capacity[0][4] = 3;
 capacity[1][2] = 9;
 capacity[2][4] = 7;
 capacity[2][5] = 2;
 capacity[3][5] = 5;
 capacity[4][2] = 7;
 capacity[4][3] = 4;
 
 int s = 0, t =5;
 printf("\nMax Flow: %d\n", FordFulkerson(s, t,capacity));

　　

 

 
posted @   ®Geovin Du Dream Park™  阅读(8)  评论(0)  编辑  收藏  举报
相关博文：
·  python: Algorithm II
·  c: Dijkstra's Algorithm
·  网络流学习笔记
·  网络流的C++代码实现与过程讲解
·  [数学建模]网络最大流(自用,可能说的不明白)
阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 零经验选手，Compose 一天开发一款小游戏！
· 一起来玩mcp_server_sqlite，让AI帮你做增删改查！！
历史上的今天：
2022-09-26 Java: Chain of Responsibility Pattern
2021-09-26 Dynamically create a div element with JavaScript/jQuery
< 2025年3月 >
日 一 二 三 四 五 六
23 24 25 26 27 28 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 1 2 3 4 5
点击右上角即可分享
微信分享提示