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 Tree
  • Practice Tree
  • MCQs on Tree
  • Tutorial on Tree
  • Types of Trees
  • Basic operations
  • Tree Traversal
  • Binary Tree
  • Complete Binary Tree
  • Ternary Tree
  • Binary Search Tree
  • Red-Black Tree
  • AVL Tree
  • Full Binary Tree
  • B-Tree
  • Advantages & Disadvantages
Open In App
Next Article:
Finding the path from one vertex to rest using BFS
Next article icon

Print all the levels with odd and even number of nodes in it | Set-2

Last Updated : 12 Sep, 2022
Comments
Improve
Suggest changes
Like Article
Like
Report

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

Note: The level numbers starts from 1. That is, the root node is at the level 1.

Approach: 

  • Insert all the connecting nodes to a 2-D vector tree.
  • Run a BFS on the tree such that height[node] = 1 + height[parent]
  • Once BFS traversal is completed, increase the count[] array by 1, for every node's level.
  • Iterate from first level to last level, and print all nodes with count[] values as odd to get level with odd number nodes.
  • Iterate from first level to last level, and print all nodes with count[] values as even to get level with even number nodes.

Below is the implementation of the above approach: 

C++ 
// C++ program to print all levels // with odd and even number of nodes  #include <bits/stdc++.h> using namespace std;  // Function for BFS in a tree void bfs(int node, int parent, int height[], int vis[],          vector<int> tree[]) {      // mark first node as visited     vis[node] = 1;      // Declare Queue     queue<int> q;      // Push the first element     q.push(1);      // calculate the level of every node     height[node] = 1 + height[parent];      // Check if the queue is empty or not     while (!q.empty()) {          // Get the top element in the queue         int top = q.front();          // pop the element         q.pop();          // mark as visited         vis[top] = 1;          // Iterate for the connected nodes         for (int i = 0; i < tree[top].size(); i++) {              // if not visited             if (!vis[tree[top][i]]) {                  // Insert into queue                 q.push(tree[top][i]);                  // Increase level                 height[tree[top][i]] = 1 + height[top];             }         }     } }  // Function to insert edges void insertEdges(int x, int y, vector<int> tree[]) {     tree[x].push_back(y);     tree[y].push_back(x); }  // Function to print all levels void printLevelsOddEven(int N, int vis[], int height[]) {     int mark[N + 1];     memset(mark, 0, sizeof mark);      int maxLevel = 0;     for (int i = 1; i <= N; i++) {          // count number of nodes         // in every level         if (vis[i])             mark[height[i]]++;          // find the maximum height of tree         maxLevel = max(height[i], maxLevel);     }      // print odd number of nodes     cout << "The levels with odd number of nodes are: ";     for (int i = 1; i <= maxLevel; i++) {         if (mark[i] % 2)             cout << i << " ";     }      // print even number of nodes     cout << "\nThe levels with even number of nodes are: ";     for (int i = 1; i <= maxLevel; i++) {         if (mark[i] % 2 == 0)             cout << i << " ";     } }  // Driver Code int main() {     // Construct the tree      /*   1        /   \       2     3      / \     \     4    5    6         / \  /        7   8 9  */      const int N = 9;      vector<int> tree[N + 1];      insertEdges(1, 2, tree);     insertEdges(1, 3, tree);     insertEdges(2, 4, tree);     insertEdges(2, 5, tree);     insertEdges(5, 7, tree);     insertEdges(5, 8, tree);     insertEdges(3, 6, tree);     insertEdges(6, 9, tree);      int height[N + 1] = {0};     int vis[N + 1] = { 0 };      // call the bfs function     bfs(1, 0, height, vis, tree);      // Function to print     printLevelsOddEven(N, vis, height);      return 0; }
Java 
// Java program to print all levels // with odd and even number of nodes import java.util.*; public class Main {     // Function for BFS in a tree     static void bfs(int node, int parent, int[] height, int[] vis, Vector<Vector<Integer>> tree)     {         // Mark first node as visited         vis[node] = 1;                // Declare Queue         Queue<Integer> q = new LinkedList<>();                // Push the first element         q.add(1);                // Calculate the level of every node         height[node] = 1 + height[parent];                // Check if the queue is empty or not         while (q.size() != 0)         {                           // Get the top element in the queue             int top = (int)q.peek();                    // Pop the element             q.remove();                    // Mark as visited             vis[top] = 1;                    // Iterate for the connected nodes             for(int i = 0; i < tree.get(top).size(); i++)             {                                   // If not visited                 if (vis[(int)tree.get(top).get(i)] == 0)                 {                                           // Insert into queue                     q.add(tree.get(top).get(i));                            // Increase level                     height[(int)tree.get(top).get(i)] = 1 + height[top];                 }             }         }     }            // Function to insert edges     static void insertEdges(int x, int y, Vector<Vector<Integer>> tree)     {         tree.get(x).add(y);         tree.get(y).add(x);     }            // Function to print all levels     static void printLevelsOddEven(int N, int[] vis, int[] height)     {         int[] mark = new int[N + 1];         for(int i = 0; i < N + 1; i++)         {             mark[i] = 0;         }                int maxLevel = 0;         for(int i = 1; i <= N; i++)         {                           // Count number of nodes             // in every level             if (vis[i]!=0)                 mark[height[i]]++;                    // Find the maximum height of tree             maxLevel = Math.max(height[i], maxLevel);         }                // Print odd number of nodes         System.out.print("The levels with odd " +                       "number of nodes are: ");                   for(int i = 1; i <= maxLevel; i++)         {             if (mark[i] % 2 != 0)             {                 System.out.print(i + " ");             }         }                // print even number of nodes         System.out.println();         System.out.print("The levels with even " +                       "number of nodes are: ");                   for(int i = 1; i <= maxLevel; i++)         {             if (mark[i] % 2 == 0)             {                 System.out.print(i + " ");             }         }     }      public static void main(String[] args) {         // Construct the tree               /*   1            /   \           2     3          / \     \         4    5    6             / \  /            7   8 9  */                   int N = 9;                   Vector<Vector<Integer>> tree = new Vector<Vector<Integer>>();                   for(int i = 0; i < N + 1; i++)         {             tree.add(new Vector<Integer>());         }                   insertEdges(1, 2, tree);         insertEdges(1, 3, tree);         insertEdges(2, 4, tree);         insertEdges(2, 5, tree);         insertEdges(5, 7, tree);         insertEdges(5, 8, tree);         insertEdges(3, 6, tree);         insertEdges(6, 9, tree);                   int[] height = new int[N + 1];         int[] vis = new int[N + 1];         for(int i = 0; i < N + 1; i++)         {             vis[i] = 0;         }                   height[0] = 0;                   // Call the bfs function         bfs(1, 0, height, vis, tree);                   // Function to print         printLevelsOddEven(N, vis, height);     } }  // This code is contributed by divyeshrabadiya07.
Python3 
# Python3 program to print all levels  # with odd and even number of nodes   # Function for BFS in a tree  def bfs(node, parent, height, vis, tree):      # mark first node as visited      vis[node] = 1      # Declare Queue      q = []       # append the first element      q.append(1)       # calculate the level of every node      height[node] = 1 + height[parent]       # Check if the queue is empty or not      while (len(q)):          # Get the top element in          # the queue          top = q[0]           # pop the element          q.pop(0)           # mark as visited          vis[top] = 1          # Iterate for the connected nodes          for i in range(len(tree[top])):                           # if not visited              if (not vis[tree[top][i]]):                   # Insert into queue                  q.append(tree[top][i])                   # Increase level                  height[tree[top][i]] = 1 + height[top]   # Function to insert edges  def insertEdges(x, y, tree):      tree[x].append(y)      tree[y].append(x)      # Function to print all levels  def printLevelsOddEven(N, vis, height):      mark = [0] * (N + 1)      maxLevel = 0     for i in range(1, N + 1):           # count number of nodes          # in every level          if (vis[i]) :             mark[height[i]] += 1          # find the maximum height of tree          maxLevel = max(height[i], maxLevel)           # print odd number of nodes      print("The levels with odd number",           "of nodes are:", end = " ")     for i in range(1, maxLevel + 1):         if (mark[i] % 2):              print(i, end = " " )          # print even number of nodes      print("\nThe levels with even number",              "of nodes are:", end = " ")      for i in range(1, maxLevel ):          if (mark[i] % 2 == 0):              print(i, end = " ")  # Driver Code  if __name__ == '__main__':          # Construct the tree      """ 1      / \      2 3      / \ \      4 5 6          / \ /      7 8 9 """      N = 9      tree = [[0]] * (N + 1)      insertEdges(1, 2, tree)      insertEdges(1, 3, tree)      insertEdges(2, 4, tree)      insertEdges(2, 5, tree)      insertEdges(5, 7, tree)      insertEdges(5, 8, tree)      insertEdges(3, 6, tree)      insertEdges(6, 9, tree)       height = [0] * (N + 1)     vis = [0] * (N + 1)      # call the bfs function      bfs(1, 0, height, vis, tree)       # Function to print     printLevelsOddEven(N, vis, height)  # This code is contributed  # by SHUBHAMSINGH10
C# 
// C# program to print all levels // with odd and even number of nodes using System; using System.Collections;  class GFG{  // Function for BFS in a tree static void bfs(int node, int parent,                  int []height, int []vis,                 ArrayList []tree) {          // Mark first node as visited     vis[node] = 1;       // Declare Queue     Queue q = new Queue();       // Push the first element     q.Enqueue(1);       // Calculate the level of every node     height[node] = 1 + height[parent];       // Check if the queue is empty or not     while (q.Count != 0)     {                  // Get the top element in the queue         int top = (int)q.Peek();           // Pop the element         q.Dequeue();           // Mark as visited         vis[top] = 1;           // Iterate for the connected nodes         for(int i = 0; i < tree[top].Count; i++)          {                          // If not visited             if (vis[(int)tree[top][i]] == 0)             {                                  // Insert into queue                 q.Enqueue(tree[top][i]);                   // Increase level                 height[(int)tree[top][i]] = 1 + height[top];             }         }     } }   // Function to insert edges static void insertEdges(int x, int y, ArrayList []tree) {     tree[x].Add(y);     tree[y].Add(x); }   // Function to print all levels static void printLevelsOddEven(int N, int []vis,                                 int []height) {     int []mark = new int[N + 1];     Array.Fill(mark, 0);       int maxLevel = 0;     for(int i = 1; i <= N; i++)      {                  // Count number of nodes         // in every level         if (vis[i]!=0)             mark[height[i]]++;           // Find the maximum height of tree         maxLevel = Math.Max(height[i], maxLevel);     }       // Print odd number of nodes     Console.Write("The levels with odd " +                   "number of nodes are: ");          for(int i = 1; i <= maxLevel; i++)     {         if (mark[i] % 2 != 0)         {             Console.Write(i + " ");         }     }       // print even number of nodes     Console.Write("\nThe levels with even " +                    "number of nodes are: ");          for(int i = 1; i <= maxLevel; i++)     {         if (mark[i] % 2 == 0)         {             Console.Write(i + " ");         }     } }      // Driver code     static void Main()  {            // Construct the tree          /*   1        /   \       2     3      / \     \     4    5    6         / \  /        7   8 9  */          int N = 9;          ArrayList []tree = new ArrayList[N + 1];          for(int i = 0; i < N + 1; i++)     {         tree[i] = new ArrayList();     }          insertEdges(1, 2, tree);     insertEdges(1, 3, tree);     insertEdges(2, 4, tree);     insertEdges(2, 5, tree);     insertEdges(5, 7, tree);     insertEdges(5, 8, tree);     insertEdges(3, 6, tree);     insertEdges(6, 9, tree);          int []height = new int[N + 1];     int []vis = new int[N + 1];     Array.Fill(vis, 0);          height[0] = 0;          // Call the bfs function     bfs(1, 0, height, vis, tree);          // Function to print     printLevelsOddEven(N, vis, height); } }  // This code is contributed by rutvik_56
JavaScript 
<script>      // JavaScript program to print all levels     // with odd and even number of nodes           // Function for BFS in a tree     function bfs(node, parent, height, vis, tree)     {          // Mark first node as visited         vis[node] = 1;          // Declare Queue         let q = [];          // Push the first element         q.push(1);          // Calculate the level of every node         height[node] = 1 + height[parent];          // Check if the queue is empty or not         while (q.length != 0)         {              // Get the top element in the queue             let top = q[0];              // Pop the element             q.shift();              // Mark as visited             vis[top] = 1;              // Iterate for the connected nodes             for(let i = 0; i < tree[top].length; i++)             {                  // If not visited                 if (vis[tree[top][i]] == 0)                 {                      // Insert into queue                     q.push(tree[top][i]);                      // Increase level                     height[tree[top][i]] = 1 + height[top];                 }             }         }     }      // Function to insert edges     function insertEdges(x, y, tree)     {         tree[x].push(y);         tree[y].push(x);     }      // Function to print all levels     function printLevelsOddEven(N, vis, height)     {         let mark = new Array(N + 1);         mark.fill(0);          let maxLevel = 0;         for(let i = 1; i <= N; i++)         {              // Count number of nodes             // in every level             if (vis[i]!=0)                 mark[height[i]]++;              // Find the maximum height of tree             maxLevel = Math.max(height[i], maxLevel);         }          // Print odd number of nodes         document.write("The levels with odd " +                       "number of nodes are: ");          for(let i = 1; i <= maxLevel; i++)         {             if (mark[i] % 2 != 0)             {                 document.write(i + " ");             }         }          // print even number of nodes            document.write("</br>" + "The levels with even " +                       "number of nodes are: ");          for(let i = 1; i <= maxLevel; i++)         {             if (mark[i] % 2 == 0)             {                 document.write(i + " ");             }         }     }          // Construct the tree           /*   1        /   \       2     3      / \     \     4    5    6         / \  /        7   8 9  */           let N = 9;           let tree = new Array(N + 1);           for(let i = 0; i < N + 1; i++)     {         tree[i] = [];     }           insertEdges(1, 2, tree);     insertEdges(1, 3, tree);     insertEdges(2, 4, tree);     insertEdges(2, 5, tree);     insertEdges(5, 7, tree);     insertEdges(5, 8, tree);     insertEdges(3, 6, tree);     insertEdges(6, 9, tree);           let height = new Array(N + 1);     let vis = new Array(N + 1);     vis.fill(0);           height[0] = 0;           // Call the bfs function     bfs(1, 0, height, vis, tree);           // Function to print     printLevelsOddEven(N, vis, height);  </script>

Output
The levels with odd number of nodes are: 1 3 4  The levels with even number of nodes are: 2

complexity Analysis:

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

Next Article
Finding the path from one vertex to rest using BFS

S
Striver
Improve
Article Tags :
  • Tree
  • DSA
  • BFS
  • n-ary-tree
  • Traversal
Practice Tags :
  • BFS
  • Traversal
  • Tree

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