 Open in App
Not now

# Minimum number of edges between two vertices of a Graph

• Difficulty Level : Easy
• Last Updated : 26 Aug, 2022

You are given an undirected graph G(V, E) with N vertices and M edges. We need to find the minimum number of edges between a given pair of vertices (u, v).

Examples:

Input: For given graph G. Find minimum number of edges between (1, 5). Output: 2
Explanation: (1, 2) and (2, 5) are the only edges resulting into shortest path between 1 and 5.

The idea is to perform BFS from one of given input vertex(u). At the time of BFS maintain an array of distance[n] and initialize it to zero for all vertices. Now, suppose during BFS, vertex x is popped from queue and we are pushing all adjacent non-visited vertices(i) back into queue at the same time we should update distance[i] = distance[x] + 1;
Finally, distance[v] gives the minimum number of edges between u and v.

Algorithm:

```int minEdgeBFS(int u, int v, int n)
{
// visited[n] for keeping track of visited
// node in BFS
bool visited[n] = {0};

// Initialize distances as 0
int distance[n] = {0};

// queue to do BFS.
queue  Q;
distance[u] = 0;

Q.push(u);
visited[u] = true;
while (!Q.empty())
{
int x = Q.front();
Q.pop();

for (int i=0; i<edges[x].size(); i++)
{
if (visited[edges[x][i]])
continue;

// update distance for i
distance[edges[x][i]] = distance[x] + 1;
Q.push(edges[x][i]);
visited[edges[x][i]] = 1;
}
}
return distance[v];
}```

Implementation:

## C++

 `// C++ program to find minimum edge` `// between given two vertex of Graph` `#include` `using` `namespace` `std;`   `// function for finding minimum no. of edge` `// using BFS` `int` `minEdgeBFS(vector <``int``> edges[], ``int` `u,` `                              ``int` `v, ``int` `n)` `{` `    ``// visited[n] for keeping track of visited` `    ``// node in BFS` `    ``vector<``bool``> visited(n, 0);`   `    ``// Initialize distances as 0` `    ``vector<``int``> distance(n, 0);`   `    ``// queue to do BFS.` `    ``queue <``int``> Q;` `    ``distance[u] = 0;`   `    ``Q.push(u);` `    ``visited[u] = ``true``;` `    ``while` `(!Q.empty())` `    ``{` `        ``int` `x = Q.front();` `        ``Q.pop();`   `        ``for` `(``int` `i=0; i edges[], ``int` `u, ``int` `v)` `{` `   ``edges[u].push_back(v);` `   ``edges[v].push_back(u);` `}`   `// Driver function` `int` `main()` `{` `    ``// To store adjacency list of graph` `    ``int` `n = 9;` `    ``vector <``int``> edges;` `    ``addEdge(edges, 0, 1);` `    ``addEdge(edges, 0, 7);` `    ``addEdge(edges, 1, 7);` `    ``addEdge(edges, 1, 2);` `    ``addEdge(edges, 2, 3);` `    ``addEdge(edges, 2, 5);` `    ``addEdge(edges, 2, 8);` `    ``addEdge(edges, 3, 4);` `    ``addEdge(edges, 3, 5);` `    ``addEdge(edges, 4, 5);` `    ``addEdge(edges, 5, 6);` `    ``addEdge(edges, 6, 7);` `    ``addEdge(edges, 7, 8);` `    ``int` `u = 0;` `    ``int` `v = 5;` `    ``cout << minEdgeBFS(edges, u, v, n);` `    ``return` `0;` `}`

## Java

 `// Java program to find minimum edge` `// between given two vertex of Graph`   `import` `java.util.LinkedList;` `import` `java.util.Queue;` `import` `java.util.Vector;`   `class` `Test` `{` `    ``// Method for finding minimum no. of edge` `    ``// using BFS` `    ``static` `int` `minEdgeBFS(Vector edges[], ``int` `u,` `                                  ``int` `v, ``int` `n)` `    ``{` `        ``// visited[n] for keeping track of visited` `        ``// node in BFS` `        ``Vector visited = ``new` `Vector(n);` `        `  `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``visited.addElement(``false``);` `        ``}` `     `  `        ``// Initialize distances as 0` `        ``Vector distance = ``new` `Vector(n);` `        `  `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``distance.addElement(``0``);` `        ``}` `     `  `        ``// queue to do BFS.` `        ``Queue Q = ``new` `LinkedList<>();` `        ``distance.setElementAt(``0``, u);` `     `  `        ``Q.add(u);` `        ``visited.setElementAt(``true``, u);` `        ``while` `(!Q.isEmpty())` `        ``{` `            ``int` `x = Q.peek();` `            ``Q.poll();` `     `  `            ``for` `(``int` `i=``0``; i edges[], ``int` `u, ``int` `v)` `    ``{` `       ``edges[u].add(v);` `       ``edges[v].add(u);` `    ``}`   `    ``// Driver method` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``// To store adjacency list of graph` `        ``int` `n = ``9``;` `        ``Vector edges[] = ``new` `Vector[``9``];` `        `  `        ``for` `(``int` `i = ``0``; i < edges.length; i++) {` `            ``edges[i] = ``new` `Vector<>();` `        ``}` `        `  `        ``addEdge(edges, ``0``, ``1``);` `        ``addEdge(edges, ``0``, ``7``);` `        ``addEdge(edges, ``1``, ``7``);` `        ``addEdge(edges, ``1``, ``2``);` `        ``addEdge(edges, ``2``, ``3``);` `        ``addEdge(edges, ``2``, ``5``);` `        ``addEdge(edges, ``2``, ``8``);` `        ``addEdge(edges, ``3``, ``4``);` `        ``addEdge(edges, ``3``, ``5``);` `        ``addEdge(edges, ``4``, ``5``);` `        ``addEdge(edges, ``5``, ``6``);` `        ``addEdge(edges, ``6``, ``7``);` `        ``addEdge(edges, ``7``, ``8``);` `        ``int` `u = ``0``;` `        ``int` `v = ``5``;` `        ``System.out.println(minEdgeBFS(edges, u, v, n));` `    ``}` `}` `// This code is contributed by Gaurav Miglani`

## Python3

 `# Python3 program to find minimum edge ` `# between given two vertex of Graph` `import` `queue `   `# function for finding minimum ` `# no. of edge using BFS ` `def` `minEdgeBFS(edges, u, v, n):` `    `  `    ``# visited[n] for keeping track ` `    ``# of visited node in BFS ` `    ``visited ``=` `[``0``] ``*` `n `   `    ``# Initialize distances as 0 ` `    ``distance ``=` `[``0``] ``*` `n`   `    ``# queue to do BFS. ` `    ``Q ``=` `queue.Queue()` `    ``distance[u] ``=` `0`   `    ``Q.put(u) ` `    ``visited[u] ``=` `True` `    ``while` `(``not` `Q.empty()):` `        ``x ``=` `Q.get() ` `        `  `        ``for` `i ``in` `range``(``len``(edges[x])):` `            ``if` `(visited[edges[x][i]]):` `                ``continue`   `            ``# update distance for i ` `            ``distance[edges[x][i]] ``=` `distance[x] ``+` `1` `            ``Q.put(edges[x][i]) ` `            ``visited[edges[x][i]] ``=` `1` `    ``return` `distance[v]`   `# function for addition of edge ` `def` `addEdge(edges, u, v):` `    ``edges[u].append(v) ` `    ``edges[v].append(u)`   `# Driver  Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# To store adjacency list of graph ` `    ``n ``=` `9` `    ``edges ``=` `[[] ``for` `i ``in` `range``(n)]` `    ``addEdge(edges, ``0``, ``1``) ` `    ``addEdge(edges, ``0``, ``7``) ` `    ``addEdge(edges, ``1``, ``7``) ` `    ``addEdge(edges, ``1``, ``2``) ` `    ``addEdge(edges, ``2``, ``3``) ` `    ``addEdge(edges, ``2``, ``5``) ` `    ``addEdge(edges, ``2``, ``8``) ` `    ``addEdge(edges, ``3``, ``4``) ` `    ``addEdge(edges, ``3``, ``5``) ` `    ``addEdge(edges, ``4``, ``5``) ` `    ``addEdge(edges, ``5``, ``6``) ` `    ``addEdge(edges, ``6``, ``7``) ` `    ``addEdge(edges, ``7``, ``8``) ` `    ``u ``=` `0` `    ``v ``=` `5` `    ``print``(minEdgeBFS(edges, u, v, n))`   `# This code is contributed by PranchalK`

## C#

 `// C# program to find minimum edge ` `// between given two vertex of Graph ` `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `class` `GFG{` `    `  `// Method for finding minimum no. of edge ` `// using BFS ` `static` `int` `minEdgeBFS(ArrayList []edges, ``int` `u,` `                                  ``int` `v, ``int` `n) ` `{ ` `    `  `    ``// visited[n] for keeping track of visited ` `    ``// node in BFS ` `    ``ArrayList visited = ``new` `ArrayList(); ` `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        ``visited.Add(``false``); ` `    ``} `   `    ``// Initialize distances as 0 ` `    ``ArrayList distance = ``new` `ArrayList(); ` `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        ``distance.Add(0); ` `    ``} `   `    ``// queue to do BFS. ` `    ``Queue Q = ``new` `Queue(); ` `    `  `    ``distance[u] = 0; `   `    ``Q.Enqueue(u); ` `    `  `    ``visited[u] = ``true``;` `    `  `    ``while` `(Q.Count != 0) ` `    ``{ ` `        ``int` `x = (``int``)Q.Dequeue(); `   `        ``for``(``int` `i = 0; i < edges[x].Count; i++) ` `        ``{ ` `            ``if` `((``bool``)visited[(``int``)edges[x][i]]) ` `                ``continue``; ` `                `  `            ``// Update distance for i ` `            ``distance[(``int``)edges[x][i]] = (``int``)distance[x] + 1; ` `            ``Q.Enqueue((``int``)edges[x][i]); ` `            ``visited[(``int``)edges[x][i]] = ``true``; ` `        ``} ` `    ``} ` `    ``return` `(``int``)distance[v]; ` `} `   `// Method for addition of edge ` `static` `void` `addEdge(ArrayList []edges, ` `                    ``int` `u, ``int` `v) ` `{ ` `    ``edges[u].Add(v); ` `    ``edges[v].Add(u); ` `} `   `// Driver code` `public` `static` `void` `Main(``string` `[]args) ` `{ ` `    `  `    ``// To store adjacency list of graph ` `    ``int` `n = 9; ` `    ``ArrayList []edges = ``new` `ArrayList; ` `    `  `    ``for``(``int` `i = 0; i < 9; i++) ` `    ``{` `        ``edges[i] = ``new` `ArrayList(); ` `    ``} ` `    `  `    ``addEdge(edges, 0, 1); ` `    ``addEdge(edges, 0, 7); ` `    ``addEdge(edges, 1, 7); ` `    ``addEdge(edges, 1, 2); ` `    ``addEdge(edges, 2, 3); ` `    ``addEdge(edges, 2, 5); ` `    ``addEdge(edges, 2, 8); ` `    ``addEdge(edges, 3, 4); ` `    ``addEdge(edges, 3, 5); ` `    ``addEdge(edges, 4, 5); ` `    ``addEdge(edges, 5, 6); ` `    ``addEdge(edges, 6, 7); ` `    ``addEdge(edges, 7, 8); ` `    `  `    ``int` `u = 0; ` `    ``int` `v = 5; ` `    `  `    ``Console.Write(minEdgeBFS(edges, u, v, n)); ` `} ` `} `   `// This code is contributed by rutvik_56`

## Javascript

 ``

Output

`3`

Time Complexity: O(V + E), for performing Breadth-First Search.
Auxiliary Space: O(V), as V vertices can be present in the queue in the worst case.