Skip to content
geeksforgeeks
  • Tutorials
    • Python
    • Java
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
    • Practice Coding Problems
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • DSA
  • Interview Problems on Graph
  • Practice Graph
  • MCQs on Graph
  • Graph Tutorial
  • Graph Representation
  • Graph Properties
  • Types of Graphs
  • Graph Applications
  • BFS on Graph
  • DFS on Graph
  • Graph VS Tree
  • Transpose Graph
  • Dijkstra's Algorithm
  • Minimum Spanning Tree
  • Prim’s Algorithm
  • Topological Sorting
  • Floyd Warshall Algorithm
  • Strongly Connected Components
  • Advantages & Disadvantages
Open In App
Next Article:
Distance of nearest cell having 1 in a binary matrix
Next article icon

Number of shortest paths in an unweighted and directed graph

Last Updated : 17 Aug, 2022
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an unweighted directed graph, can be cyclic or acyclic. Print the number of shortest paths from a given vertex to each of the vertices. For example consider the below graph. There is one shortest path vertex 0 to vertex 0 (from each vertex there is a single shortest path to itself), one shortest path between vertex 0 to vertex 2 (0->2), and there are 4 different shortest paths from vertex 0 to vertex 6: 

  1. 0->1->3->4->6 
  2. 0->1->3->5->6 
  3. 0->2->3->4->6 
  4. 0->2->3->5->6 

The idea is to use BFS. We use two arrays called dist[] and paths[], dist[] represents the shortest distances from source vertex, and paths[] represents the number of different shortest paths from the source vertex to each of the vertices. Initially all the elements in dist[] are infinity except source vertex which is equal to 0, since the distance to source vertex from itself is 0, and all the elements in paths[] are 0 except source vertex which is equal to 1, since each vertex has a single shortest path to itself. after that, we start traversing the graph using BFS manner. 

Then, for every neighbor Y of each vertex X do: 

  1. if dist[Y] > dist[X]+1 decrease the dist[Y] to dist[X] +1 and assign the number of paths of vertex X to number of paths of vertex Y. 
  2. else if dist[Y] = dist[X] + 1, then add the number of paths of vertex X to the number of paths of vertex Y. 

For example: 

Let's take a look at the below graph. The source vertex is 0. Suppose we traverse on vertex 2, we check all its neighbors, which is only 3.since vertex 3 was already visited when we were traversed vertex 1, dist[3] = 2 and paths[3] = 1. The second condition is true, so it means that additional shortest paths have been found, so we add to the number of paths of vertex 3, the number of paths of vertex 2. 

The equal condition happens when we traverse on vertex 5: 

Implementation:

C++ 
// CPP program to count number of shortest // paths from a given source to every other // vertex using BFS. #include <bits/stdc++.h> using namespace std;  // Traverses graph in BFS manner. It fills  // dist[] and paths[] void BFS(vector<int> adj[], int src, int dist[],                            int paths[], int n) {     bool visited[n];     for (int i = 0; i < n; i++)         visited[i] = false;     dist[src] = 0;     paths[src] = 1;      queue <int> q;     q.push(src);     visited[src] = true;     while (!q.empty())     {         int curr = q.front();         q.pop();          // For all neighbors of current vertex do:         for (auto x : adj[curr])         {             // if the current vertex is not yet             // visited, then push it to the queue.             if (visited[x] == false)             {                 q.push(x);                 visited[x] = true;             }              // check if there is a better path.             if (dist[x] > dist[curr] + 1)             {                 dist[x] = dist[curr] + 1;                 paths[x] = paths[curr];             }              // additional shortest paths found             else if (dist[x] == dist[curr] + 1)                 paths[x] += paths[curr];         }     } }  // function to find number of different // shortest paths form given vertex s. // n is number of vertices. void findShortestPaths(vector<int> adj[],                        int s, int n) {     int dist[n], paths[n];     for (int i = 0; i < n; i++)         dist[i] = INT_MAX;     for (int i = 0; i < n; i++)         paths[i] = 0;     BFS(adj, s, dist, paths, n);     cout << "Numbers of shortest Paths are: ";     for (int i = 0; i < n; i++)         cout << paths[i] << " "; }  // A utility function to add an edge in a // directed graph. void addEdge(vector<int> adj[], int u, int v) {     adj[u].push_back(v); }  // Driver code int main() {     int n = 7; // Number of vertices     vector <int> adj[n];     addEdge(adj, 0, 1);     addEdge(adj, 0, 2);     addEdge(adj, 1, 2);     addEdge(adj, 1, 3);     addEdge(adj, 2, 3);     addEdge(adj, 3, 4);     addEdge(adj, 3, 5);     addEdge(adj, 4, 6);     addEdge(adj, 5, 6);     findShortestPaths(adj, 0, 7);     return 0; }
Java 
// Java program to count number of shortest  // paths from a given source to every other  // vertex using BFS. import java.io.*; import java.util.*;  class GFG  {      // Traverses graph in BFS manner.      // It fills dist[] and paths[]     static void BFS(Vector<Integer>[] adj, int src,                   int dist[], int paths[], int n)      {         boolean[] visited = new boolean[n];         for (int i = 0; i < n; i++)             visited[i] = false;         dist[src] = 0;         paths[src] = 1;          Queue<Integer> q = new LinkedList<>();         q.add(src);         visited[src] = true;         while (!q.isEmpty())         {             int curr = q.peek();             q.poll();              // For all neighbors of current vertex do:             for (int x : adj[curr])             {                  // if the current vertex is not yet                 // visited, then push it to the queue.                 if (visited[x] == false)                 {                     q.add(x);                     visited[x] = true;                 }                  // check if there is a better path.                 if (dist[x] > dist[curr] + 1)                  {                     dist[x] = dist[curr] + 1;                     paths[x] = paths[curr];                 }                  // additional shortest paths found                 else if (dist[x] == dist[curr] + 1)                     paths[x] += paths[curr];             }         }     }      // function to find number of different     // shortest paths form given vertex s.     // n is number of vertices.     static void findShortestPaths(Vector<Integer> adj[],                                             int s, int n)      {         int[] dist = new int[n], paths = new int[n];                  for (int i = 0; i < n; i++)             dist[i] = Integer.MAX_VALUE;          for (int i = 0; i < n; i++)             paths[i] = 0;          BFS(adj, s, dist, paths, n);          System.out.print("Numbers of shortest Paths are: ");         for (int i = 0; i < n; i++)             System.out.print(paths[i] + " ");     }      // A utility function to add an edge in a     // directed graph.     static void addEdge(Vector<Integer> adj[],                                  int u, int v)     {         adj[u].add(v);     }      // Driver Code     public static void main(String[] args)      {         int n = 7; // Number of vertices          Vector<Integer>[] adj = new Vector[n];         for (int i = 0; i < n; i++)             adj[i] = new Vector<>();          addEdge(adj, 0, 1);         addEdge(adj, 0, 2);         addEdge(adj, 1, 2);         addEdge(adj, 1, 3);         addEdge(adj, 2, 3);         addEdge(adj, 3, 4);         addEdge(adj, 3, 5);         addEdge(adj, 4, 6);         addEdge(adj, 5, 6);         findShortestPaths(adj, 0, 7);     } }  // This code is contributed by // sanjeev2552
Python3 
# Python3 program to count number of shortest # paths from a given source to every other # vertex using BFS. from collections import deque from sys import maxsize as INT_MAX  # Traverses graph in BFS manner. It fills # dist[] and paths[] def BFS(adj: list, src: int, dist: list, paths: list, n: int):     visited = [False] * n     dist[src] = 0     paths[src] = 1      q = deque()     q.append(src)     visited[src] = True     while q:         curr = q[0]         q.popleft()          # For all neighbors of current vertex do:         for x in adj[curr]:              # if the current vertex is not yet             # visited, then push it to the queue.             if not visited[x]:                 q.append(x)                 visited[x] = True              # check if there is a better path.             if dist[x] > dist[curr] + 1:                 dist[x] = dist[curr] + 1                 paths[x] = paths[curr]              # additional shortest paths found             elif dist[x] == dist[curr] + 1:                 paths[x] += paths[curr]  # function to find number of different # shortest paths form given vertex s. # n is number of vertices. def findShortestPaths(adj: list, s: int, n: int):     dist = [INT_MAX] * n     paths = [0] * n     BFS(adj, s, dist, paths, n)     print("Numbers of shortest Paths are:", end=" ")     for i in paths:         print(i, end=" ")  # A utility function to add an edge in a # directed graph. def addEdge(adj: list, u: int, v: int):     adj[u].append(v)  # Driver Code if __name__ == "__main__":      n = 7 # Number of vertices     adj = [0] * n     for i in range(n):         adj[i] = []     addEdge(adj, 0, 1)     addEdge(adj, 0, 2)     addEdge(adj, 1, 2)     addEdge(adj, 1, 3)     addEdge(adj, 2, 3)     addEdge(adj, 3, 4)     addEdge(adj, 3, 5)     addEdge(adj, 4, 6)     addEdge(adj, 5, 6)     findShortestPaths(adj, 0, 7)  # This code is contributed by # sanjeev2552
C# 
// C# program to count number of shortest  // paths from a given source to every other  // vertex using BFS. using System; using System.Collections.Generic;  class GFG  {      // Traverses graph in BFS manner.      // It fills dist[] and paths[]     static void BFS(List<int>[] adj, int src,                 int []dist, int []paths, int n)      {         bool[] visited = new bool[n];         for (int i = 0; i < n; i++)             visited[i] = false;         dist[src] = 0;         paths[src] = 1;          List<int> q = new List<int>();         q.Add(src);         visited[src] = true;         while (q.Count != 0)         {             int curr = q[0];             q.RemoveAt(0);              // For all neighbors of current vertex do:             foreach (int x in adj[curr])             {                  // if the current vertex is not yet                 // visited, then push it to the queue.                 if (visited[x] == false)                 {                     q.Add(x);                     visited[x] = true;                 }                  // check if there is a better path.                 if (dist[x] > dist[curr] + 1)                  {                     dist[x] = dist[curr] + 1;                     paths[x] = paths[curr];                 }                  // additional shortest paths found                 else if (dist[x] == dist[curr] + 1)                     paths[x] += paths[curr];             }         }     }      // function to find number of different     // shortest paths form given vertex s.     // n is number of vertices.     static void findShortestPaths(List<int> []adj,                                          int s, int n)      {         int[] dist = new int[n], paths = new int[n];                  for (int i = 0; i < n; i++)             dist[i] = int.MaxValue;          for (int i = 0; i < n; i++)             paths[i] = 0;          BFS(adj, s, dist, paths, n);          Console.Write("Numbers of shortest Paths are: ");         for (int i = 0; i < n; i++)             Console.Write(paths[i] + " ");     }      // A utility function to add an edge in a     // directed graph.     static void addEdge(List<int> []adj,                                 int u, int v)     {         adj[u].Add(v);     }      // Driver Code     public static void Main(String[] args)      {         int n = 7; // Number of vertices          List<int>[] adj = new List<int>[n];         for (int i = 0; i < n; i++)             adj[i] = new List<int>();          addEdge(adj, 0, 1);         addEdge(adj, 0, 2);         addEdge(adj, 1, 2);         addEdge(adj, 1, 3);         addEdge(adj, 2, 3);         addEdge(adj, 3, 4);         addEdge(adj, 3, 5);         addEdge(adj, 4, 6);         addEdge(adj, 5, 6);         findShortestPaths(adj, 0, 7);     } }  // This code is contributed by 29AjayKumar
JavaScript 
<script> // Javascript program to count number of shortest // paths from a given source to every other // vertex using BFS.  // Traverses graph in BFS manner.     // It fills dist[] and paths[] function  BFS(adj,src,dist,paths,n) {     let visited = new Array(n);         for (let i = 0; i < n; i++)             visited[i] = false;         dist[src] = 0;         paths[src] = 1;           let q = [];         q.push(src);         visited[src] = true;         while (q.length!=0)         {             let curr = q[0];             q.shift();               // For all neighbors of current vertex do:             for (let x of adj[curr].values())             {                   // if the current vertex is not yet                 // visited, then push it to the queue.                 if (visited[x] == false)                 {                     q.push(x);                     visited[x] = true;                 }                   // check if there is a better path.                 if (dist[x] > dist[curr] + 1)                 {                     dist[x] = dist[curr] + 1;                     paths[x] = paths[curr];                 }                   // additional shortest paths found                 else if (dist[x] == dist[curr] + 1)                     paths[x] += paths[curr];             }         } }  // function to find number of different     // shortest paths form given vertex s.     // n is number of vertices. function findShortestPaths(adj,s,n) {     let dist = new Array(n), paths = new Array(n);                   for (let i = 0; i < n; i++)             dist[i] = Number.MAX_VALUE;           for (let i = 0; i < n; i++)             paths[i] = 0;           BFS(adj, s, dist, paths, n);           document.write("Numbers of shortest Paths are: ");         for (let i = 0; i < n; i++)             document.write(paths[i] + " "); }  // A utility function to add an edge in a     // directed graph. function addEdge(adj,u,v) {     adj[u].push(v); }  // Driver Code let n = 7; // Number of vertices  let adj = new Array(n); for (let i = 0; i < n; i++)     adj[i] = [];  addEdge(adj, 0, 1); addEdge(adj, 0, 2); addEdge(adj, 1, 2); addEdge(adj, 1, 3); addEdge(adj, 2, 3); addEdge(adj, 3, 4); addEdge(adj, 3, 5); addEdge(adj, 4, 6); addEdge(adj, 5, 6); findShortestPaths(adj, 0, 7);  // This code is contributed by rag2127 </script>

Output
Numbers of shortest Paths are: 1 1 1 2 2 2 4

Time Complexity : O(V + E)


Next Article
Distance of nearest cell having 1 in a binary matrix

S
shlomialon
Improve
Article Tags :
  • Graph
  • DSA
Practice Tags :
  • Graph

Similar Reads

    Breadth First Search or BFS for a Graph
    Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
    15+ min read

    BFS in different language

    C Program for Breadth First Search or BFS for a Graph
    The Breadth First Search (BFS) algorithm is used to search a graph data structure for a node that meets a set of criteria. It starts at the root of the graph and visits all nodes at the current depth level before moving on to the nodes at the next depth level. Relation between BFS for Graph and Tree
    3 min read
    Java Program for Breadth First Search or BFS for a Graph
    The Breadth First Search (BFS) algorithm is used to search a graph data structure for a node that meets a set of criteria. It starts at the root of the graph and visits all nodes at the current depth level before moving on to the nodes at the next depth level. Relation between BFS for Graph and Tree
    3 min read
    Breadth First Search or BFS for a Graph in Python
    Breadth First Search (BFS) is a fundamental graph traversal algorithm. It begins with a node, then first traverses all its adjacent nodes. Once all adjacent are visited, then their adjacent are traversed. BFS is different from DFS in a way that closest vertices are visited before others. We mainly t
    4 min read
    BFS for Disconnected Graph
    In the previous post, BFS only with a particular vertex is performed i.e. it is assumed that all vertices are reachable from the starting vertex. But in the case of a disconnected graph or any vertex that is unreachable from all vertex, the previous implementation will not give the desired output, s
    14 min read
    Applications, Advantages and Disadvantages of Breadth First Search (BFS)
    We have earlier discussed Breadth First Traversal Algorithm for Graphs. Here in this article, we will see the applications, advantages, and disadvantages of the Breadth First Search. Applications of Breadth First Search: 1. Shortest Path and Minimum Spanning Tree for unweighted graph: In an unweight
    4 min read
    Breadth First Traversal ( BFS ) on a 2D array
    Given a matrix of size M x N consisting of integers, the task is to print the matrix elements using Breadth-First Search traversal. Examples: Input: grid[][] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}}Output: 1 2 5 3 6 9 4 7 10 13 8 11 14 12 15 16 Input: grid[][] = {{-1, 0, 0,
    9 min read
    0-1 BFS (Shortest Path in a Binary Weight Graph)
    Given an undirected graph where every edge has a weight as either 0 or 1. The task is to find the shortest path from the source vertex to all other vertices in the graph.Example: Input: Source Vertex = 0 and below graph Having vertices like (u, v, w): edges: [[0,1,0], [0, 7, 1], [1,2,1], [1, 7, 1],
    10 min read

    Variations of BFS implementations

    Implementation of BFS using adjacency matrix
    Breadth First Search (BFS) has been discussed in this article which uses adjacency list for the graph representation. In this article, adjacency matrix will be used to represent the graph.Adjacency matrix representation: In adjacency matrix representation of a graph, the matrix mat[][] of size n*n (
    7 min read
    BFS using STL for competitive coding
    A STL based simple implementation of BFS using queue and vector in STL. The adjacency list is represented using vectors of vector.  In BFS, we start with a node. Create a queue and enqueue source into it. Mark source as visited.While queue is not empty, do followingDequeue a vertex from queue. Let t
    5 min read
    Breadth First Search without using Queue
    Breadth-first search is a graph traversal algorithm which traverse a graph or tree level by level. In this article, BFS for a Graph is implemented using Adjacency list without using a Queue.Examples: Input: Output: BFS traversal = 2, 0, 3, 1 Explanation: In the following graph, we start traversal fr
    8 min read
    BFS using vectors & queue as per the algorithm of CLRS
    Breadth-first search traversal of a graph using the algorithm given in CLRS book. BFS is one of the ways to traverse a graph. It is named so because it expands the frontier between discovered and undiscovered vertices uniformly across the breadth of the frontier. What it means is that the algorithm
    11 min read

    Easy problems on BFS

    Find if there is a path between two vertices in a directed graph
    Given a Directed Graph and two vertices src and dest, check whether there is a path from src to dest.Example: Consider the following Graph: adj[][] = [ [], [0, 2], [0, 3], [], [2] ]Input : src = 1, dest = 3Output: YesExplanation: There is a path from 1 to 3, 1 -> 2 -> 3Input : src = 0, dest =
    11 min read
    Find if there is a path between two vertices in an undirected graph
    Given an undirected graph with N vertices and E edges and two vertices (U, V) from the graph, the task is to detect if a path exists between these two vertices. Print "Yes" if a path exists and "No" otherwise. Examples: U = 1, V = 2 Output: No Explanation: There is no edge between the two points and
    15+ min read
    Print all the levels with odd and even number of nodes in it | Set-2
    Given an N-ary tree, print all the levels with odd and even number of nodes in it. Examples: For example consider the following tree 1 - Level 1 / \ 2 3 - Level 2 / \ \ 4 5 6 - Level 3 / \ / 7 8 9 - Level 4 The levels with odd number of nodes are: 1 3 4 The levels with even number of nodes are: 2 No
    12 min read
    Finding the path from one vertex to rest using BFS
    Given an adjacency list representation of a directed graph, the task is to find the path from source to every other node in the graph using BFS. Examples: Input: Output: 0 <- 2 1 <- 0 <- 2 2 3 <- 1 <- 0 <- 2 4 <- 5 <- 2 5 <- 2 6 <- 2 Approach: In the images shown below:
    14 min read
    Find all reachable nodes from every node present in a given set
    Given an undirected graph and a set of vertices, find all reachable nodes from every vertex present in the given set.Consider below undirected graph with 2 disconnected components.  arr[] = {1 , 2 , 5}Reachable nodes from 1 are 1, 2, 3, 4Reachable nodes from 2 are 1, 2, 3, 4Reachable nodes from 5 ar
    12 min read
    Program to print all the non-reachable nodes | Using BFS
    Given an undirected graph and a set of vertices, we have to print all the non-reachable nodes from the given head node using a breadth-first search. For example: Consider below undirected graph with two disconnected components: In this graph, if we consider 0 as a head node, then the node 0, 1 and 2
    8 min read
    Check whether a given graph is Bipartite or not
    Given a graph with V vertices numbered from 0 to V-1 and a list of edges, determine whether the graph is bipartite or not.Note: A bipartite graph is a type of graph where the set of vertices can be divided into two disjoint sets, say U and V, such that every edge connects a vertex in U to a vertex i
    8 min read
    Print all paths from a given source to a destination using BFS
    Given a directed graph, a source vertex ‘src’ and a destination vertex ‘dst’, print all paths from given ‘src’ to ‘dst’. Please note that in the cases, we have cycles in the graph, we need not to consider paths have cycles as in case of cycles, there can by infinitely many by doing multiple iteratio
    9 min read
    Minimum steps to reach target by a Knight | Set 1
    Given a square chessboard of n x n size, the position of the Knight and the position of a target are given. We need to find out the minimum steps a Knight will take to reach the target position.Examples: Input: KnightknightPosition: (1, 3) , targetPosition: (5, 0)Output: 3Explanation: In above diagr
    9 min read

    Intermediate problems on BFS

    Traversal of a Graph in lexicographical order using BFS
    C++ // C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std; // Function to traverse the graph in // lexicographical order using BFS void LexiBFS(map<char, set<char> >& G, char S, map<char, bool>& vis) { // Stores nodes of the gr
    8 min read
    Detect cycle in an undirected graph using BFS
    Given an undirected graph, the task is to determine if cycle is present in it or not.Examples:Input: V = 5, edges[][] = [[0, 1], [0, 2], [0, 3], [1, 2], [3, 4]]Undirected Graph with 5 NodeOutput: trueExplanation: The diagram clearly shows a cycle 0 → 2 → 1 → 0.Input: V = 4, edges[][] = [[0, 1], [1,
    6 min read
    Detect Cycle in a Directed Graph using BFS
    Given a directed graph, check whether the graph contains a cycle or not. Your function should return true if the given graph contains at least one cycle, else return false. For example, the following graph contains two cycles 0->1->2->3->0 and 2->4->2, so your function must return
    11 min read
    Minimum number of edges between two vertices of a Graph
    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: 2Explanation: (1, 2) and (2, 5) are the only edges resu
    8 min read
    Word Ladder - Shortest Chain To Reach Target Word
    Given an array of strings arr[], and two different strings start and target, representing two words. The task is to find the length of the smallest chain from string start to target, such that only one character of the adjacent words differs and each word exists in arr[].Note: Print 0 if it is not p
    15 min read
    Print the lexicographically smallest BFS of the graph starting from 1
    Given a connected graph with N vertices and M edges. The task is to print the lexicographically smallest BFS traversal of the graph starting from 1. Note: The vertices are numbered from 1 to N.Examples: Input: N = 5, M = 5 Edges: 1 4 3 4 5 4 3 2 1 5 Output: 1 4 3 2 5 Start from 1, go to 4, then to 3
    7 min read
    Shortest path in an unweighted graph
    Given an unweighted, undirected graph of V nodes and E edges, a source node S, and a destination node D, we need to find the shortest path from node S to node D in the graph. Input: V = 8, E = 10, S = 0, D = 7, edges[][] = {{0, 1}, {1, 2}, {0, 3}, {3, 4}, {4, 7}, {3, 7}, {6, 7}, {4, 5}, {4, 6}, {5,
    11 min read
    Number of shortest paths in an unweighted and directed graph
    Given an unweighted directed graph, can be cyclic or acyclic. Print the number of shortest paths from a given vertex to each of the vertices. For example consider the below graph. There is one shortest path vertex 0 to vertex 0 (from each vertex there is a single shortest path to itself), one shorte
    11 min read
    Distance of nearest cell having 1 in a binary matrix
    Given a binary grid of n*m. Find the distance of the nearest 1 in the grid for each cell.The distance is calculated as |i1  - i2| + |j1 - j2|, where i1, j1 are the row number and column number of the current cell, and i2, j2 are the row number and column number of the nearest cell having value 1. Th
    15+ min read

    Hard Problems on BFS

    Islands in a graph using BFS
    Given an n x m grid of 'W' (Water) and 'L' (Land), the task is to count the number of islands. An island is a group of adjacent 'L' cells connected horizontally, vertically, or diagonally, and it is surrounded by water or the grid boundary. The goal is to determine how many distinct islands exist in
    15+ min read
    Print all shortest paths between given source and destination in an undirected graph
    Given an undirected and unweighted graph and two nodes as source and destination, the task is to print all the paths of the shortest length between the given source and destination.Examples: Input: source = 0, destination = 5 Output: 0 -> 1 -> 3 -> 50 -> 2 -> 3 -> 50 -> 1 ->
    13 min read
    Count Number of Ways to Reach Destination in a Maze using BFS
    Given a maze of dimensions n x m represented by the matrix mat, where mat[i][j] = -1 represents a blocked cell and mat[i][j] = 0 represents an unblocked cell, the task is to count the number of ways to reach the bottom-right cell starting from the top-left cell by moving right (i, j+1) or down (i+1,
    8 min read
    Coin Change | BFS Approach
    Given an integer X and an array arr[] of length N consisting of positive integers, the task is to pick minimum number of integers from the array such that they sum up to N. Any number can be chosen infinite number of times. If no answer exists then print -1.Examples: Input: X = 7, arr[] = {3, 5, 4}
    6 min read
    Water Jug problem using BFS
    Given two empty jugs of m and n litres respectively. The jugs don't have markings to allow measuring smaller quantities. You have to use the jugs to measure d litres of water. The task is to find the minimum number of operations to be performed to obtain d litres of water in one of the jugs. In case
    12 min read
    Word Ladder - Set 2 ( Bi-directional BFS )
    Given a dictionary, and two words start and target (both of the same length). Find length of the smallest chain from start to target if it exists, such that adjacent words in the chain only differ by one character and each word in the chain is a valid word i.e., it exists in the dictionary. It may b
    15+ min read
    Implementing Water Supply Problem using Breadth First Search
    Given N cities that are connected using N-1 roads. Between Cities [i, i+1], there exists an edge for all i from 1 to N-1.The task is to set up a connection for water supply. Set the water supply in one city and water gets transported from it to other cities using road transport. Certain cities are b
    10 min read
    Minimum Cost Path in a directed graph via given set of intermediate nodes
    Given a weighted, directed graph G, an array V[] consisting of vertices, the task is to find the Minimum Cost Path passing through all the vertices of the set V, from a given source S to a destination D. Examples: Input: V = {7}, S = 0, D = 6 Output: 11 Explanation: Minimum path 0->7->5->6.
    10 min read
    Shortest path in a Binary Maze
    Given an M x N matrix where each element can either be 0 or 1. We need to find the shortest path between a given source cell to a destination cell. The path can only be created out of a cell if its value is 1.Note: You can move into an adjacent cell in one of the four directions, Up, Down, Left, and
    15+ min read
    Minimum cost to traverse from one index to another in the String
    Given a string S of length N consisting of lower case character, the task is to find the minimum cost to reach from index i to index j. At any index k, the cost to jump to the index k+1 and k-1(without going out of bounds) is 1. Additionally, the cost to jump to any index m such that S[m] = S[k] is
    10 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences