# Minimum bridges required to be crossed to reach Nth city

• Difficulty Level : Hard
• Last Updated : 27 May, 2021

Given an integer N denoting the number of connected cities ( numbered from 1 to N ) and a 2D array arr[][] consisting of pairs connected to each other by bidirectional bridges. The task is to find the minimum the number of bridges required to be crossed to reach the city N from the city 1.

Examples:

Input: N = 3, M = 2, arr[][] = {{1, 2}, {2, 3}}

Output: 2
Explanation:
To reach Node 2 from Node 1, 1 bridge is required to be crossed.
To reach Node 3 from Node 2, 1 bridge is required to be crossed.
Hence, 2 bridges are required to be connected.

Input: N = 4, M = 3, arr[][] = {{1, 2}, {2, 3}, {2, 4}}
Output: 2

Approach: Follow the steps below to solve the problem:

• Initialize an adjacency list to build and store the Graph nodes.
• Initialize an array, say vis[] of size N to mark the visited nodes and another array, say dist[] of size N, to store the minimum distance from city 1.
• Perform BFS and using the concept of Single Source Shortest Path to traverse the graph and store the minimum number of bridges required to be crossed to reach every city from city 1.
• Print the value of dist[N] as the minimum distance to reach city N from city 1.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Adjacency list to store graph``vector<``int``> g[10001];` `// Stores info about visited nodes``int` `vis[10001];` `// Stores distance of nodes``// from the source node``int` `dist[10001];` `// Function for BFS traversal``void` `BFS(``int` `src)``{``    ``// Stores the nodes``    ``queue<``int``> q;` `    ``// Push the source node``    ``q.push(src);` `    ``// Mark the pushed node visited``    ``vis[src] = 1;` `    ``// Source node is always at dist 0``    ``dist[src] = 0;` `    ``// Iterate until queue is not empty``    ``while` `(!q.empty()) {` `        ``// Update the current node``        ``int` `curr = q.front();` `        ``// Pop the node after``        ``// update by curr``        ``q.pop();` `        ``// Traverse every node of``        ``// the adjacency list``        ``for` `(``auto` `child : g[curr]) {``            ``if` `(vis[child] == 0) {` `                ``// Push the child node``                ``// if its not visited``                ``q.push(child);` `                ``// Update the distance of next level``                ``// nodes as it can be accessed by the``                ``// previous node in BFS``                ``dist[child] = dist[curr] + 1;` `                ``// Mark the child node as visited``                ``vis[child] = 1;``            ``}``        ``}``    ``}``}` `// Function to build the graph``void` `buildGraph(``int` `M, ``int` `arr[][2])``{``    ``for` `(``int` `i = 0; i < M; i++) {``        ``g[arr[i][0]].push_back(arr[i][1]);``        ``g[arr[i][1]].push_back(arr[i][0]);``    ``}``}` `// Function to print the distance between from``// city 1 to city N``void` `shortestDistance(``int` `N, ``int` `M, ``int` `arr[][2])``{``    ``// Build graph``    ``buildGraph(M, arr);` `    ``// Perform BFS traversal``    ``BFS(1);` `    ``// Print the shortest distance``    ``cout << dist[N];``}` `// Driver Code``int` `main()``{``    ``// Given number of Nodes & Edges``    ``int` `N = 3, M = 2;` `    ``// Given pairs of edges``    ``int` `arr[][2] = { { 1, 2 }, { 2, 3 } };` `    ``// Function Call``    ``shortestDistance(N, M, arr);``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG``{` `// Adjacency list to store graph``static` `Vector []g = ``new` `Vector[``10001``];` `// Stores info about visited nodes``static` `int` `[]vis = ``new` `int``[``10001``];` `// Stores distance of nodes``// from the source node``static` `int` `[]dist = ``new` `int``[``10001``];``static` `{``    ``for``(``int` `i = ``0``; i < g.length; i++)``    ``{``        ``g[i] = ``new` `Vector<>();``    ``}``}``  ` `// Function for BFS traversal``static` `void` `BFS(``int` `src)``{``  ` `    ``// Stores the nodes``    ``Queue q = ``new` `LinkedList<>();` `    ``// Push the source node``    ``q.add(src);` `    ``// Mark the pushed node visited``    ``vis[src] = ``1``;` `    ``// Source node is always at dist 0``    ``dist[src] = ``0``;` `    ``// Iterate until queue is not empty``    ``while` `(!q.isEmpty()) {` `        ``// Update the current node``        ``int` `curr = q.peek();` `        ``// Pop the node after``        ``// update by curr``        ``q.remove();` `        ``// Traverse every node of``        ``// the adjacency list``        ``for` `(``int` `child : g[curr]) {``            ``if` `(vis[child] == ``0``) {` `                ``// Push the child node``                ``// if its not visited``                ``q.add(child);` `                ``// Update the distance of next level``                ``// nodes as it can be accessed by the``                ``// previous node in BFS``                ``dist[child] = dist[curr] + ``1``;` `                ``// Mark the child node as visited``                ``vis[child] = ``1``;``            ``}``        ``}``    ``}``}` `// Function to build the graph``static` `void` `buildGraph(``int` `M, ``int` `arr[][])``{``    ``for` `(``int` `i = ``0``; i < M; i++) {``        ``g[arr[i][``0``]].add(arr[i][``1``]);``        ``g[arr[i][``1``]].add(arr[i][``0``]);``    ``}``}` `// Function to print the distance between from``// city 1 to city N``static` `void` `shortestDistance(``int` `N, ``int` `M, ``int` `arr[][])``{``  ` `    ``// Build graph``    ``buildGraph(M, arr);` `    ``// Perform BFS traversal``    ``BFS(``1``);` `    ``// Print the shortest distance``    ``System.out.print(dist[N]);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ` `    ``// Given number of Nodes & Edges``    ``int` `N = ``3``, M = ``2``;` `    ``// Given pairs of edges``    ``int` `arr[][] = { { ``1``, ``2` `}, { ``2``, ``3` `} };` `    ``// Function Call``    ``shortestDistance(N, M, arr);``}``}` `// This code is contributed by shikhasingrajput.`

## Python3

 `# Python 3 program for the above approach` `# Adjacency list to store graph``g ``=` `[[] ``for` `i ``in` `range``(``10001``)]` `# Stores info about visited nodes``vis ``=` `[``0` `for` `i ``in` `range``(``10001``)]` `# Stores distance of nodes``# from the source node``dist ``=` `[``0` `for` `i ``in` `range``(``10001``)]` `# Function for BFS traversal``def` `BFS(src):``    ``global` `vis``    ``global` `dist``    ``global` `g``    ` `    ``# Stores the nodes``    ``q ``=` `[]` `    ``# Push the source node``    ``q.append(src)` `    ``# Mark the pushed node visited``    ``vis[src] ``=` `1` `    ``# Source node is always at dist 0``    ``dist[src] ``=` `0` `    ``# Iterate until queue is not empty``    ``while` `(``len``(q)):``      ` `        ``# Update the current node``        ``curr ``=` `q[``0``]` `        ``# Pop the node after``        ``# update by curr``        ``q.remove(q[``0``])` `        ``# Traverse every node of``        ``# the adjacency list``        ``for` `child ``in` `g[curr]:``            ``if` `(vis[child] ``=``=` `0``):``              ` `                ``# Push the child node``                ``# if its not visited``                ``q.append(child)` `                ``# Update the distance of next level``                ``# nodes as it can be accessed by the``                ``# previous node in BFS``                ``dist[child] ``=` `dist[curr] ``+` `1` `                ``# Mark the child node as visited``                ``vis[child] ``=` `1` `# Function to build the graph``def` `buildGraph(M, arr):``    ``global` `g``    ``for` `i ``in` `range``(M):``        ``g[arr[i][``0``]].append(arr[i][``1``])``        ``g[arr[i][``1``]].append(arr[i][``0``])` `# Function to print the distance between from``# city 1 to city N``def` `shortestDistance(N, M, arr):``  ` `    ``# Build graph``    ``buildGraph(M, arr)` `    ``# Perform BFS traversal``    ``BFS(``1``)``    ` `    ``# Print the shortest distance``    ``print``(dist[N])` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given number of Nodes & Edges``    ``N ``=` `3``    ``M ``=` `2` `    ``# Given pairs of edges``    ``arr ``=`  `[[``1``, ``2``], [``2``, ``3``]]` `    ``# Function Call``    ``shortestDistance(N, M, arr)``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{` `// Adjacency list to store graph``static` `List<``int``> []g = ``new` `List<``int``>[10001];` `// Stores info about visited nodes``static` `int` `[]vis = ``new` `int``[10001];` `// Stores distance of nodes``// from the source node``static` `int` `[]dist = ``new` `int``[10001];` `  ` `// Function for BFS traversal``static` `void` `BFS(``int` `src)``{``  ` `    ``// Stores the nodes``    ``Queue<``int``> q = ``new` `Queue<``int``>();` `    ``// Push the source node``    ``q.Enqueue(src);` `    ``// Mark the pushed node visited``    ``vis[src] = 1;` `    ``// Source node is always at dist 0``    ``dist[src] = 0;` `    ``// Iterate until queue is not empty``    ``while` `(q.Count!=0) {` `        ``// Update the current node``        ``int` `curr = q.Peek();` `        ``// Pop the node after``        ``// update by curr``        ``q.Dequeue();` `        ``// Traverse every node of``        ``// the adjacency list``        ``foreach` `(``int` `child ``in` `g[curr]) {``            ``if` `(vis[child] == 0) {` `                ``// Push the child node``                ``// if its not visited``                ``q.Enqueue(child);` `                ``// Update the distance of next level``                ``// nodes as it can be accessed by the``                ``// previous node in BFS``                ``dist[child] = dist[curr] + 1;` `                ``// Mark the child node as visited``                ``vis[child] = 1;``            ``}``        ``}``    ``}``}` `// Function to build the graph``static` `void` `buildGraph(``int` `M, ``int` `[,]arr)``{``    ``for` `(``int` `i = 0; i < M; i++) {``        ``g[arr[i,0]].Add(arr[i,1]);``        ``g[arr[i,1]].Add(arr[i,0]);``    ``}``}` `// Function to print the distance between from``// city 1 to city N``static` `void` `shortestDistance(``int` `N, ``int` `M, ``int` `[,]arr)``{``  ` `    ``// Build graph``    ``buildGraph(M, arr);` `    ``// Perform BFS traversal``    ``BFS(1);` `    ``// Print the shortest distance``    ``Console.Write(dist[N]);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ` `    ``// Given number of Nodes & Edges``    ``int` `N = 3, M = 2;` `    ``// Given pairs of edges``    ``int` `[,]arr = { { 1, 2 }, { 2, 3 } };` `    ``for``(``int` `i = 0; i < g.Length; i++)``    ``{``        ``g[i] = ``new` `List<``int``>();``    ``}``    ``// Function Call``    ``shortestDistance(N, M, arr);``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up