Scribd
Upload
167 views

Min-Cut-In-Directed-Graph C++ Code

This C++ program finds the minimum cut in a flow network using the Ford-Fulkerson algorithm. It takes a graph with capacities on each edge as input, constructs a residual graph to track remaining capacities on edges, and repeatedly uses BFS to find augmenting paths from the source to sink to push flow along. It increments the flow along each path until no more paths exist. Finally, it uses DFS to find the vertices reachable from the source in the residual graph and prints the cut edges between reachable and unreachable vertices.

Uploaded by

Akshara P S
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
167 views

Min-Cut-In-Directed-Graph C++ Code

This C++ program finds the minimum cut in a flow network using the Ford-Fulkerson algorithm. It takes a graph with capacities on each edge as input, constructs a residual graph to track remaining capacities on edges, and repeatedly uses BFS to find augmenting paths from the source to sink to push flow along. It increments the flow along each path until no more paths exist. Finally, it uses DFS to find the vertices reachable from the source in the residual graph and prints the cut edges between reachable and unreachable vertices.

Uploaded by

Akshara P S
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 3

// C++ program for finding minimum cut using Ford-Fulkerson

#include<bits/stdc++.h>
using namespace std;

/* 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(vector< vector<int> >&rGraph, int 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 vertices
void dfs(vector< vector<int> >& rGraph, int V, int s, bool visited[])
{
visited[s] = true;
for (int i = 0; i < V; i++)
if (rGraph[s][i] && !visited[i])
dfs(rGraph,V, i, visited);
}

// Prints the minimum s-t cut


void minCut( vector< vector<int> > graph, int 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
vector< vector<int> >rGraph(V,vector<int>(V,0));// 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 there is a path from source to sink


while (bfs(rGraph, V, 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, V, 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;
}

// Driver program to test above functions


int main()
{
// Let us create a graph shown in the above example
int N,s,t;
printf("\nEnter no: of vertices: ");
scanf("%d",&N);
printf("\nEnter matrix:\n");

vector< vector<int> >G(N, vector<int>(N,0));


for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
scanf("%d",&G[i][j]);
}
}
printf("\nEnter source and sink: ");
scanf("%d%d",&s,&t);
minCut(G,N,s,t);

return 0;
}

You might also like