Skip to content
Related Articles

Related Articles

Improve Article

Queries for M-th node in the DFS of subtree

  • Difficulty Level : Hard
  • Last Updated : 27 Aug, 2021
Geek Week

Given a tree of N nodes and N-1 edges. Also given an integer M and a node, the task is to print the M-th node in the DFS of the subtree of a given node for multiple queries. 

Note: M will not be greater than the number of nodes in the subtree of the given node.

Input: M = 3, node = 1 
Output:
In the above example if 1 is given as the node, then the DFS of subtree will be 1 2 4 6 7 5 3, hence if M is 3, then the 3rd node is 4 

Input: M = 4, node = 2 
Output:
If 2 is given as the node, then the DFS of the subtree will be 2 4 6 7 5., hence if M is 4 then the 4th node is 7.



Approach: 

  • Add the edges between the nodes in an adjacency list.
  • Call DFS function to generate the DFS of the complete tree.
  • Use an under[] array to store the height of the subtree under the given node including the node.
  • In the DFS function, keep incrementing the size of subtree on every recursive call.
  • Mark the node index in the DFS of complete using hashing.
  • Let index of given node in the DFS of the tree be ind, then the M-th node will be at index ind + M -1 as the DFS of a subtree of a node will always be a contiguous subarray starting from the node.

Below is the implementation of the above approach.

C++




// C++ program for Queries
// for DFS of subtree of a node in a tree
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
 
// Adjacency list to store the
// tree nodes connection
vector<int> v[N];
 
// stores the index of node in DFS
unordered_map<int, int> mp;
 
// stores the index of node in
// original node
vector<int> a;
 
// Function to call DFS and count nodes
// under that subtree
void dfs(int under[], int child, int parent)
{
 
    // stores the DFS of tree
    a.push_back(child);
 
    // height of subtree
    under[child] = 1;
 
    // iterate for children
    for (auto it : v[child]) {
 
        // if not equal to parent
        // so that it does not traverse back
        if (it != parent) {
 
            // call DFS for subtree
            dfs(under, it, child);
 
            // add the height
            under[child] += under[it];
        }
    }
}
 
// Function to return the DFS of subtree of node
int printnodeDFSofSubtree(int node, int under[], int m)
{
    // index of node in the original DFS
    int ind = mp[node];
 
    // height of subtree of node
    return a[ind + m - 1];
}
 
// Function to add edges to a tree
void addEdge(int x, int y)
{
    v[x].push_back(y);
    v[y].push_back(x);
}
 
// Marks the index of node in original DFS
void markIndexDfs()
{
    int size = a.size();
 
    // marks the index
    for (int i = 0; i < size; i++) {
        mp[a[i]] = i;
    }
}
 
// Driver Code
int main()
{
    int n = 7;
 
    // add edges of a tree
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
    addEdge(4, 6);
    addEdge(4, 7);
 
    // array to store the height of subtree
    // of every node in a tree
    int under[n + 1];
 
    // Call the function DFS to generate the DFS
    dfs(under, 1, 0);
 
    // Function call to mark the index of node
    markIndexDfs();
 
    int m = 3;
 
    // Query 1
    cout << printnodeDFSofSubtree(1, under, m) << endl;
 
    // Query 2
    m = 4;
    cout << printnodeDFSofSubtree(2, under, m);
 
    return 0;
}

Java




// Java program for Queries for
// DFS of subtree of a node in a tree
import java.util.*;
 
class GFG{
     
// Adjacency list to store the
// tree nodes connection
static ArrayList<ArrayList<Integer>> v;
 
// Stores the index of node in DFS
static HashMap<Integer, Integer> mp;
 
// Stores the index of node in
// original node
static ArrayList<Integer> a;
 
// Function to call DFS and count nodes
// under that subtree
static void dfs(int under[], int child,
                int parent)
{
 
    // Stores the DFS of tree
    a.add(child);
 
    // Height of subtree
    under[child] = 1;
 
    // iterate for children
    for(int it : v.get(child))
    {
 
        // If not equal to parent
        // so that it does not traverse back
        if (it != parent)
        {
 
            // Call DFS for subtree
            dfs(under, it, child);
 
            // Add the height
            under[child] += under[it];
        }
    }
}
 
// Function to return the DFS of subtree of node
static int printnodeDFSofSubtree(int node,
                                 int under[],
                                 int m)
{
     
    // Index of node in the original DFS
    int ind = mp.get(node);
 
    // Height of subtree of node
    return a.get(ind + m - 1);
}
 
// Function to add edges to a tree
static void addEdge(int x, int y)
{
    v.get(x).add(y);
    v.get(y).add(x);
}
 
// Marks the index of node in original DFS
static void markIndexDfs()
{
    int size = a.size();
 
    // Marks the index
    for(int i = 0; i < size; i++)
    {
        mp.put(a.get(i), i);
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int n = 7;
 
    mp = new HashMap<>();
    v = new ArrayList<>();
    a = new ArrayList<>();
     
    for(int i = 0; i < n + 1; i++)
        v.add(new ArrayList<>());
         
    // Add edges of a tree
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
    addEdge(4, 6);
    addEdge(4, 7);
 
    // Array to store the height of subtree
    // of every node in a tree
    int under[] = new int[n + 1];
     
    // Call the function DFS to generate the DFS
    dfs(under, 1, 0);
 
    // Function call to mark the index of node
    markIndexDfs();
 
    int m = 3;
 
    // Query 1
    System.out.println(
        printnodeDFSofSubtree(1, under, m));
 
    // Query 2
    m = 4;
    System.out.println(
        printnodeDFSofSubtree(2, under, m));
}
}
 
// This code is contributed by jrishabh99

Python3




# Python3 program for Queries
# for DFS of subtree of a node in a tree
N = 100000
 
# Adjacency list to store the
# tree nodes connection
v = [[]for i in range(N)]
 
# stores the index of node in DFS
mp = {}
 
# stores the index of node in
# original node
a = []
 
# Function to call DFS and count nodes
# under that subtree
def dfs(under, child, parent):
     
    # stores the DFS of tree
    a.append(child)
     
    # height of subtree
    under[child] = 1
     
    # iterate for children
    for it in v[child]:
         
        # if not equal to parent
        # so that it does not traverse back
        if (it != parent):
             
            # call DFS for subtree
            dfs(under, it, child)
             
            # add the height
            under[child] += under[it]
             
# Function to return the DFS of subtree of node
def printnodeDFSofSubtree(node, under, m):
     
    # index of node in the original DFS
    ind = mp[node]
     
    # height of subtree of node
    return a[ind + m - 1]
     
# Function to add edges to a tree
def addEdge(x, y):
    v[x].append(y)
    v[y].append(x)
 
# Marks the index of node in original DFS
def markIndexDfs():
     
    size = len(a)
     
    # marks the index
    for i in range(size):
        mp[a[i]] = i
     
# Driver Code
 
n = 7
 
# add edges of a tree
addEdge(1, 2)
addEdge(1, 3)
addEdge(2, 4)
addEdge(2, 5)
addEdge(4, 6)
addEdge(4, 7)
 
# array to store the height of subtree
# of every node in a tree
under = [0]*(n + 1)
 
# Call the function DFS to generate the DFS
dfs(under, 1, 0)
 
# Function call to mark the index of node
markIndexDfs()
 
m = 3
 
# Query 1
print(printnodeDFSofSubtree(1, under, m))
 
# Query 2
m = 4
print(printnodeDFSofSubtree(2, under, m))
 
# This code is contributed by SHUBHAMSINGH10

C#




// C# program for Queries for DFS
// of subtree of a node in a tree
using System;
using System.Collections.Generic;
 
class GFG{
     
// Adjacency list to store the
// tree nodes connection
static List<List<int>> v;
 
// Stores the index of node in DFS
static Dictionary<int, int> mp;
 
// Stores the index of node in
// original node
static List<int> a;
 
// Function to call DFS and count nodes
// under that subtree
static void dfs(int []under, int child,
                int parent)
{
     
    // Stores the DFS of tree
    a.Add(child);
 
    // Height of subtree
    under[child] = 1;
 
    // Iterate for children
    foreach(int it in v[child])
    {
         
        // If not equal to parent so
        // that it does not traverse back
        if (it != parent)
        {
             
            // Call DFS for subtree
            dfs(under, it, child);
 
            // Add the height
            under[child] += under[it];
        }
    }
}
 
// Function to return the DFS of subtree of node
static int printnodeDFSofSubtree(int node,
                                 int []under,
                                 int m)
{
     
    // Index of node in the original DFS
    int ind = mp[node];
 
    // Height of subtree of node
    return a[ind + m - 1];
}
 
// Function to add edges to a tree
static void addEdge(int x, int y)
{
    v[x].Add(y);
    v[y].Add(x);
}
 
// Marks the index of node in original DFS
static void markIndexDfs()
{
    int size = a.Count;
 
    // Marks the index
    for(int i = 0; i < size; i++)
    {
        mp.Add(a[i], i);
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    int n = 7;
 
    mp = new Dictionary<int, int>();
    v = new List<List<int>>();
    a = new List<int>();
     
    for(int i = 0; i < n + 1; i++)
        v.Add(new List<int>());
         
    // Add edges of a tree
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
    addEdge(4, 6);
    addEdge(4, 7);
 
    // Array to store the height of subtree
    // of every node in a tree
    int []under = new int[n + 1];
     
    // Call the function DFS to generate the DFS
    dfs(under, 1, 0);
 
    // Function call to mark the index of node
    markIndexDfs();
 
    int m = 3;
 
    // Query 1
    Console.WriteLine(
        printnodeDFSofSubtree(1, under, m));
 
    // Query 2
    m = 4;
    Console.WriteLine(
        printnodeDFSofSubtree(2, under, m));
}
}
 
// This code is contributed by Amit Katiyar

Javascript




<script>
 
// Javascript program for Queries for DFS
// of subtree of a node in a tree
   
// Adjacency list to store the
// tree nodes connection
var v = [];
 
// Stores the index of node in DFS
var mp = new Map();
 
// Stores the index of node in
// original node
var a = [];
 
// Function to call DFS and count nodes
// under that subtree
function dfs(under, child, parent)
{
     
    // Stores the DFS of tree
    a.push(child);
 
    // Height of subtree
    under[child] = 1;
 
    // Iterate for children
    for(var it of v[child])
    {
         
        // If not equal to parent so
        // that it does not traverse back
        if (it != parent)
        {
             
            // Call DFS for subtree
            dfs(under, it, child);
 
            // Push the height
            under[child] += under[it];
        }
    }
}
 
// Function to return the DFS of subtree of node
function printnodeDFSofSubtree(node, under, m)
{
     
    // Index of node in the original DFS
    var ind = mp.get(node);
 
    // Height of subtree of node
    return a[ind + m - 1];
}
 
// Function to add edges to a tree
function addEdge(x, y)
{
    v[x].push(y);
    v[y].push(x);
}
 
// Marks the index of node in original DFS
function markIndexDfs()
{
    var size = a.length;
 
    // Marks the index
    for(var i = 0; i < size; i++)
    {
        mp.set(a[i], i);
    }
}
 
// Driver Code
var n = 7;
mp = new Map();
v = [];
a = [];
 
for(var i = 0; i < n + 1; i++)
    v.push(Array());
     
// Push edges of a tree
addEdge(1, 2);
addEdge(1, 3);
addEdge(2, 4);
addEdge(2, 5);
addEdge(4, 6);
addEdge(4, 7);
 
// Array to store the height of subtree
// of every node in a tree
var under = new Array(n + 1);
 
// Call the function DFS to generate the DFS
dfs(under, 1, 0);
 
// Function call to mark the index of node
markIndexDfs();
var m = 3;
 
// Query 1
document.write(printnodeDFSofSubtree(
    1, under, m) + "<br>");
     
// Query 2
m = 4;
document.write(printnodeDFSofSubtree(
    2, under, m));
 
// This code is contributed by rutvik_56
 
</script>

Output:

4
7

Time Complexity: O(1), for processing each query. 
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.  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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :