Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Construct the Rooted tree by using start and finish time of its DFS traversal

  • Last Updated : 23 Jun, 2021

Given start and finish times of DFS traversal of N vertices that are available in a Rooted tree, the task is to construct the tree (Print the Parent of each node). 
Parent of the root node is 0.
Examples: 
 

Input: Start[] = {2, 4, 1, 0, 3}, End[] = {3, 5, 4, 5, 4}
Output: 3 4 4 0 3
Given Tree is -:
                      4(0, 5)
                    /   \
              (1, 4)3     2(4, 5)
                 /  \    
           (2, 3)1    5(3, 4)
The root will always have start time = 0
processing a node takes 1 unit time but backtracking 
does not consume time, so the finishing time 
of two nodes can be the same.

Input: Start[] = {4, 3, 2, 1, 0}, End[] = {5, 5, 3, 3, 5}
Output: 2 5 4 5 0

 

Approach: 
 

  • Root of the tree is the vertex whose starting time is zero.
  • Now, it is sufficient to find the descendants of a vertex, this way we can find the parent of every vertex.
  • Define Identity[i] as the index of the vertex with starting equal to i.
  • As Start[v] and End[v] are starting and ending time of vertex v.The first child of v is Identity[Start[v]+1] and 
    the (i+1)th is Identity[End[chv[i]]] where chv[i] is the ith child of v.
  • Traverse down in DFS manner and update the parent of each node.

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
int N;
 
// Function to find the parent of each node.
vector<int> Restore_Tree(int Start[], int End[])
{
 
    // Storing index of vertex with starting
    // time Equal to i
    vector<int> Identity(N,0);
 
 
    for (int i = 0; i < N; i++)
    {
        Identity[Start[i]] = i;
    }
 
    // Parent array
    vector<int> parent(N,-1);
    int curr_parent = Identity[0];
 
    for (int j = 1; j < N; j++)
    {
 
        // Find the vertex with starting time j
        int child = Identity[j];
 
        // If end time of this child is greater than
        // (start time + 1), then we traverse down and
        // store curr_parent as the parent of child
        if (End[child] - j > 1)
        {
            parent[child] = curr_parent;
            curr_parent = child;
        }
 
        // Find the parent of current vertex
        // over iterating on the finish time
        else
            parent[child] = curr_parent;
 
        // Backtracking takes zero time
        while (End[child]== End[parent[child]])
        {
            child = parent[child];
            curr_parent = parent[child];
            if (curr_parent == Identity[0])
                break;
        }
    }
    for (int i = 0; i < N; i++)
        parent[i] += 1;
 
    // Return the parent array
    return parent;
}
 
// Driver Code
int main()
{
    N = 5;
 
    // Start and End time of DFS
    int Start[] = {2, 4, 1, 0, 3};
    int End[] = {3, 5, 4, 5, 4};
    vector<int> a = Restore_Tree(Start, End);
 
    for(int ans:a)
        cout << ans << " ";
 
    return 0;
}
 
// This code is contributed by mohit kumar 29

Java




// Java implementation of above approach
import java.util.Arrays;
 
class GFG
{
     
static int N = 5;
 
// Function to find the parent of each node.
static int[] Restore_Tree(int []S, int []End)
{
 
    // Storing index of vertex with starting
    // time Equal to i
    int []Identity = new int[N];
 
    for(int i = 0; i < N; i++)
        Identity[S[i]] = i;
 
    // Parent array
    int []parent = new int[N];
    Arrays.fill(parent,-1);
    int curr_parent = Identity[0];
     
    for(int j = 1; j < N; j++)
    {
 
        // Find the vertex with starting time j
        int child = Identity[j];
 
        // If end time of this child is greater than
        // (start time + 1), then we traverse down and
        // store curr_parent as the parent of child
        if(End[child] - j > 1)
        {
            parent[child] = curr_parent;
            curr_parent = child;
        }
         
        // Find the parent of current vertex
        // over iterating on the finish time
        else{
            parent[child] = curr_parent;
 
            // Backtracking takes zero time
            while(parent[child]>-1 && End[child] == End[parent[child]])
            {
                child = parent[child];
                curr_parent = parent[child];
                if(curr_parent == Identity[0])
                    break;
            }
        }
    }
    for(int i = 0; i < N; i++)
        parent[i] += 1;
 
    // Return the parent array
    return parent;
}
 
// Driver Code
public static void main(String[] args)
{
    // Start and End time of DFS
    int []Start = {2, 4, 1, 0, 3};
    int []End = {3, 5, 4, 5, 4};
    int ans[] =Restore_Tree(Start, End);
    for(int a:ans)
        System.out.print(a + " ");
}
}
 
// This code has been contributed by 29AjayKumar

Python




# Python implementation of the above approach
  
# Function to find the parent of each node.
def Restore_Tree(S, E):
  
    # Storing index of vertex with starting
    # time Equal to i
    Identity = N*[0
 
    for i in range(N):
        Identity[Start[i]] = i
  
    # Parent array
    parent = N*[-1]
    curr_parent = Identity[0]
     
    for j in range(1, N):
 
        # Find the vertex with starting time j
        child = Identity[j]
 
        # If end time of this child is greater than
        # (start time + 1), then we traverse down and
        # store curr_parent as the parent of child
        if End[child] - j > 1:
            parent[child] = curr_parent
            curr_parent = child
 
        # Find the parent of current vertex
        # over iterating on the finish time
        else:    
            parent[child] = curr_parent
 
            # Backtracking takes zero time
            while End[child]== End[parent[child]]:
                child = parent[child]
                curr_parent = parent[child]
                if curr_parent == Identity[0]:
                    break
    for i in range(N):
        parent[i]+= 1
  
    # Return the parent array
    return parent
  
# Driver Code
if __name__=="__main__":
    N = 5
  
    # Start and End time of DFS
    Start = [2, 4, 1, 0, 3]
    End = [3, 5, 4, 5, 4]
    print(*Restore_Tree(Start, End))

C#




// C# implementation of the approach
using System;
     
class GFG
{
     
static int N = 5;
 
// Function to find the parent of each node.
static int[] Restore_Tree(int []S, int []End)
{
 
    // Storing index of vertex with starting
    // time Equal to i
    int []Identity = new int[N];
 
    for(int i = 0; i < N; i++)
        Identity[S[i]] = i;
 
    // Parent array
    int []parent = new int[N];
    for(int i = 0; i < N; i++)
        parent[i]=-1;
    int curr_parent = Identity[0];
     
    for(int j = 1; j < N; j++)
    {
 
        // Find the vertex with starting time j
        int child = Identity[j];
 
        // If end time of this child is greater than
        // (start time + 1), then we traverse down and
        // store curr_parent as the parent of child
        if(End[child] - j > 1)
        {
            parent[child] = curr_parent;
            curr_parent = child;
        }
         
        // Find the parent of current vertex
        // over iterating on the finish time
        else
        {
            parent[child] = curr_parent;
 
            // Backtracking takes zero time
            while(parent[child]>-1 && End[child] == End[parent[child]])
            {
                child = parent[child];
                curr_parent = parent[child];
                if(curr_parent == Identity[0])
                    break;
            }
        }
    }
    for(int i = 0; i < N; i++)
        parent[i] += 1;
 
    // Return the parent array
    return parent;
}
 
// Driver Code
public static void Main(String[] args)
{
    // Start and End time of DFS
    int []Start = {2, 4, 1, 0, 3};
    int []End = {3, 5, 4, 5, 4};
    int []ans =Restore_Tree(Start, End);
    foreach(int a in ans)
        Console.Write(a + " ");
}
}
 
/* This code contributed by PrinciRaj1992 */

Javascript




<script>
 
// JavaScript implementation of the approach
 
var N = 5;
 
// Function to find the parent of each node.
function Restore_Tree(S, End)
{
 
    // Storing index of vertex with starting
    // time Equal to i
    var Identity = Array(N);
 
    for(var i = 0; i < N; i++)
        Identity[S[i]] = i;
 
    // Parent array
    var parent = Array(N);
    for(var i = 0; i < N; i++)
        parent[i]=-1;
    var curr_parent = Identity[0];
     
    for(var j = 1; j < N; j++)
    {
 
        // Find the vertex with starting time j
        var child = Identity[j];
 
        // If end time of this child is greater than
        // (start time + 1), then we traverse down and
        // store curr_parent as the parent of child
        if(End[child] - j > 1)
        {
            parent[child] = curr_parent;
            curr_parent = child;
        }
         
        // Find the parent of current vertex
        // over iterating on the finish time
        else
        {
            parent[child] = curr_parent;
 
            // Backtracking takes zero time
            while(parent[child]>-1 &&
            End[child] == End[parent[child]])
            {
                child = parent[child];
                curr_parent = parent[child];
                if(curr_parent == Identity[0])
                    break;
            }
        }
    }
    for(var i = 0; i < N; i++)
        parent[i] += 1;
 
    // Return the parent array
    return parent;
}
 
// Driver Code
 
// Start and End time of DFS
var Start = [2, 4, 1, 0, 3];
var End = [3, 5, 4, 5, 4];
var ans =Restore_Tree(Start, End);
for(var a of ans)
    document.write(a + " ");
 
 
</script>
Output: 
3 4 4 0 3

 

Time Complexity : O(N) 
where N is the number of nodes in the tree.
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!