Skip to content
Related Articles

Related Articles

Queries for M-th node in the DFS of subtree
  • Difficulty Level : Hard
  • Last Updated : 26 Oct, 2020

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;
 
// Adjaceny 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);
 
    // hieght 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{
     
// Adjaceny 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
 
# Adjaceny 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)
     
    # hieght 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{
     
// Adjaceny 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

Output:

4
7

Time Complexity: O(1), for processing each query. 
Auxiliary Space: O(N)
 

My Personal Notes arrow_drop_up
Recommended Articles
Page :