 Open in App
Not now

# Number of minimum length paths between 1 to N including each node

• Last Updated : 15 Sep, 2021

Given an undirected and unweighted graph of N nodes and M edges, the task is to count the minimum length paths between node 1 to N through each of the nodes. If there is 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: 1 1 1 1
Explanation: Total paths of minimum length from 1 to 4, passing from 1 is 1.
Total paths of minimum length from 1 to 4, passing from 2 is 1.
Total paths of minimum length from 1 to 4, passing from 3 is 1.
Total paths of minimum length from 1 to 4, passing from 4 is 1.

Input: N = 5, M = 5, edges = {{1, 2}, {1, 4}, {1 3}, {2, 5}, {2, 4}}
Output: 1 1 0 1 1

Approach: The given problem can be solved by performing 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, and the product of both the minimum distances will be the total count of minimum length paths 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 arrays, say dist[] to store the shortest distance and ways[] to count the number of ways to reach that node.
• 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 and ways[y] equals ways[x]. Otherwise, if dist[y] equals dis +1 then add ways[x] to ways[y].
• Finally, iterate over the range N, and for each node print the count of minimum length paths as ways1[i]*ways2[i].

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` `countMinDistance(``int` `n, ``int` `m,` `                      ``int` `edges[])` `{`   `    ``// Stores the number of edges` `    ``vector g;`   `    ``// Storing the edges in vector` `    ``for` `(``int` `i = 0; i < m; i++) {` `        ``int` `a = edges[i] - 1;` `        ``int` `b = edges[i] - 1;` `        ``g[a].push_back(b);` `        ``g[b].push_back(a);` `    ``}`   `    ``// Initialize queue` `    ``queue > queue1;` `    ``queue1.push({ 0, 0 });` `    ``vector<``int``> dist(n, 1e9);` `    ``vector<``int``> ways1(n, 0);` `    ``dist = 0;` `    ``ways1 = 1;`   `    ``// BFS from 1st node using queue` `    ``while` `(!queue1.empty()) {` `        ``auto` `up = queue1.front();`   `        ``// Pop from queue` `        ``queue1.pop();` `        ``int` `x = up.first;` `        ``int` `dis = up.second;` `        ``if` `(dis > dist[x])` `            ``continue``;` `        ``if` `(x == n - 1)` `            ``continue``;`   `        ``// Traversing the adjacency list` `        ``for` `(ll y : g[x]) {` `            ``if` `(dist[y] > dis + 1) {` `                ``dist[y] = dis + 1;` `                ``ways1[y] = ways1[x];` `                ``queue1.push({ y, dis + 1 });` `            ``}` `            ``else` `if` `(dist[y] == dis + 1) {` `                ``ways1[y] += ways1[x];` `            ``}` `        ``}` `    ``}`   `    ``// Initialize queue` `    ``queue > queue2;` `    ``queue2.push({ n - 1, 0 });` `    ``vector<``int``> dist1(n, 1e9);` `    ``vector<``int``> ways2(n, 0);` `    ``dist1[n - 1] = 0;` `    ``ways2[n - 1] = 1;`   `    ``// BFS from last node` `    ``while` `(!queue2.empty()) {` `        ``auto` `up = queue2.front();`   `        ``// Pop from queue` `        ``queue2.pop();` `        ``int` `x = up.first;` `        ``int` `dis = up.second;` `        ``if` `(dis > dist1[x])` `            ``continue``;` `        ``if` `(x == 0)` `            ``continue``;`   `        ``// Traverse the adjacency list` `        ``for` `(ll y : g[x]) {` `            ``if` `(dist1[y] > dis + 1) {` `                ``dist1[y] = dis + 1;` `                ``ways2[y] = ways2[x];` `                ``queue2.push({ y, dis + 1 });` `            ``}` `            ``else` `if` `(dist1[y] == 1 + dis) {` `                ``ways2[y] += ways2[x];` `            ``}` `        ``}` `    ``}`   `    ``// Print the count of minimum` `    ``// distance` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``cout << ways1[i] * ways2[i] << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 5, M = 5;` `    ``int` `edges[M] = {` `        ``{ 1, 2 }, { 1, 4 }, { 1, 3 }, ` `        ``{ 2, 5 }, { 2, 4 }` `    ``};` `    ``countMinDistance(N, M, edges);`   `    ``return` `0;` `}`

## Python3

 `# Python 3 program for the above approach`   `# Function to calculate the distances` `# from node 1 to N` `def` `countMinDistance(n, m, edges):` `    ``# Stores the number of edges` `    ``g ``=` `[[] ``for` `i ``in` `range``(``10005``)]`   `    ``# Storing the edges in 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` `    ``queue1 ``=` `[]` `    ``queue1.append([``0``, ``0``])` `    ``dist ``=` `[``1e9` `for` `i ``in` `range``(n)]` `    ``ways1 ``=` `[``0` `for` `i ``in` `range``(n)]` `    ``dist[``0``] ``=` `0` `    ``ways1[``0``] ``=` `1`   `    ``# BFS from 1st node using queue` `    ``while` `(``len``(queue1)>``0``):` `        ``up ``=` `queue1[``0``]`   `        ``# Pop from queue` `        ``queue1 ``=` `queue1[:``-``1``]` `        ``x ``=` `up[``0``]` `        ``dis ``=` `up[``1``]` `        ``if` `(dis > dist[x]):` `            ``continue` `        ``if` `(x ``=``=` `n ``-` `1``):` `            ``continue`   `        ``# Traversing the adjacency list` `        ``for` `y ``in` `g[x]:` `            ``if` `(dist[y] > dis ``+` `1``):` `                ``dist[y] ``=` `dis ``+` `1` `                ``ways1[y] ``=` `ways1[x]` `                ``queue1.append([y, dis ``+` `1``])` `        `  `            ``elif``(dist[y] ``=``=` `dis ``+` `1``):` `                ``ways1[y] ``+``=` `ways1[x]`   `    ``# Initialize queue` `    ``queue2 ``=` `[]` `    ``queue2.append([n ``-` `1``, ``0``])` `    ``dist1 ``=` `[``1e9` `for` `i ``in` `range``(n)]` `    ``ways2 ``=` `[``0` `for` `i ``in` `range``(n)]` `    ``dist1[n ``-` `1``] ``=` `0` `    ``ways2[n ``-` `1``] ``=` `1`   `    ``# BFS from last node` `    ``while``(``len``(queue2)>``0``):` `        ``up ``=` `queue2[``0``]`   `        ``# Pop from queue` `        ``queue2 ``=` `queue2[:``-``1``]` `        ``x ``=` `up[``0``]` `        ``dis ``=` `up[``1``]` `        ``if` `(dis > dist1[x]):` `            ``continue` `        ``if` `(x ``=``=` `0``):` `            ``continue`   `        ``# Traverse the adjacency list` `        ``for` `y ``in` `g[x]:` `            ``if` `(dist1[y] > dis ``+` `1``):` `                ``dist1[y] ``=` `dis ``+` `1` `                ``ways2[y] ``=` `ways2[x]` `                ``queue2.append([y, dis ``+` `1``])`   `            ``elif``(dist1[y] ``=``=` `1` `+` `dis):` `                ``ways2[y] ``+``=` `ways2[x]`   `    ``# Print the count of minimum` `    ``# distance` `    ``ways1[n``-``1``] ``=` `1` `    ``ways2[n``-``1``] ``=` `1` `    ``for` `i ``in` `range``(n):` `        ``print``(ways1[i] ``*` `ways2[i],end ``=` `" "``)` `    `    `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `5` `    ``M ``=` `5` `    ``edges ``=` `[[``1``, ``2``],[``1``, ``4``],[``1``, ``3``],[``2``, ``5``],[``2``, ``4``]]` `    ``countMinDistance(N, M, edges)` `    `  `    ``# This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``

Output:

`1 1 0 1 1`

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

My Personal Notes arrow_drop_up
Related Articles