# Size of the Largest Trees in a Forest formed by the given Graph

• Difficulty Level : Hard
• Last Updated : 24 Sep, 2021

Given an undirected acyclic graph having N nodes and M edges, the task is to find the size of the largest tree in the forest formed by the graph.

A forest is a collection of disjoint trees. In other words, we can also say that forest is a collection of an acyclic graph which is not connected.

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.

Examples:

Input: N = 5, edges[][] = {{0, 1}, {0, 2}, {3, 4}}
Output:
Explanation:
There are 2 trees, each having size 3 and 2 respectively.

```   0
/   \
1     2```

and

```3
\
4```

Hence the size of the largest tree is 3.

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

Approach: The idea is to first count the number of reachable nodes from every forest. Therefore:

• Apply DFS on every node and obtain the size of the tree formed by this node and check if every connected node is visited from one source.
• If the size of the current tree is greater than the answer then update the answer to the current tree’s size.
• Again perform DFS traversal if some set of nodes are not yet visited.
• Finally, the max of all the answers when all the nodes are visited is the final answer.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the size``// of the largest tree in the forest` `#include ``using` `namespace` `std;` `// A utility function to add``// an edge in an undirected graph.``void` `addEdge(vector<``int``> adj[],``             ``int` `u, ``int` `v)``{``    ``adj[u].push_back(v);``    ``adj[v].push_back(u);``}` `// A utility function to perform DFS of a``// graph recursively from a given vertex u``// and returns the size of the tree formed by u``int` `DFSUtil(``int` `u, vector<``int``> adj[],``            ``vector<``bool``>& visited)``{``    ``visited[u] = ``true``;``    ``int` `sz = 1;` `    ``// Iterating through all the nodes``    ``for` `(``int` `i = 0; i < adj[u].size(); i++)``        ``if` `(visited[adj[u][i]] == ``false``)` `            ``// Perform DFS if the node is``            ``// not yet visited``            ``sz += DFSUtil(``                ``adj[u][i], adj, visited);``    ``return` `sz;``}` `// Function to return the  size of the``// largest tree in the forest given as``// the adjacency list``int` `largestTree(vector<``int``> adj[], ``int` `V)``{``    ``vector<``bool``> visited(V, ``false``);``    ``int` `answer = 0;` `    ``// Iterating through all the vertices``    ``for` `(``int` `u = 0; u < V; u++) {``        ``if` `(visited[u] == ``false``) {` `            ``// Find the answer``            ``answer``                ``= max(answer,``                      ``DFSUtil(u, adj, visited));``        ``}``    ``}``    ``return` `answer;``}` `// Driver code``int` `main()``{``    ``int` `V = 5;``    ``vector<``int``> adj[V];``    ``addEdge(adj, 0, 1);``    ``addEdge(adj, 0, 2);``    ``addEdge(adj, 3, 4);``    ``cout << largestTree(adj, V);``    ``return` `0;``}`

## Java

 `// Java program to find the size``// of the largest tree in the forest``import` `java.util.*;``class` `GFG{` `// A utility function to add``// an edge in an undirected graph.``static` `void` `addEdge(Vector adj[],``                    ``int` `u, ``int` `v)``{``  ``adj[u].add(v);``  ``adj[v].add(u);``}` `// A utility function to perform DFS of a``// graph recursively from a given vertex u``// and returns the size of the tree formed by u``static` `int` `DFSUtil(``int` `u, Vector adj[],``                   ``Vector visited)``{``  ``visited.add(u, ``true``);``  ``int` `sz = ``1``;` `  ``// Iterating through all the nodes``  ``for` `(``int` `i = ``0``; i < adj[u].size(); i++)``    ``if` `(visited.get(adj[u].get(i)) == ``false``)` `      ``// Perform DFS if the node is``      ``// not yet visited``      ``sz += DFSUtil(adj[u].get(i),``                    ``adj, visited);``  ``return` `sz;``}` `// Function to return the  size of the``// largest tree in the forest given as``// the adjacency list``static` `int` `largestTree(Vector adj[],``                       ``int` `V)``{``  ``Vector visited = ``new` `Vector<>();``  ``for``(``int` `i = ``0``; i < V; i++)``  ``{``    ``visited.add(``false``);``  ``}``  ``int` `answer = ``0``;` `  ``// Iterating through all the vertices``  ``for` `(``int` `u = ``0``; u < V; u++)``  ``{``    ``if` `(visited.get(u) == ``false``)``    ``{``      ``// Find the answer``      ``answer = Math.max(answer,``               ``DFSUtil(u, adj, visited));``    ``}``  ``}``  ``return` `answer;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``  ``int` `V = ``5``;``  ``Vector adj[] = ``new` `Vector[V];``  ``for` `(``int` `i = ``0``; i < adj.length; i++)``    ``adj[i] = ``new` `Vector();``  ``addEdge(adj, ``0``, ``1``);``  ``addEdge(adj, ``0``, ``2``);``  ``addEdge(adj, ``3``, ``4``);``  ``System.out.print(largestTree(adj, V));``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to find the size``# of the largest tree in the forest`` ` `# A utility function to add``# an edge in an undirected graph.``def` `addEdge(adj, u, v):` `    ``adj[u].append(v)``    ``adj[v].append(u)` `# A utility function to perform DFS of a``# graph recursively from a given vertex u``# and returns the size of the tree formed by u``def` `DFSUtil(u, adj, visited):``    ` `    ``visited[u] ``=` `True``    ``sz ``=` `1`` ` `    ``# Iterating through all the nodes``    ``for` `i ``in` `range``(``0``, ``len``(adj[u])):``        ``if` `(visited[adj[u][i]] ``=``=` `False``):`` ` `            ``# Perform DFS if the node is``            ``# not yet visited``            ``sz ``+``=` `DFSUtil(adj[u][i], adj, visited)``            ` `    ``return` `sz` `# Function to return the  size of the``# largest tree in the forest given as``# the adjacency list``def` `largestTree(adj, V):``    ` `    ``visited ``=` `[``False` `for` `i ``in` `range``(V)]``    ` `    ``answer ``=` `0`` ` `    ``# Iterating through all the vertices``    ``for` `u ``in` `range``(V):``        ``if` `(visited[u] ``=``=` `False``):`` ` `            ``# Find the answer``            ``answer ``=` `max``(answer,DFSUtil(``                ``u, adj, visited))``        ` `    ``return` `answer` `# Driver code``if` `__name__``=``=``"__main__"``:` `    ``V ``=` `5``    ` `    ``adj ``=` `[[] ``for` `i ``in` `range``(V)]``    ` `    ``addEdge(adj, ``0``, ``1``)``    ``addEdge(adj, ``0``, ``2``)``    ``addEdge(adj, ``3``, ``4``)``    ` `    ``print``(largestTree(adj, V))``    ` `# This code is contributed by rutvik_56`

## C#

 `// C# program to find the size``// of the largest tree in the forest``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// A utility function to add``// an edge in an undirected graph.``static` `void` `addEdge(List<``int``> []adj,``                    ``int` `u, ``int` `v)``{``  ``adj[u].Add(v);``  ``adj[v].Add(u);``}` `// A utility function to perform DFS of a``// graph recursively from a given vertex u``// and returns the size of the tree formed by u``static` `int` `DFSUtil(``int` `u, List<``int``> []adj,``                   ``List visited)``{``  ``visited.Insert(u, ``true``);``  ``int` `sz = 1;` `  ``// Iterating through all the nodes``  ``for` `(``int` `i = 0; i < adj[u].Count; i++)``    ``if` `(visited[adj[u][i]] == ``false``)` `      ``// Perform DFS if the node is``      ``// not yet visited``      ``sz += DFSUtil(adj[u][i],``                    ``adj, visited);``  ``return` `sz;``}` `// Function to return the  size of the``// largest tree in the forest given as``// the adjacency list``static` `int` `largestTree(List<``int``> []adj,``                       ``int` `V)``{``  ``List visited = ``new` `List();``  ``for``(``int` `i = 0; i < V; i++)``  ``{``    ``visited.Add(``false``);``  ``}``  ``int` `answer = 0;` `  ``// Iterating through all the vertices``  ``for` `(``int` `u = 0; u < V; u++)``  ``{``    ``if` `(visited[u] == ``false``)``    ``{``      ``// Find the answer``      ``answer = Math.Max(answer,``               ``DFSUtil(u, adj, visited));``    ``}``  ``}``  ``return` `answer;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``  ``int` `V = 5;``  ``List<``int``> []adj = ``new` `List<``int``>[V];``  ` `  ``for` `(``int` `i = 0; i < adj.Length; i++)``    ``adj[i] = ``new` `List<``int``>();``  ` `  ``addEdge(adj, 0, 1);``  ``addEdge(adj, 0, 2);``  ``addEdge(adj, 3, 4);``  ``Console.Write(largestTree(adj, V));``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``
Output:
`3`

Time Complexity: O(V + E), where V is the number of vertices and E is the number of edges.

My Personal Notes arrow_drop_up