Minimum bridges required to be crossed to reach N^th city

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 <bits/stdc++.h>
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<Integer> []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<Integer> 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

<script>

// JavaScript program for the above approach

// Adjacency list to store graph
var g = Array.from(Array(10001), ()=>new Array());;

// Stores info about visited nodes
var vis = Array(10001).fill(false);

// Stores distance of nodes
// from the source node
var dist = Array(10001).fill(0);

// Function for BFS traversal
function BFS(src)
{
    // Stores the nodes
    var 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.length!=0) {

        // Update the current node
        var curr = q[0];

        // Pop the node after
        // update by curr
        q.shift();

        // Traverse every node of
        // the adjacency list
        g[curr].forEach(child => {
              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
function buildGraph(M, arr)
{
    for (var i = 0; i < M; i++) {
        g[arr[i][0]].push(arr[i][1]);
        g[arr[i][1]].push(arr[i][0]);
    }
}

// Function to print the distance between from
// city 1 to city N
function shortestDistance(N, M, arr)
{
    // Build graph
    buildGraph(M, arr);

    // Perform BFS traversal
    BFS(1);

    // Print the shortest distance
    document.write( dist[N]);
}

// Driver Code
// Given number of Nodes & Edges
var N = 3, M = 2;

// Given pairs of edges
var arr = [ [ 1, 2 ], [ 2, 3 ] ];

// Function Call
shortestDistance(N, M, arr);


</script>

Output:

2

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