# Program to print all the non-reachable nodes | Using BFS

• Difficulty Level : Hard
• Last Updated : 26 Nov, 2020

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 are reachable. We mark all the reachable nodes as visited. All those nodes which are not marked as visited i.e, node 3 and 4 are non-reachable nodes.

Examples:

```Input: 5
0 1
0 2
1 2
3 4
Output: 3 4

Input: 8
0 1
0 2
1 2
3 4
4 5
6 7
Output: 3 4 5 6 7```

Approach:

• We can either use BFS or DFS for this purpose. Set 1 of this article implements the DFS approach. In this article, BFS approach is used.
• We do BFS from a given source. Since the given graph is undirected, all the vertices that belong to the disconnected component are non-reachable nodes. We use the visited array for this purpose, the array which is used to keep track of non-visited vertices in BFS.
• BFS is a traversing algorithm which starts traversing from a selected node (source or starting node) and traverses the graph layer-wise thus exploring the neighbour nodes (nodes which are directly connected to source node). Then, move towards the next-level neighbour nodes.

Below is the implementation of the above approach:

## C++

 `// C++ program to count non-reachable nodes``// from a given source using BFS.` `#include ``using` `namespace` `std;` `// Function to add an edge to graph``void` `add_edge(vector<``int``> adj[],``              ``int` `v, ``int` `w)``{``    ``// Add w to v’s list.``    ``adj[v].push_back(w);` `    ``// Add v to w's list.``    ``adj[w].push_back(v);``}` `// BFS traversal of the vertices``// reachable from starting node``void` `BFS(vector<``int``> adj[], ``int` `s,``         ``int` `v)``{``    ``// Mark all the vertices``    ``// as not visited``    ``bool` `visited[v] = { ``false` `};` `    ``// Create a queue for BFS``    ``queue<``int``> q;` `    ``// Mark the current node as``    ``// visited and enqueue it``    ``q.push(s);``    ``visited[s] = ``true``;` `    ``while` `(!q.empty()) {``        ``// Dequeue a vertex from``        ``// queue``        ``int` `p = q.front();``        ``q.pop();` `        ``// Get all adjacent vertices``        ``// of the dequeued vertex p.``        ``// If a adjacent has not been``        ``// visited, then mark it``        ``// visited and enqueue it``        ``for` `(``auto` `it = adj[p].begin();``             ``it != adj[p].end(); it++) {``            ``if` `(!visited[*it]) {``                ``visited[*it] = ``true``;``                ``q.push(*it);``            ``}``        ``}``    ``}``    ``for` `(``int` `i = 0; i < v; i++) {``        ``if` `(!visited[i]) {``            ``cout << i << ``" "``;``        ``}``    ``}``    ``cout << ``"\n"``;``}` `// Drivers code``int` `main()``{``    ``// Create a graph given in``    ``// the above diagram``    ``vector<``int``> adj;``    ``add_edge(adj, 0, 1);``    ``add_edge(adj, 0, 2);``    ``add_edge(adj, 1, 2);``    ``add_edge(adj, 3, 4);``    ``add_edge(adj, 4, 5);``    ``add_edge(adj, 6, 7);` `    ``BFS(adj, 0, 8);` `    ``return` `0;``}`

## Java

 `// Java program to count non-reachable nodes``// from a given source using BFS.``import` `java.util.*;` `class` `GFG{`` ` `// Function to add an edge to graph``static` `void` `add_edge(Vector adj[],``              ``int` `v, ``int` `w)``{``    ``// Add w to v’s list.``    ``adj[v].add(w);`` ` `    ``// Add v to w's list.``    ``adj[w].add(v);``}`` ` `// BFS traversal of the vertices``// reachable from starting node``static` `void` `BFS(Vector adj[], ``int` `s,``         ``int` `v)``{``    ``// Mark all the vertices``    ``// as not visited``    ``boolean` `[]visited = ``new` `boolean``[v];`` ` `    ``// Create a queue for BFS``    ``Queue q = ``new` `LinkedList<>();`` ` `    ``// Mark the current node as``    ``// visited and enqueue it``    ``q.add(s);``    ``visited[s] = ``true``;`` ` `    ``while` `(!q.isEmpty()) {` `        ``// Dequeue a vertex from``        ``// queue``        ``int` `p = q.peek();``        ``q.remove();`` ` `        ``// Get all adjacent vertices``        ``// of the dequeued vertex p.``        ``// If a adjacent has not been``        ``// visited, then mark it``        ``// visited and enqueue it``        ``for` `(``int` `it : adj[p]) {``            ``if` `(!visited[it]) {``                ``visited[it] = ``true``;``                ``q.add(it);``            ``}``        ``}``    ``}``    ``for` `(``int` `i = ``0``; i < v; i++) {``        ``if` `(!visited[i]) {``            ``System.out.print(i+ ``" "``);``        ``}``    ``}``    ``System.out.print(``"\n"``);``}`` ` `// Drivers code``public` `static` `void` `main(String[] args)``{``    ``// Create a graph given in``    ``// the above diagram``    ``Vector []adj = ``new` `Vector[``8``];``    ``for` `(``int` `i = ``0``; i < ``8``; i++)``        ``adj[i] = ``new` `Vector();``    ``add_edge(adj, ``0``, ``1``);``    ``add_edge(adj, ``0``, ``2``);``    ``add_edge(adj, ``1``, ``2``);``    ``add_edge(adj, ``3``, ``4``);``    ``add_edge(adj, ``4``, ``5``);``    ``add_edge(adj, ``6``, ``7``);`` ` `    ``BFS(adj, ``0``, ``8``);`` ` `}``}` `// This code is contributed by sapnasingh4991`

## Python3

 `# Python3 program to count non-reachable``# nodes from a given source using BFS` `# Function to add an edge to graph``def` `add_edge(adj, v, w):``    ` `    ``# Add w to v’s list``    ``adj[v].append(w)` `    ``# Add v to w's list``    ``adj[w].append(v)` `# BFS traversal of the vertices``# reachable from starting node``def` `BFS(adj, s, v):` `    ``# Mark all the vertices``    ``# as not visited``    ``visited ``=` `[``False` `for` `i ``in` `range``(v)]` `    ``# Create a queue for BFS``    ``q ``=` `[]` `    ``# Mark the current node as``    ``# visited and enqueue it``    ``q.append(s)``    ``visited[s] ``=` `True` `    ``while` `(``len``(q) !``=` `0``):``      ` `        ``# Dequeue a vertex from``        ``# queue``        ``p ``=` `q[``0``]``        ``q.pop(``0``)` `        ``# Get all adjacent vertices``        ``# of the dequeued vertex p.``        ``# If a adjacent has not been``        ``# visited, then mark it``        ``# visited and enqueue it``        ``for` `it ``in` `adj[p]:``            ``if` `(``not` `visited[it]):``                ``visited[it] ``=` `True``                ``q.append(it)``            ` `    ``for` `i ``in` `range``(v):``        ``if` `(``not` `visited[i]):``            ``print``(i, end ``=` `' '``)``            ` `    ``print``()``    ` `# Driver code``if` `__name__``=``=``'__main__'``:` `    ``# Create a graph given in``    ``# the above diagram``    ``adj ``=` `[[] ``for` `i ``in` `range``(``8``)]``    ` `    ``add_edge(adj, ``0``, ``1``)``    ``add_edge(adj, ``0``, ``2``)``    ``add_edge(adj, ``1``, ``2``)``    ``add_edge(adj, ``3``, ``4``)``    ``add_edge(adj, ``4``, ``5``)``    ``add_edge(adj, ``6``, ``7``)``    ` `    ``BFS(adj, ``0``, ``8``)` `# This code is contributed by rutvik_56`

## C#

 `// C# program to count non-reachable nodes``// from a given source using BFS.``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``  ` `// Function to add an edge to graph``static` `void` `add_edge(List<``int``> []adj,``              ``int` `v, ``int` `w)``{``    ``// Add w to v’s list.``    ``adj[v].Add(w);``  ` `    ``// Add v to w's list.``    ``adj[w].Add(v);``}``  ` `// BFS traversal of the vertices``// reachable from starting node``static` `void` `BFS(List<``int``> []adj, ``int` `s,``         ``int` `v)``{``    ``// Mark all the vertices``    ``// as not visited``    ``bool` `[]visited = ``new` `bool``[v];``  ` `    ``// Create a queue for BFS``    ``List<``int``> q = ``new` `List<``int``>();``  ` `    ``// Mark the current node as``    ``// visited and enqueue it``    ``q.Add(s);``    ``visited[s] = ``true``;``  ` `    ``while` `(q.Count != 0) {`` ` `        ``// Dequeue a vertex from``        ``// queue``        ``int` `p = q;``        ``q.RemoveAt(0);``  ` `        ``// Get all adjacent vertices``        ``// of the dequeued vertex p.``        ``// If a adjacent has not been``        ``// visited, then mark it``        ``// visited and enqueue it``        ``foreach` `(``int` `it ``in` `adj[p]) {``            ``if` `(!visited[it]) {``                ``visited[it] = ``true``;``                ``q.Add(it);``            ``}``        ``}``    ``}``    ``for` `(``int` `i = 0; i < v; i++) {``        ``if` `(!visited[i]) {``            ``Console.Write(i + ``" "``);``        ``}``    ``}``    ``Console.Write(``"\n"``);``}``  ` `// Driver's code``public` `static` `void` `Main(String[] args)``{``    ``// Create a graph given in``    ``// the above diagram``    ``List<``int``> []adj = ``new` `List<``int``>;``    ``for` `(``int` `i = 0; i < 8; i++)``        ``adj[i] = ``new` `List<``int``>();``    ``add_edge(adj, 0, 1);``    ``add_edge(adj, 0, 2);``    ``add_edge(adj, 1, 2);``    ``add_edge(adj, 3, 4);``    ``add_edge(adj, 4, 5);``    ``add_edge(adj, 6, 7);``  ` `    ``BFS(adj, 0, 8);``}``}` `// This code is contributed by 29AjayKumar`
Output:
`3 4 5 6 7`

My Personal Notes arrow_drop_up