#include #include #include #include

#include
#include
#include
#include
using namespace std;

// Number of vertices in given graph
#define V 6

/* Returns true if there is a path from source 's' to sink 't' in
residual graph. Also fills parent[] to store the path */
bool bfs(int rGraph[V][V], int s, int t, int parent[])
{
// Create a visited array and mark all vertices as not visited
bool visited[V];
memset(visited, 0, sizeof(visited));

// Create a queue, enqueue source vertex and mark source vertex
// as visited
queue q;
q.push(s);
visited[s] = true;
parent[s] = -1;

// Standard BFS Loop
while (!q.empty())
{
int u = q.front();
q.pop();

for (int v=0; v 0)
{
q.push(v);
parent[v] = u;
visited[v] = true;
}
}
}

// If we reached sink in BFS starting from source, then return
// true, else false
return (visited[t] == true);
}

// Returns tne maximum flow from s to t in the given graph
int fordFulkerson(int graph[V][V], int s, int t)
{
int u, v;

// Create a residual graph and fill the residual graph with
// given capacities in the original graph as residual capacities
// in residual graph
int rGraph[V][V]; // Residual graph where rGraph[i][j] indicates
// residual capacity of edge from i to j (if there
// is an edge. If rGraph[i][j] is 0, then there is not)
for (u = 0; u < V; u++)
for (v = 0; v < V; v++)
rGraph[u][v] = graph[u][v];

int parent[V]; // This array is filled by BFS and to store path

int max_flow = 0; // There is no flow initially

// Augment the flow while tere is path from source to sink
while (bfs(rGraph, s, t, parent))
{
// Find minimum residual capacity of the edhes along the
// path filled by BFS. Or we can say find the maximum flow
// through the path found.
int path_flow = INT_MAX;
for (v=t; v!=s; v=parent[v])
{
u = parent[v];
path_flow = min(path_flow, rGraph[u][v]);
}

// update residual capacities of the edges and reverse edges
// along the path
for (v=t; v != s; v=parent[v])
{
u = parent[v];
rGraph[u][v] -= path_flow;
rGraph[v][u] += path_flow;
}

// Add path flow to overall flow
max_flow += path_flow;
}

// Return the overall flow
return max_flow;
}

// Driver program to test above functions
int main()
{
// Let us create a graph shown in the above example
int graph[V][V] = { {0, 16, 13, 0, 0, 0},
{0, 0, 10, 12, 0, 0},
{0, 4, 0, 0, 14, 0},
{0, 0, 9, 0, 0, 20},
{0, 0, 0, 7, 0, 4},
{0, 0, 0, 0, 0, 0}
};

cout

Kết quả (Việt) 1:

#include #include #include #include bằng cách sử dụng không gian tên std;Số đỉnh trong cho đồ thị#define V 6/ * Trả về true Nếu có một đường đi từ nguồn của ' chìm 't' trong đồ thị còn lại. Cũng điền vào phụ huynh [] để lưu trữ đường dẫn * /bool bfs (int rGraph [V] [V], int s, int t, int parent[]){ Tạo ra một mảng truy cập và đánh dấu tất cả đỉnh như không truy cập bool viếng thăm [V]; memset (truy cập, 0, sizeof(visited)); Tạo một danh sách chờ, enqueue nguồn đỉnh và đánh dấu nguồn đỉnh Khi truy cập hàng đợi q; q.Push(s); viếng thăm [s] = true; phụ huynh [s] = -1; Tiêu chuẩn BFS Loop trong khi (! q.empty()) { int u = q.front(); q.pop(); cho (int v = 0; v { Nếu (thăm [v] == false & & rGraph [u] [v] > 0) { q.Push(v); phụ huynh [v] = u; viếng thăm [v] = true; } } } Nếu chúng tôi đạt đến bồn rửa chén ở BFS bắt đầu từ mã nguồn, sau đó trở lại đúng, sai khác trở về (viếng thăm [t] == true);}Trở về dòng chảy tối đa tne s t trong biểu đồ nhất địnhint fordFulkerson (int biểu đồ [V] [V], int s, int t){ int u, v; Tạo một đồ thị dư và điền vào biểu đồ dư với nhất định năng lực trong biểu đồ ban đầu như dư khả năng trong đồ thị dư int rGraph [V] [V]; Đồ thị dư rGraph [i] [j] chỉ ra nơi công suất dư cạnh từ i đến j (nếu có là một cạnh. Nếu rGraph [i] [j] là 0, sau đó không) cho (u = 0; u < V; u ++) cho (v = 0; v < V; v ++) rGraph [u] [v] = biểu đồ [u] [v]; phụ huynh int [V]; Mảng này là đầy bởi BFS và để lưu trữ con đường int max_flow = 0; Đó là dòng chảy không ban đầu Tăng cường dòng chảy trong khi tere là đường đi từ nguồn chìm trong khi (bfs (rGraph, s, t, cha mẹ)) { Tìm thấy tối thiểu công suất dư edhes dọc theo các con đường đầy bởi BFS. Hoặc chúng tôi có thể nói tìm dòng chảy tối đa thông qua con đường tìm thấy. int path_flow = INT_MAX; cho (v = t; v! = s; v=parent[v]) { u = cha mẹ [v]; path_flow = min (path_flow, rGraph[u][v]); } Cập nhật các năng lực còn lại của các cạnh và đảo ngược cạnh dọc theo con đường cho (v = t; v! = s; v=parent[v]) { u = cha mẹ [v]; rGraph [u] [v]-= path_flow; rGraph [v] [u] = path_flow; } Thêm đường chảy vào lưu lượng tổng thể max_flow = path_flow; } Trở về dòng chảy tổng thể trở lại max_flow;}Điều khiển chương trình để thử nghiệm trên chức năngint main(){ Hãy để chúng tôi tạo ra một biểu đồ hiển thị trong ví dụ trên đồ thị int [V] [V] = {{0, 16, 13, 0, 0, 0}, {0, 0, 10, 12, 0, 0}, {0, 4, 0, 0, 14, 0}, {0, 0, 9, 0, 0, 20}, {0, 0, 0, 7, 0, 4}, {0, 0, 0, 0, 0, 0} }; cout << "dòng chảy tối đa có thể là" << fordFulkerson (đồ thị, 0, 5); Return 0;}

Kết quả (Việt) 2:

#include
#include
#include
#include
using namespace std; // Số các đỉnh trong đồ thị cho #define V 6 / * Trả về true nếu có một đường đi từ nguồn 's' chìm 't' trong đồ thị còn lại. Cũng đầy cha mẹ [] để lưu trữ đường dẫn * / bool BFS (int rGraph [V] [V], int s, int t, int cha mẹ []) { // Tạo một mảng đến thăm và đánh dấu tất cả các đỉnh như không truy cập bool thăm [V]; memset (truy cập, 0, sizeof (truy cập)); // Tạo một hàng đợi, đỉnh nguồn enqueue và đánh dấu đỉnh nguồn // như thăm hàng đợi














q;
q.push (s);
thăm [s] = true;
cha mẹ [s] = -1; // Chuẩn BFS vòng while (q.empty ()) { int u = q.front (); q. pop (); for (int v = 0; v







{
If (viếng thăm [v] == false && rGraph [u] [v]> 0)
{
q.push (v);
cha mẹ [v] = u;
thăm [v] = true;
}
}
} // Nếu chúng tôi bồn rửa đạt trong BFS bắt đầu từ mã nguồn, sau đó trở về // true, khác giả trở lại (đến thăm [t] == true); } // trả TNE lưu lượng tối đa từ s đến t trong đồ thị cho int fordFulkerson (int đồ thị [V] [V], int s, int t) { int u, v; // Tạo một biểu đồ còn lại và điền vào biểu đồ còn lại với // năng lực đưa ra trong đồ thị ban đầu là năng lực dư // trong dư đồ int rGraph [V] [ V]; // Dư đồ nơi rGraph [i] [j] chỉ ra // suất còn lại của cạnh từ i tới j (nếu có // là một cạnh. Nếu rGraph [i] [j] là 0, sau đó không có) cho ( u = 0; u <V; u ++) for (v = 0; v <V; v ++) rGraph [u] [v] = đồ thị [u] [v]; int cha mẹ [V]; // Mảng này được lấp đầy bởi BFS và để lưu trữ đường int max_flow = 0; // Không có dòng chảy ban đầu // Tăng thêm dòng chảy trong khi tere là đường đi từ nguồn chìm trong khi (BFS (rGraph, s, t, mẹ)) { // Tìm công suất dư tối thiểu của edhes dọc // con đường lấp đầy bởi BFS. Hoặc chúng ta có thể nói rằng tìm thấy lưu lượng tối đa // thông qua con đường được tìm thấy. Int path_flow = INT_MAX; for (v = t;! V = s; v = cha mẹ [v]) { u = cha mẹ [v]; path_flow = min ( path_flow, rGraph [u] [v]); } // cập nhật dung lượng còn lại của các cạnh và đảo ngược các cạnh // dọc theo con đường cho (v = t;! v = s; v = cha mẹ [v]) { u = mẹ [v]; rGraph [u] [v] - = path_flow; rGraph [v] [u] + = path_flow; } // Thêm dòng đường dẫn đến dòng chảy chung max_flow + = path_flow; } // Return tổng dòng chảy max_flow trở lại; } // chương trình điều khiển để kiểm tra trên các chức năng int main () { // Hãy để chúng tôi tạo ra một biểu đồ thể hiện trong ví dụ trên int đồ thị [V] [V] = {{0, 16, 13, 0, 0, 0}, {0, 0, 10, 12, 0, 0}, {0, 4, 0, 0, 14, 0}, {0, 0, 9, 0, 0, 20}, {0, 0, 0, 7 , 0, 4}, {0, 0, 0, 0, 0, 0} }; cout << "dòng chảy tối đa có thể là" << fordFulkerson (đồ thị, 0, 5); return 0; }