Given a tree with **N** nodes value from **1** to **N** and **(N – 1)** Edges and a number **K**, the task is to remove the minimum number of nodes from the tree such that every subtree will have at most **K** nodes. Removing Nodes will remove the edges from that nodes to all the other connected nodes.

**Examples:**

Input:N = 10, K = 3, Below is the graph:

Output:

Number of nodes removed: 2

Removed Nodes: 2 1Explanation:

After removing the nodes 1 and 2, here, no subtree or tree has more than 3 nodes. Below is the resulting graph:

Input:N = 6, K = 3, Below is the graph:

Output:

Number of nodes removed: 1

Removed Nodes: 1Explanation:

After removing the nodes 1, here, no subtree or tree has more than 3 nodes. Below is the resulting graph:

**Approach:** The idea is to observe that the number of nodes in the subtree of a node X is the **sum** of the number of nodes in the subtree of its children and the node itself. Below are the steps:

- Use Dynamic Programming and DFS to store the
**count**of nodes in the subtree of each node easily. - Now, to have no node with subtree having more than K nodes, the idea is to remove the node whenever it has more than K nodes in its subtree, and pass 0 to its parent.
- In the above step, we are having each node with nodes in its subtree not greater than K and minimizing the number of node removals.

Below is the implementation of the above approach:

`// Java program for the above approach` `import` `java.util.*;`
`class` `GFG {`
` ` `// Variables used to store data globally`
` ` `static` `final` `int` `N = ` `20` `;`
` ` `static` `boolean` `visited[] = ` `new` `boolean` `[N];`
` ` `static` `int` `K;`
` ` `static` `int` `removals = ` `0` `;`
` ` `static` `ArrayList<Integer> removed_nodes`
` ` `= ` `new` `ArrayList<>();`
` ` `// Adjacency list representation of tree`
` ` `static` `ArrayList<ArrayList<Integer> > adj`
` ` `= ` `new` `ArrayList<>();`
` ` `// Function to perform DFS Traversal`
` ` `static` `int` `dfs(` `int` `s)`
` ` `{`
` ` `// Mark the node as true`
` ` `visited[s] = ` `true` `;`
` ` `int` `nodes = ` `1` `;`
` ` `// Traverse adjacency list`
` ` `// of child node`
` ` `for` `(Integer child : adj.get(s)) {`
` ` `// If already visited then`
` ` `// omit the node`
` ` `if` `(visited[child])`
` ` `continue` `;`
` ` `// Add number of nodes`
` ` `// in subtree`
` ` `nodes += dfs(child);`
` ` `}`
` ` `if` `(nodes > K) {`
` ` `// Increment the count`
` ` `removals++;`
` ` `removed_nodes.add(s);`
` ` `nodes = ` `0` `;`
` ` `}`
` ` `// Return the nodes`
` ` `return` `nodes;`
` ` `}`
` ` `// Function to add edges in graph`
` ` `static` `void` `addEdge(` `int` `a, ` `int` `b)`
` ` `{`
` ` `adj.get(a).add(b);`
` ` `adj.get(b).add(a);`
` ` `}`
` ` `// Function that finds the number`
` ` `// of nodes to be removed such that`
` ` `// every subtree has size at most K`
` ` `public` `static` `void` `findRemovedNodes(` `int` `K)`
` ` `{`
` ` `// Function Call to find the`
` ` `// number of nodes to remove`
` ` `dfs(` `1` `);`
` ` `// Print Removed Nodes`
` ` `System.out.println(` `"Number of nodes"`
` ` `+ ` `" removed: "`
` ` `+ removals);`
` ` `System.out.print(` `"Removed Nodes: "` `);`
` ` `for` `(` `int` `node : removed_nodes)`
` ` `System.out.print(node + ` `" "` `);`
` ` `}`
` ` `// Driver Code`
` ` `public` `static` `void` `main(String[] args)`
` ` `{`
` ` `// Creating list for all nodes`
` ` `for` `(` `int` `i = ` `0` `; i < N; i++)`
` ` `adj.add(` `new` `ArrayList<>());`
` ` `// Insert of nodes in graph`
` ` `addEdge(` `1` `, ` `2` `);`
` ` `addEdge(` `1` `, ` `3` `);`
` ` `addEdge(` `2` `, ` `4` `);`
` ` `addEdge(` `2` `, ` `5` `);`
` ` `addEdge(` `3` `, ` `6` `);`
` ` `// Required subtree size`
` ` `K = ` `3` `;`
` ` `// Function Call`
` ` `findRemovedNodes(K);`
` ` `}`
`}` |

*chevron_right*

*filter_none*

`# Python3 program for the above approach` `# Variables used to store data globally` `N ` `=` `20`
`visited ` `=` `[` `False` `for` `i ` `in` `range` `(N)]`
`K ` `=` `0`
`removals ` `=` `0`
`removed_nodes ` `=` `[]`
`# Adjacency list representation of tree` `adj ` `=` `[[] ` `for` `i ` `in` `range` `(N)]`
`# Function to perform DFS Traversal` `def` `dfs(s):`
` ` ` ` `global` `removals`
` ` ` ` `# Mark the node as true`
` ` `visited[s] ` `=` `True`
` ` `nodes ` `=` `1`
` ` `# Traverse adjacency list`
` ` `# of child node`
` ` `for` `child ` `in` `adj[s]:`
` ` `# If already visited then`
` ` `# omit the node`
` ` `if` `(visited[child]):`
` ` `continue`
` ` `# Add number of nodes`
` ` `# in subtree`
` ` `nodes ` `+` `=` `dfs(child)`
` ` `if` `(nodes > K):`
` ` `# Increment the count`
` ` `removals ` `+` `=` `1`
` ` `removed_nodes.append(s)`
` ` `nodes ` `=` `0`
` ` `# Return the nodes`
` ` `return` `nodes`
`# Function to add edges in graph` `def` `addEdge(a, b):`
` ` `adj[a].append(b)`
` ` `adj[b].append(a)`
`# Function that finds the number` `# of nodes to be removed such that` `# every subtree has size at most K` `def` `findRemovedNodes(K):`
` ` `# Function Call to find the`
` ` `# number of nodes to remove`
` ` `dfs(` `1` `)`
` ` `# Print Removed Nodes`
` ` `print` `(` `"Number of nodes removed: "` `, removals)`
` ` `print` `(` `"Removed Nodes: "` `, end ` `=` `' '` `)`
` ` ` ` `for` `node ` `in` `removed_nodes:`
` ` `print` `(node, end ` `=` `' '` `)`
` ` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:`
` ` `# Insert of nodes in graph`
` ` `addEdge(` `1` `, ` `2` `)`
` ` `addEdge(` `1` `, ` `3` `)`
` ` `addEdge(` `2` `, ` `4` `)`
` ` `addEdge(` `2` `, ` `5` `)`
` ` `addEdge(` `3` `, ` `6` `)`
` ` `# Required subtree size`
` ` `K ` `=` `3`
` ` `# Function Call`
` ` `findRemovedNodes(K)`
`# This code is contributed by rutvik_56` |

*chevron_right*

*filter_none*

`// C# program for the above approach` `using` `System;`
`using` `System.Collections.Generic;`
`class` `GFG{`
` ` `// Variables used to store data globally`
` ` `static` `readonly` `int` `N = 20;`
` ` `static` `bool` `[]visited = ` `new` `bool` `[N];`
` ` `static` `int` `K;`
` ` `static` `int` `removals = 0;`
` ` `static` `List<` `int` `> removed_nodes`
` ` `= ` `new` `List<` `int` `>();`
` ` `// Adjacency list representation of tree`
` ` `static` `List<List<` `int` `> > adj`
` ` `= ` `new` `List<List<` `int` `>>();`
` ` `// Function to perform DFS Traversal`
` ` `static` `int` `dfs(` `int` `s)`
` ` `{`
` ` `// Mark the node as true`
` ` `visited[s] = ` `true` `;`
` ` `int` `nodes = 1;`
` ` `// Traverse adjacency list`
` ` `// of child node`
` ` `foreach` `(` `int` `child ` `in` `adj[s]) `
` ` `{`
` ` `// If already visited then`
` ` `// omit the node`
` ` `if` `(visited[child])`
` ` `continue` `;`
` ` `// Add number of nodes`
` ` `// in subtree`
` ` `nodes += dfs(child);`
` ` `}`
` ` `if` `(nodes > K)`
` ` `{`
` ` `// Increment the count`
` ` `removals++;`
` ` `removed_nodes.Add(s);`
` ` `nodes = 0;`
` ` `}`
` ` `// Return the nodes`
` ` `return` `nodes;`
` ` `}`
` ` `// Function to add edges in graph`
` ` `static` `void` `addEdge(` `int` `a, ` `int` `b)`
` ` `{`
` ` `adj[a].Add(b);`
` ` `adj[b].Add(a);`
` ` `}`
` ` `// Function that finds the number`
` ` `// of nodes to be removed such that`
` ` `// every subtree has size at most K`
` ` `public` `static` `void` `findRemovedNodes(` `int` `K)`
` ` `{`
` ` `// Function Call to find the`
` ` `// number of nodes to remove`
` ` `dfs(1);`
` ` `// Print Removed Nodes`
` ` `Console.WriteLine(` `"Number of nodes"` `+ `
` ` `" removed: "` `+`
` ` `removals);`
` ` `Console.Write(` `"Removed Nodes: "` `);`
` ` `foreach` `(` `int` `node ` `in` `removed_nodes)`
` ` `Console.Write(node + ` `" "` `);`
` ` `}`
` ` `// Driver Code`
` ` `public` `static` `void` `Main(String[] args)`
` ` `{`
` ` `// Creating list for all nodes`
` ` `for` `(` `int` `i = 0; i < N; i++)`
` ` `adj.Add(` `new` `List<` `int` `>());`
` ` `// Insert of nodes in graph`
` ` `addEdge(1, 2);`
` ` `addEdge(1, 3);`
` ` `addEdge(2, 4);`
` ` `addEdge(2, 5);`
` ` `addEdge(3, 6);`
` ` `// Required subtree size`
` ` `K = 3;`
` ` `// Function Call`
` ` `findRemovedNodes(K);`
` ` `}`
`}` `// This code is contributed by Rohit_ranjan` |

*chevron_right*

*filter_none*

**Output:**

Number of nodes removed: 1 Removed Nodes: 1

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

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.

## Recommended Posts:

- Queries for the number of nodes having values less than V in the subtree of a Node
- Node having maximum number of nodes less than its value in its subtree
- Remove minimum elements from either side such that 2*min becomes more than max
- Remove minimum elements from either side such that 2*min becomes more than max | Set 2
- Given a n-ary tree, count number of nodes which have more number of children than parents
- Count pairs (A, B) such that A has X and B has Y number of set bits and A+B = C
- Convert a Binary Tree such that every node stores the sum of all nodes in its right subtree
- Queries to find the Minimum Weight from a Subtree of atmost D-distant Nodes from Node X
- Number of sub-sequence such that it has one consecutive element with difference less than or equal to 1
- Number of unique paths in tree such that every path has a value greater than K
- Minimum nodes to be colored in a Graph such that every node has a colored neighbour
- Minimum labelled node to be removed from undirected Graph such that there is no cycle
- Number of leaf nodes in the subtree of every node of an n-ary tree
- Change a Binary Tree so that every node stores sum of all nodes in left subtree
- Subtree of all nodes in a tree using DFS
- Check if two nodes are in same subtree of the root node
- Count of nodes having odd divisors in the given subtree for Q queries
- Count of Numbers in Range where the number does not contain more than K non zero digits
- Minimum number of edges required to be removed from an Undirected Graph to make it acyclic
- Smallest submatrix required to be removed such that sum of the remaining matrix is divisible by K

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.