Count the number of non-reachable nodes

Given an undirected graph and a set of vertices, we have to count the number of non-reachable nodes from the given head node using a depth-first search.

Consider below undirected graph with two disconnected components:

not-reachable



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. Hence their count is 2.

Example:

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

We can either use BFS or DFS for this purpose. In the below implementation, DFS is used. We do DFS 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 DFS. In DFS, if we start from the head node it will mark all the nodes connected to the head node as visited. Then after traversing the graph, we count the number of nodes that are not marked as visited from the head node.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count non-reachable nodes
// from a given source using DFS.
#include <iostream>
#include <list>
using namespace std;
  
// Graph class represents a directed graph
// using adjacency list representation
class Graph {
    int V; // No. of vertices
  
    // Pointer to an array containing
    // adjacency lists
    list<int>* adj;
  
    // A recursive function used by DFS
    void DFSUtil(int v, bool visited[]);
  
public:
    Graph(int V); // Constructor
  
    // function to add an edge to graph
    void addEdge(int v, int w);
  
    // DFS traversal of the vertices
    // reachable from v
    int countNotReach(int v);
};
  
Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];
}
  
void Graph::addEdge(int v, int w)
{
    adj[v].push_back(w); // Add w to v’s list.
    adj[w].push_back(v); // Add v to w's list.
}
  
void Graph::DFSUtil(int v, bool visited[])
{
    // Mark the current node as visited and
    // print it
    visited[v] = true;
  
    // Recur for all the vertices adjacent
    // to this vertex
    list<int>::iterator i;
    for (i = adj[v].begin(); i != adj[v].end(); ++i)
        if (!visited[*i])
            DFSUtil(*i, visited);
}
  
// Returns count of not reachable nodes from
// vertex v.
// It uses recursive DFSUtil()
int Graph::countNotReach(int v)
{
    // Mark all the vertices as not visited
    bool* visited = new bool[V];
    for (int i = 0; i < V; i++)
        visited[i] = false;
  
    // Call the recursive helper function
    // to print DFS traversal
    DFSUtil(v, visited);
  
    // Return count of not visited nodes
    int count = 0;
    for (int i = 0; i < V; i++) {
        if (visited[i] == false)
            count++;
    }
    return count;
}
  
int main()
{
    // Create a graph given in the above diagram
    Graph g(8);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(3, 4);
    g.addEdge(4, 5);
    g.addEdge(6, 7);
  
    cout << g.countNotReach(2);
  
    return 0;
}

chevron_right






                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 program to count non-reachable  


# nodes from a given source using DFS.  


  


# Graph class represents a directed graph  


# using adjacency list representation  


class Graph: 


    def __init__(self, V): 


        self.V = V 


        self.adj = [[] for i in range(V)] 


  


    def addEdge(self, v, w): 


        self.adj[v].append(w) # Add w to v’s list.  


        self.adj[w].append(v) # Add v to w's list. 


      


    def DFSUtil(self, v, visited): 


          


        # Mark the current node as  


        # visited and print it  


        visited[v] = True


      


        # Recur for all the vertices  


        # adjacent to this vertex 


        i = self.adj[v][0] 


        while i != self.adj[v][-1]: 


            if (not visited[i]): 


                self.DFSUtil(i, visited) 


            i += 1


      


    # Returns count of not reachable  


    # nodes from vertex v.  


    # It uses recursive DFSUtil()  


    def countNotReach(self, v): 


          


        # Mark all the vertices as not visited  


        visited = [False] * self.V 


      


        # Call the recursive helper  


        # function to prDFS traversal  


        self.DFSUtil(v, visited)  


      


        # Return count of not visited nodes  


        count = 0


        for i in range(self.V): 


            if (visited[i] == False):  


                count += 1


        return count 


  


# Driver Code 


if __name__ == '__main__': 


  


    # Create a graph given in the 


    # above diagram  


    g = Graph(8)  


    g.addEdge(0, 1)  


    g.addEdge(0, 2)  


    g.addEdge(1, 2)  


    g.addEdge(3, 4)  


    g.addEdge(4, 5)  


    g.addEdge(6, 7)  


  


    print(g.countNotReach(2)) 


  


# This code is contributed by PranchalK 



















                        chevron_right







                        filter_none










Output: 


 5









          
          
          
          

            

    

        My Personal Notes
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
shivani.mittal
Check out this Author's contributed articles.
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on  the "Improve Article" button below.



      
      
      
      

      

      
					
		

    Article Tags : 
Graph

           	
Practice Tags : 
DFS
Graph

        

         

         
 
                2

                

        



        
        
        
        
        

    

            

            1.8
            

            

             
                 Based on 10 vote(s)
                    

            
            
            
            
            
        

        
        

        

        

        

        

        

        


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.