GeeksforGeeks App
Open App
Browser
Continue

# Minimum length paths between 1 to N including each node

Given an undirected graph consisting of N nodes and M edges, the task is to find the minimum length of the path from Node 1 to Node N passing from every possible node of the given graph. If there doesn’t exist any such path, then print -1.

Note: The path can pass through a node any number of times.

Examples:

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

Minimum path length from 1 to 4, passing from 1 is 2.
Minimum path length from 1 to 4, passing from 2 is 2.
Minimum path length from 1 to 4, passing from 3 is 3.
Minimum path length from 1 to 4, passing from 4 is 2.

Input: N = 5, M = 7, edges[][] = {{1, 2}, {1, 4}, {2, 3}, {2, 5}, {4, 3}, {4, 5}, {1, 5}}
Output: 1 2 4 2 1

Approach: The idea is to run two BFS, one from node 1 excluding node N and another from node N excluding node 1 to find the minimum distance of all the nodes from 1 and N. The sum of both the minimum distances will be the minimum length of the path from 1 to N including the node. Follow the steps below to solve the problem:

• Initialize a queue, say queue1 to perform BFS from node 1 and a queue queue2 to perform BFS from node N.
• Initialize two arrays, say dist1[] and dist2[] that store the shortest distance by performing BFS1 and BFS2.
• Perform two BFS and perform the following steps in each case:
• Pop from the queue and store node in x and its distance in dis.
• If dist[x] is smaller than dis then continue.
• Traverse the adjacency list of x and for each child y, if dist[y] is greater than dis + 1 then update dist[y] equals dis + 1.
• After populating the two arrays dist1[] and dist2[] in the above steps, iterate over the range [0, N] and if the sum of (dist1[i] + dist2[i]) is greater than 109 then print “-1” as their exists no such path. Otherwise, print the value of (dist1[i] + dist2[i]) as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;``#define ll long long int` `// Function to calculate the distances``// from node 1 to N``void` `minDisIncludingNode(``int` `n, ``int` `m,``                         ``int` `edges[][2])``{``    ``// Vector to store our edges``    ``vector g[10005];` `    ``// Storing the edgees in the Vector``    ``for` `(``int` `i = 0; i < m; i++) {``        ``int` `a = edges[i][0] - 1;``        ``int` `b = edges[i][1] - 1;``        ``g[a].push_back(b);``        ``g[b].push_back(a);``    ``}` `    ``// Initialize queue``    ``queue > q;``    ``q.push({ 0, 0 });``    ``vector<``int``> dist(n, 1e9);``    ``dist[0] = 0;` `    ``// BFS from first node using queue``    ``while` `(!q.empty()) {``        ``auto` `up = q.front();` `        ``// Pop from queue``        ``q.pop();``        ``int` `x = up.first;``        ``int` `lev = up.second;``        ``if` `(lev > dist[x])``            ``continue``;``        ``if` `(x == n - 1)``            ``continue``;` `        ``// Traversing its adjacency list``        ``for` `(ll y : g[x]) {``            ``if` `(dist[y] > lev + 1) {``                ``dist[y] = lev + 1;``                ``q.push({ y, lev + 1 });``            ``}``        ``}``    ``}``    ``// Initialize queue``    ``queue > q1;``    ``q1.push({ n - 1, 0 });``    ``vector<``int``> dist1(n, 1e9);``    ``dist1[n - 1] = 0;` `    ``// BFS from last node using queue``    ``while` `(!q1.empty()) {``        ``auto` `up = q1.front();` `        ``// Pop from queue``        ``q1.pop();``        ``int` `x = up.first;``        ``int` `lev = up.second;``        ``if` `(lev > dist1[x])``            ``continue``;``        ``if` `(x == 0)``            ``continue``;` `        ``// Traversing its adjacency list``        ``for` `(ll y : g[x]) {``            ``if` `(dist1[y] > lev + 1) {``                ``dist1[y] = lev + 1;``                ``q1.push({ y, lev + 1 });``            ``}``        ``}``    ``}` `    ``// Printing the minimum distance``    ``// including node i``    ``for` `(``int` `i = 0; i < n; i++) {``        ``// If not reachable``        ``if` `(dist[i] + dist1[i] > 1e9)``            ``cout << -1 << ``" "``;` `        ``// Path exists``        ``else``            ``cout << dist[i] + dist1[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `n = 5;``    ``int` `m = 7;``    ``int` `edges[m][2]``        ``= { { 1, 2 }, { 1, 4 },``            ``{ 2, 3 }, { 2, 5 },``            ``{ 4, 3 }, { 4, 5 },``            ``{ 1, 5 } };` `    ``// Function Call``    ``minDisIncludingNode(n, m, edges);` `    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main {` `    ``public` `static` `void` `minDisIncludingNode(``int` `n, ``int` `m, ``int``[][] edges) {``        ``// List to store our edges``        ``List[] g = ``new` `ArrayList[``10005``];``        ``for` `(``int` `i = ``0``; i < ``10005``; i++) {``            ``g[i] = ``new` `ArrayList();``        ``}` `        ``// Storing the edges in the List``        ``for` `(``int` `i = ``0``; i < m; i++) {``            ``int` `a = edges[i][``0``] - ``1``;``            ``int` `b = edges[i][``1``] - ``1``;``            ``g[a].add(b);``            ``g[b].add(a);``        ``}` `        ``// Initialize queue``        ``Queue q = ``new` `LinkedList<>();``        ``q.add(``0``);``        ``int``[] dist = ``new` `int``[n];``        ``Arrays.fill(dist, Integer.MAX_VALUE);``        ``dist[``0``] = ``0``;` `        ``// BFS from first node using queue``        ``while` `(!q.isEmpty()) {``            ``int` `x = q.poll();``            ``if` `(x == n - ``1``)``                ``continue``;` `            ``// Traversing its adjacency list``            ``for` `(``int` `y : g[x]) {``                ``if` `(dist[y] > dist[x] + ``1``) {``                    ``dist[y] = dist[x] + ``1``;``                    ``q.add(y);``                ``}``            ``}``        ``}``        ``// Initialize queue``        ``Queue q1 = ``new` `LinkedList<>();``        ``q1.add(n - ``1``);``        ``int``[] dist1 = ``new` `int``[n];``        ``Arrays.fill(dist1, Integer.MAX_VALUE);``        ``dist1[n - ``1``] = ``0``;` `        ``// BFS from last node using queue``        ``while` `(!q1.isEmpty()) {``            ``int` `x = q1.poll();``            ``if` `(x == ``0``)``                ``continue``;` `            ``// Traversing its adjacency list``            ``for` `(``int` `y : g[x]) {``                ``if` `(dist1[y] > dist1[x] + ``1``) {``                    ``dist1[y] = dist1[x] + ``1``;``                    ``q1.add(y);``                ``}``            ``}``        ``}` `        ``// Printing the minimum distance``        ``// including node i``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``// If not reachable``            ``if` `(dist[i] + dist1[i] > Integer.MAX_VALUE)``                ``System.out.print(-``1` `+ ``" "``);` `            ``// Path exists``            ``else``                ``System.out.print(dist[i] + dist1[i] + ``" "``);``        ``}``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``// Given Input``        ``int` `n = ``5``;``        ``int` `m = ``7``;``        ``int``[][] edges = { { ``1``, ``2` `}, { ``1``, ``4` `}, { ``2``, ``3` `},``                          ``{ ``2``, ``5` `}, { ``4``, ``3` `}, { ``4``, ``5` `}, { ``1``, ``5` `} };` `        ``// Function Call``        ``minDisIncludingNode(n, m, edges);``    ``}``}`

## Python3

 `# Python 3 program for the above approach` `# Function to calculate the distances``# from node 1 to N``def` `minDisIncludingNode(n, m, edges):``    ``# Vector to store our edges``    ``g ``=` `[[] ``for` `i ``in` `range``(``10005``)]` `    ``# Storing the edgees in the Vector``    ``for` `i ``in` `range``(m):``        ``a ``=` `edges[i][``0``] ``-` `1``        ``b ``=` `edges[i][``1``] ``-` `1``        ``g[a].append(b)``        ``g[b].append(a)` `    ``# Initialize queue``    ``q ``=` `[]``    ``q.append([``0``, ``0``])``    ``dist ``=` `[``1e9` `for` `i ``in` `range``(n)]``    ``dist[``0``] ``=` `0` `    ``# BFS from first node using queue``    ``while``(``len``(q)>``0``):``        ``up ``=` `q[``0``]` `        ``# Pop from queue``        ``q ``=` `q[``1``:]``        ``x ``=` `up[``0``]``        ``lev ``=` `up[``1``]``        ``if` `(lev > dist[x]):``            ``continue``        ``if` `(x ``=``=` `n ``-` `1``):``            ``continue` `        ``# Traversing its adjacency list``        ``for` `y ``in` `g[x]:``            ``if` `(dist[y] > lev ``+` `1``):``                ``dist[y] ``=` `lev ``+` `1``                ``q.append([y, lev ``+` `1``])``            ` `    ``# Initialize queue``    ``q1 ``=` `[]``    ``q1.append([n ``-` `1``, ``0``])``    ``dist1 ``=` `[``1e9` `for` `i ``in` `range``(n)]``    ``dist1[n ``-` `1``] ``=` `0` `    ``# BFS from last node using queue``    ``while` `(``len``(q1) > ``0``):``        ``up ``=` `q1[``0``]` `        ``# Pop from queue``        ``q1 ``=` `q1[``1``:]``        ``x ``=` `up[``0``]``        ``lev ``=` `up[``1``]``        ``if` `(lev > dist1[x]):``            ``continue``        ``if` `(x ``=``=` `0``):``            ``continue` `        ``# Traversing its adjacency list``        ``for` `y ``in` `g[x]:``            ``if` `(dist1[y] > lev ``+` `1``):``                ``dist1[y] ``=` `lev ``+` `1``                ``q1.append([y, lev ``+` `1``])` `    ``# Printing the minimum distance``    ``# including node i``    ``for` `i ``in` `range``(n):``        ``# If not reachable``        ``if` `(dist[i] ``+` `dist1[i] > ``1e9``):``            ``print``(``-``1``,end ``=` `" "``)` `        ``# Path exists``        ``else``:``            ``print``(dist[i] ``+` `dist1[i],end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``# Given Input``    ``n ``=` `5``    ``m ``=` `7``    ``edges ``=` `[[``1``, ``2``],[``1``, ``4``],[``2``, ``3``],[``2``, ``5``],[``4``, ``3``],[``4``, ``5``],[``1``, ``5``]]` `    ``# Function Call``    ``minDisIncludingNode(n, m, edges)``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `MainClass {``    ``public` `static` `void` `MinDisIncludingNode(``int` `n, ``int` `m, ``int``[][] edges) {``        ``// List to store our edges``        ``List<``int``>[] g = ``new` `List<``int``>[10005];``        ``for` `(``int` `i = 0; i < 10005; i++) {``            ``g[i] = ``new` `List<``int``>();``        ``}` `        ``// Storing the edges in the List``        ``for` `(``int` `i = 0; i < m; i++) {``            ``int` `a = edges[i][0] - 1;``            ``int` `b = edges[i][1] - 1;``            ``g[a].Add(b);``            ``g[b].Add(a);``        ``}` `        ``// Initialize queue``        ``Queue<``int``> q = ``new` `Queue<``int``>();``        ``q.Enqueue(0);``        ``int``[] dist = ``new` `int``[n];``        ``for` `(``int` `i = 0; i < n; i++) {``            ``dist[i] = ``int``.MaxValue;``        ``}``        ``dist[0] = 0;` `        ``// BFS from first node using queue``        ``while` `(q.Count != 0) {``            ``int` `x = q.Dequeue();``            ``if` `(x == n - 1)``                ``continue``;` `            ``// Traversing its adjacency list``            ``foreach` `(``int` `y ``in` `g[x]) {``                ``if` `(dist[y] > dist[x] + 1) {``                    ``dist[y] = dist[x] + 1;``                    ``q.Enqueue(y);``                ``}``            ``}``        ``}``        ``// Initialize queue``        ``Queue<``int``> q1 = ``new` `Queue<``int``>();``        ``q1.Enqueue(n - 1);``        ``int``[] dist1 = ``new` `int``[n];``        ``for` `(``int` `i = 0; i < n; i++) {``            ``dist1[i] = ``int``.MaxValue;``        ``}``        ``dist1[n - 1] = 0;` `        ``// BFS from last node using queue``        ``while` `(q1.Count != 0) {``            ``int` `x = q1.Dequeue();``            ``if` `(x == 0)``                ``continue``;` `            ``// Traversing its adjacency list``            ``foreach` `(``int` `y ``in` `g[x]) {``                ``if` `(dist1[y] > dist1[x] + 1) {``                    ``dist1[y] = dist1[x] + 1;``                    ``q1.Enqueue(y);``                ``}``            ``}``        ``}` `        ``// Printing the minimum distance``        ``// including node i``        ``for` `(``int` `i = 0; i < n; i++) {``            ``// If not reachable``            ``if` `(dist[i] + dist1[i] > ``int``.MaxValue)``                ``Console.Write(-1 + ``" "``);` `            ``// Path exists``            ``else``                ``Console.Write(dist[i] + dist1[i] + ``" "``);``        ``}``    ``}` `    ``public` `static` `void` `Main(``string``[] args) {``       ` `       ``// Given Input``            ``int` `n = 5;``            ``int` `m = 7;``            ``int``[][] edges = { ``new` `int``[] { 1, 2 }, ``new` `int``[] { 1, 4 }, ``new` `int``[] { 2, 3 },``                          ``new` `int``[] { 2, 5 }, ``new` `int``[] { 4, 3 }, ``new` `int``[] { 4, 5 }, ``new` `int``[] { 1, 5 } };` `            ``// Function Call``            ``MinDisIncludingNode(n, m, edges);``        ``}` `}`

## Javascript

 ``

Output:

`1 2 4 2 1`

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

My Personal Notes arrow_drop_up