Find minimum s-t cut in a flow network - GeeksforGeeks
In a flow network, an s-t cut is a cut that requires the source 's' and the sink 't' to be in different subsets, and it consists of edges going from the source's side to the sink's side. The capacity of an s-t cut is defined by the sum of capacity of each edge in the cut-set.
The problem discussed here is to find minimum capacity s-t cut of the given network. Expected output is all edges of the minimum cut.
The max-flow min-cut theorem states that in a flow network, the amount of maximum flow is equal to capacity of the minimum cut.
https://github.com/pjfitzgibbons/coursera-algorithms-java/blob/master/lib/FordFulkerson.java
http://algs4.cs.princeton.edu/64maxflow/FordFulkerson.java.html
https://www.youtube.com/watch?v=oWjXF_SztWI
Also check: http://massivealgorithms.blogspot.com/2014/09/ford-fulkerson-algorithm-for-maximum.html
Read full article from Find minimum s-t cut in a flow network - GeeksforGeeks
In a flow network, an s-t cut is a cut that requires the source 's' and the sink 't' to be in different subsets, and it consists of edges going from the source's side to the sink's side. The capacity of an s-t cut is defined by the sum of capacity of each edge in the cut-set.
The problem discussed here is to find minimum capacity s-t cut of the given network. Expected output is all edges of the minimum cut.
The max-flow min-cut theorem states that in a flow network, the amount of maximum flow is equal to capacity of the minimum cut.
the max-flow min-cut theorem states that in a flow network, the maximum amount of flow passing from thesource to the sink is equal to the minimum capacity that, when removed in a specific way from the network, causes the situation that no flow can pass from the source to the sink.
The max-flow min-cut theorem is a special case of the duality theorem for linear programs and can be used to derive Menger's theorem and the König–Egerváry theorem.
A cut is a bottleneck: any total flow through the network must all pass through the bottleneck at once.
The bottle might have a wide part and a narrow part. The total flow must pass through the wide part and the narrow part. It is limited by the narrow part, not by the wide part, because the wide part is wide and can accommodate the flow into or out of the narrow part.
Overall, total flow through the bottle will be constrained by the total flow that can pass through the narrowest bottleneck.
So to find the maximum possible flow, you find the narrowest bottleneck in the bottle, which is the minimum cut.
From Ford-Fulkerson, we get capacity of minimum cut. How to print all edges that form the minimum cut? The idea is to use residual graph.
Following are steps to print all edges of minimum cut.
1) Run Ford-Fulkerson algorithm and consider the final residual graph.
2) Find the set of vertices that are reachable from source in the residual graph.
3) All edges which are from a reachable vertex to non-reachable vertex are minimum cut edges. Print all such edges.
/* Returns true if there is a path from source 's' to sink 't' in residual graph. Also fills parent[] to store the path */int 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 <int> 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<V; v++) { if (visited[v]==false && rGraph[u][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);}// A DFS based function to find all reachable vertices from s. The function// marks visited[i] as true if i is reachable from s. The initial values in// visited[] must be false. We can also use BFS to find reachable verticesvoid dfs(int rGraph[V][V], int s, bool visited[]){ visited[s] = true; for (int i = 0; i < V; i++) if (rGraph[s][i] && !visited[i]) dfs(rGraph, i, visited);}// Prints the minimum s-t cutvoid minCut(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]; // rGraph[i][j] indicates residual capacity of edge i-j 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 // 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; } } // Flow is maximum now, find vertices reachable from s bool visited[V]; memset(visited, false, sizeof(visited)); dfs(rGraph, s, visited); // Print all edges that are from a reachable vertex to // non-reachable vertex in the original graph for (int i = 0; i < V; i++) for (int j = 0; j < V; j++) if (visited[i] && !visited[j] && graph[i][j]) cout << i << " - " << j << endl; return;}https://github.com/pjfitzgibbons/coursera-algorithms-java/blob/master/lib/FordFulkerson.java
http://algs4.cs.princeton.edu/64maxflow/FordFulkerson.java.html
https://www.youtube.com/watch?v=oWjXF_SztWI
Also check: http://massivealgorithms.blogspot.com/2014/09/ford-fulkerson-algorithm-for-maximum.html
Read full article from Find minimum s-t cut in a flow network - GeeksforGeeks
