 Open in App
Not now

# Minimum edges to be removed from given undirected graph to remove any existing path between nodes A and B

• Difficulty Level : Hard
• Last Updated : 14 Dec, 2021

Given two integers N and M denoting the number of vertices and edges in the graph and array edges[][] of size M, denoting an edge between edges[i] and edges[i], the task is to find the minimum edges directly connected with node B that must be removed such that there exist no path between vertex A and B.

Examples:

Input: N = 4, A = 3, B = 2, edges[][] = {{3, 1}, {3, 4}, {1, 2}, {4, 2}}
Output: 2
Explanation: The edges at index 2 and 3 i.e., {1, 2} and {4, 2} must be removed as they both are in the path from vertex A to vertex B.

Input: N = 6, A = 1, B = 6, edges[][] = {{1, 2}, {1, 6}, {2, 6}, {1, 4}, {4, 6}, {4, 3}, {2, 4}}
Output: 3

Approach: The given problem can be solved using a Depth-first search algorithm. It can be observed that all the edges associated with the ending vertex B and exist in any path from starting node A and ending at node B must be removed. Hence, perform a dfs starting from node A and maintain all the visited vertices from it. Follow the steps below to solve the problem:

• Create an adjacency matrix g[][] which stores the edges between two nodes.
• Initialize an array v[], to mark the node which can be reached from node A.
• Create a variable cnt, which stores the count of nodes needed to be removed. Initially, cnt = 0.
• Iterate through all the nodes and if it is reachable from A and is directly connected with B, increment the value of cnt.
• The value stored in cnt is the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function for Depth first Search``void` `dfs(``int` `s, vector > g,``         ``vector<``int``>& v)``{``    ``for` `(``auto` `i : g[s]) {` `        ``// If current vertex is``        ``// not visited yet``        ``if` `(!v[i]) {``            ``v[i] = 1;` `            ``// Recursive call for``            ``// dfs function``            ``dfs(i, g, v);``        ``}``    ``}``}` `// Function to find the out the minimum``// number of edges that must be removed``int` `deleteEdges(``int` `n, ``int` `m, ``int` `a, ``int` `b,``                ``vector > edges)``{``    ``// Creating Adjacency Matrix``    ``vector > g(n, vector<``int``>());``    ``for` `(``int` `i = 0; i < m; i++) {``        ``g[edges[i] - 1].push_back(edges[i] - 1);``        ``g[edges[i] - 1].push_back(edges[i] - 1);``    ``}` `    ``// Vector for marking visited``    ``vector<``int``> v(n, 0);``    ``v[a - 1] = 1;` `    ``// Calling dfs function``    ``dfs(a - 1, g, v);` `    ``// Stores the final count``    ``int` `cnt = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If current node can not``        ``// be visited from node A``        ``if` `(v[i] == 0)``            ``continue``;``        ``for` `(``int` `j = 0; j < g[i].size(); j++) {` `            ``// If a node between current``            ``// node and node b exist``            ``if` `(g[i][j] == b - 1) {``                ``cnt++;``            ``}``        ``}``    ``}` `    ``// Return Answer``    ``return` `cnt;``}` `// Driver Code``int` `main()``{``    ``int` `N = 6;``    ``int` `M = 7;``    ``int` `A = 1;``    ``int` `B = 6;``    ``vector > edges{``        ``{ 1, 2 }, { 5, 2 }, { 2, 4 },``        ``{ 2, 3 }, { 3, 6 }, { 4, 6 }, { 5, 6 }``    ``};` `    ``cout << deleteEdges(N, M, A, B, edges);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function for Depth first Search``static` `void` `dfs(``int` `s, Vector [] g,``         ``int``[] v)``{``    ``for` `(``int` `i : g[s]) {` `        ``// If current vertex is``        ``// not visited yet``        ``if` `(v[i] == ``0``) {``            ``v[i] = ``1``;` `            ``// Recursive call for``            ``// dfs function``            ``dfs(i, g, v);``        ``}``    ``}``}` `// Function to find the out the minimum``// number of edges that must be removed``static` `int` `deleteEdges(``int` `n, ``int` `m, ``int` `a, ``int` `b,``                ``int``[][] edges)``{``  ` `    ``// Creating Adjacency Matrix``    ``Vector []g = ``new` `Vector[n];``    ``for` `(``int` `i = ``0``; i < g.length; i++)``        ``g[i] = ``new` `Vector();``    ``for` `(``int` `i = ``0``; i < m; i++) {``        ``g[edges[i][``0``] - ``1``].add(edges[i][``1``] - ``1``);``        ``g[edges[i][``1``] - ``1``].add(edges[i][``0``] - ``1``);``    ``}` `    ``// Vector for marking visited``    ``int` `[]v = ``new` `int``[n];``    ``v[a - ``1``] = ``1``;` `    ``// Calling dfs function``    ``dfs(a - ``1``, g, v);` `    ``// Stores the final count``    ``int` `cnt = ``0``;` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `        ``// If current node can not``        ``// be visited from node A``        ``if` `(v[i] == ``0``)``            ``continue``;``        ``for` `(``int` `j = ``0``; j < g[i].size(); j++) {` `            ``// If a node between current``            ``// node and node b exist``            ``if` `(g[i].get(j) == b - ``1``) {``                ``cnt++;``            ``}``        ``}``    ``}` `    ``// Return Answer``    ``return` `cnt;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``6``;``    ``int` `M = ``7``;``    ``int` `A = ``1``;``    ``int` `B = ``6``;``    ``int``[][] edges ={``        ``{ ``1``, ``2` `}, { ``5``, ``2` `}, { ``2``, ``4` `},``        ``{ ``2``, ``3` `}, { ``3``, ``6` `}, { ``4``, ``6` `}, { ``5``, ``6` `}``    ``};` `    ``System.out.print(deleteEdges(N, M, A, B, edges));` `}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python program for the above approach` `# Function for Depth first Search``def` `dfs(s, g, v):``    ``for` `i ``in` `g[s]:` `        ``# If current vertex is``        ``# not visited yet``        ``if` `not` `v[i]:``            ``v[i] ``=` `1` `            ``# Recursive call for``            ``# dfs function``            ``dfs(i, g, v)` `# Function to find the out the minimum``# number of edges that must be removed``def` `deleteEdges(n, m, a, b, edges):` `    ``# Creating Adjacency Matrix``    ``g ``=` `[``0``] ``*` `m``    ``for` `i ``in` `range``(``len``(g)):``        ``g[i] ``=` `[]` `    ``for` `i ``in` `range``(m):``        ``g[edges[i][``0``] ``-` `1``].append(edges[i][``1``] ``-` `1``)``        ``g[edges[i][``1``] ``-` `1``].append(edges[i][``0``] ``-` `1``)` `    ``# Vector for marking visited``    ``v ``=` `[``0``] ``*` `n``    ``v[a ``-` `1``] ``=` `1` `    ``# Calling dfs function``    ``dfs(a ``-` `1``, g, v)` `    ``# Stores the final count``    ``cnt ``=` `0` `    ``for` `i ``in` `range``(n):` `        ``# If current node can not``        ``# be visited from node A``        ``if` `(v[i] ``=``=` `0``):``            ``continue` `        ``for` `j ``in` `range``(``len``(g[i])):` `            ``# If a node between current``            ``# node and node b exist``            ``if` `(g[i][j] ``=``=` `b ``-` `1``):``                ``cnt ``+``=` `1` `    ``# Return Answer``    ``return` `cnt` `# Driver Code``N ``=` `6``M ``=` `7``A ``=` `1``B ``=` `6``edges ``=` `[[``1``, ``2``], [``5``, ``2``], [``2``, ``4``],``         ``[``2``, ``3``], [``3``, ``6``], [``4``, ``6``],``         ``[``5``, ``6``]]` `print``(deleteEdges(N, M, A, B, edges))` `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `// Function for Depth first Search``static` `void` `dfs(``int` `s, List<``int``> [] g,``         ``int``[] v)``{``    ``foreach` `(``int` `i ``in` `g[s]) {` `        ``// If current vertex is``        ``// not visited yet``        ``if` `(v[i] == 0) {``            ``v[i] = 1;` `            ``// Recursive call for``            ``// dfs function``            ``dfs(i, g, v);``        ``}``    ``}``}` `// Function to find the out the minimum``// number of edges that must be removed``static` `int` `deleteEdges(``int` `n, ``int` `m, ``int` `a, ``int` `b,``                ``int``[,] edges)``{``  ` `    ``// Creating Adjacency Matrix``    ``List<``int``> []g = ``new` `List<``int``>[n];``    ``for` `(``int` `i = 0; i < g.Length; i++)``        ``g[i] = ``new` `List<``int``>();``    ``for` `(``int` `i = 0; i < m; i++) {``        ``g[edges[i,0] - 1].Add(edges[i,1] - 1);``        ``g[edges[i,1] - 1].Add(edges[i,0] - 1);``    ``}` `    ``// List for marking visited``    ``int` `[]v = ``new` `int``[n];``    ``v[a - 1] = 1;` `    ``// Calling dfs function``    ``dfs(a - 1, g, v);` `    ``// Stores the readonly count``    ``int` `cnt = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If current node can not``        ``// be visited from node A``        ``if` `(v[i] == 0)``            ``continue``;``        ``for` `(``int` `j = 0; j < g[i].Count; j++) {` `            ``// If a node between current``            ``// node and node b exist``            ``if` `(g[i][j] == b - 1) {``                ``cnt++;``            ``}``        ``}``    ``}` `    ``// Return Answer``    ``return` `cnt;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `N = 6;``    ``int` `M = 7;``    ``int` `A = 1;``    ``int` `B = 6;``    ``int``[,] edges ={``        ``{ 1, 2 }, { 5, 2 }, { 2, 4 },``        ``{ 2, 3 }, { 3, 6 }, { 4, 6 }, { 5, 6 }``    ``};` `    ``Console.Write(deleteEdges(N, M, A, B, edges));``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output

`3`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up