Find distance of nodes from root in a tree for multiple queries

Given a tree with N vertices numbered from 0 to N – 1 and Q queries containing nodes in the tree, the task is to find the distance of given node from root node for multiple queries. Consider 0th node as the root node and take the distance of the root node from itself as 0.

Examples:

Tree:
      0
     /  \
    1    2
    |   / \
    3  4   5
Input: 2
Output: 1
Explanation:
Distance of node 2 from root is 1

Input: 3
Output: 2
Explanation:
Distance of node 3 from root is 2

Approach:
Start by assigning the distance of the root node as 0. Then, traverse the tree using Breadth First Traversal(BFS). When marking the children of the node N as visited, also assign the distance of these children as the distance[N] + 1. Finally, for different queries, the value of the distance array of the node is printed.



Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation for
// the above approach
#include <bits/stdc++.h>
using namespace std;
  
const int sz = 1e5;
  
// Adjacency list representation
// of the tree
vector<int> tree[sz + 1];
  
// Boolean array to mark all the
// vertices which are visited
bool vis[sz + 1];
  
// Array of vector where ith index
// stores the path from the root
// node to the ith node
int dis[sz + 1];
  
// Function to create an
// edge between two vertices
void addEdge(int a, int b)
{
    // Add a to b's list
    tree[a].push_back(b);
  
    // Add b to a's list
    tree[b].push_back(a);
}
  
// Modified Breadth-First Function
void bfs(int node)
{
    // Create a queue of {child, parent}
    queue<pair<int, int> > qu;
  
    // Push root node in the front of
    qu.push({ node, 0 });
    dis[0] = 0;
  
    while (!qu.empty()) {
        pair<int, int> p = qu.front();
  
        // Dequeue a vertex from queue
        qu.pop();
        vis[p.first] = true;
  
        // Get all adjacent vertices of the dequeued
        // vertex s. If any adjacent has not
        // been visited then enqueue it
        for (int child : tree[p.first]) {
            if (!vis[child]) {
                dis[child] = dis[p.first] + 1;
                qu.push({ child, p.first });
            }
        }
    }
}
  
// Driver code
int main()
{
    // Number of vertices
    int n = 6;
  
    addEdge(0, 1);
    addEdge(0, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
  
    // Calling modified bfs function
    bfs(0);
  
    int q[] = { 2, 4 };
  
    for (int i = 0; i < 2; i++) {
        cout << dis[q[i]] << '\n';
    }
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation for
// the above approach
import java.util.*;
  
class GFG
{
static int sz = (int) 1e5;
  
// Adjacency list representation
// of the tree
static Vector<Integer> []tree = new Vector[sz + 1];
  
// Boolean array to mark all the
// vertices which are visited
static boolean []vis = new boolean[sz + 1];
  
// Array of vector where ith index
// stores the path from the root
// node to the ith node
static int []dis = new int[sz + 1];
  
static class pair
    int first, second; 
    public pair(int first, int second) 
    
        this.first = first; 
        this.second = second; 
    
}
  
// Function to create an
// edge between two vertices
static void addEdge(int a, int b)
{
  
    // Add a to b's list
    tree[a].add(b);
  
    // Add b to a's list
    tree[b].add(a);
}
  
// Modified Breadth-First Function
static void bfs(int node)
{
    // Create a queue of {child, parent}
    Queue<pair> qu = new LinkedList<>();
  
    // Push root node in the front of
    qu.add(new pair(node, 0 ));
    dis[0] = 0;
  
    while (!qu.isEmpty()) 
    {
        pair p = qu.peek();
  
        // Dequeue a vertex from queue
        qu.remove();
        vis[p.first] = true;
  
        // Get all adjacent vertices of the dequeued
        // vertex s. If any adjacent has not
        // been visited then enqueue it
        for (int child : tree[p.first])
        {
            if (!vis[child]) 
            {
                dis[child] = dis[p.first] + 1;
                qu.add(new pair(child, p.first));
            }
        }
    }
}
  
// Driver code
public static void main(String[] args)
{
      
    // Number of vertices
    int n = 6;
    for (int i = 0; i < sz + 1; i++) 
        tree[i] = new Vector<Integer>();
          
    addEdge(0, 1);
    addEdge(0, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
  
    // Calling modified bfs function
    bfs(0);
  
    int q[] = { 2, 3 };
  
    for (int i = 0; i < 2; i++) 
    {
        System.out.println(dis[q[i]]);
    }
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation for
// the above approach
using System;
using System.Collections.Generic;
      
class GFG
{
static int sz = (int) 1e5;
  
// Adjacency list representation
// of the tree
static List<int> []tree = new List<int>[sz + 1];
  
// Boolean array to mark all the
// vertices which are visited
static Boolean []vis = new Boolean[sz + 1];
  
// Array of vector where ith index
// stores the path from the root
// node to the ith node
static int []dis = new int[sz + 1];
  
public class pair
    public int first, second; 
    public pair(int first, int second) 
    
        this.first = first; 
        this.second = second; 
    
}
  
// Function to create an
// edge between two vertices
static void addEdge(int a, int b)
{
  
    // Add a to b's list
    tree[a].Add(b);
  
    // Add b to a's list
    tree[b].Add(a);
}
  
// Modified Breadth-First Function
static void bfs(int node)
{
    // Create a queue of {child, parent}
    Queue<pair> qu = new Queue<pair>();
  
    // Push root node in the front of
    qu.Enqueue(new pair(node, 0 ));
    dis[0] = 0;
  
    while (qu.Count != 0) 
    {
        pair p = qu.Peek();
  
        // Dequeue a vertex from queue
        qu.Dequeue();
        vis[p.first] = true;
  
        // Get all adjacent vertices of the dequeued
        // vertex s. If any adjacent has not
        // been visited then enqueue it
        foreach (int child in tree[p.first])
        {
            if (!vis[child]) 
            {
                dis[child] = dis[p.first] + 1;
                qu.Enqueue(new pair(child, p.first));
            }
        }
    }
}
  
// Driver code
public static void Main(String[] args)
{
      
    // Number of vertices
    for (int i = 0; i < sz + 1; i++) 
        tree[i] = new List<int>();
          
    addEdge(0, 1);
    addEdge(0, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(2, 5);
  
    // Calling modified bfs function
    bfs(0);
  
    int []q = { 2, 3 };
  
    for (int i = 0; i < 2; i++) 
    {
        Console.WriteLine(dis[q[i]]);
    }
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

1
2


My Personal Notes arrow_drop_up

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.



Improved By : 29AjayKumar, Rajput-Ji