# Check if all the Nodes in a Binary Tree having common values are at least D distance apart

• Difficulty Level : Medium
• Last Updated : 22 Jun, 2021

Given a Binary Tree and an integer D, the task is to check if the distance between all pairs of the same node values in the Tree is? D or not. If found to be true, then print Yes. Otherwise, print No.

Examples:

Input: D = 7

1
/   \
2     3
/ \   /  \
4   3  4   4

Output: Yes
Explanation:
The repeated value of nodes are 3 and 4.
The distance between the two nodes valued 3, is 3.
The maximum distance between any pair of nodes valued 4 is 4.
Therefore, none of the distances exceed 7

Input: D = 1

3
/ \
3   3
\
3

Output: No

Approach:
The idea is to observe that the problem is similar to finding the distance between two nodes of a tree. But there can be multiple pairs of nodes for which we have to find the distance. Follow the steps below:

1. Perform the Post Order Traversal of the given tree and find the distance between the repeated pairs of nodes.
2. Find the nodes that are repeated in the tree using unordered_map.
3. For each repeated node of a particular value, find the maximum possible distance between any pair.
4. If that distance is > D, print “No”.
5. If no such node value is found having a pair containing that value, exceeding D, then print “Yes”.

Below is the implementation of the above approach:

## C++

 // C++ program to implement// the above approach#include using namespace std; // Structure of a Tree nodestruct Node {    int key;    struct Node *left, *right;}; // Function to create a new nodeNode* newNode(int key){    Node* temp = new Node;    temp->key = key;    temp->left = temp->right = NULL;    return (temp);} // Function to count the frequency of// node value present in the treevoid frequencyCounts(unordered_map& map,                     Node* root){    if (root == NULL)        return;    map[root->key]++;     frequencyCounts(map, root->left);    frequencyCounts(map, root->right);} // Function that returns the max distance// between the nodes that have the same keyint computeDistance(Node* root, int value){    if (root == NULL) {        return -1;    }     int left        = computeDistance(root->left, value);     int right        = computeDistance(root->right, value);     // If right and left subtree did not    // have node whose key is value    if (left == -1 && right == -1) {         // Check if the current node        // is equal to value        if (root->key == value) {            return 1;        }        else            return -1;    }     // If the left subtree has no node    // whose key is equal to value    if (left == -1) {        return right + 1;    }     // If the right subtree has no node    // whose key is equal to value    if (right == -1) {        return left + 1;    }    else {        return 1 + max(left, right);    }    return -1;} // Function that finds if the distance// between any same nodes is at most Kvoid solve(Node* root, int dist){     // Create the map to look    // for same value of nodes    unordered_map map;     // Counting the frequency of nodes    frequencyCounts(map, root);    int flag = 0;     for (auto it = map.begin();         it != map.end(); it++) {         if (it->second > 1) {             // If the returned value of            // distance is exceeds dist            int result                = computeDistance(root, it->first);             if (result > dist || result == -1) {                flag = 1;                break;            }        }    }     // Print the result    flag == 0 ? cout << "Yes\n" : cout << "No\n";} // Driver Codeint main(){    Node* root = newNode(1);    root->left = newNode(2);    root->right = newNode(3);    root->left->left = newNode(4);    root->left->right = newNode(3);    root->right->right = newNode(4);    root->right->left = newNode(4);     int dist = 7;     solve(root, dist);     return 0;}

## Java

 // Java program to implement// the above approachimport java.util.*; class GFG{ // Structure of a Tree nodestatic class Node{    int key;    Node left, right;}; // Function to create a new nodestatic Node newNode(int key){    Node temp = new Node();    temp.key = key;    temp.left = temp.right = null;    return (temp);} // Function to count the frequency of// node value present in the treestatic void frequencyCounts(HashMap map,                            Node root){    if (root == null)        return;             if(map.containsKey(root.key))        map.put(root.key, map.get(root.key) + 1);    else        map.put(root.key, 1);     frequencyCounts(map, root.left);    frequencyCounts(map, root.right);} // Function that returns the max distance// between the nodes that have the same keystatic int computeDistance(Node root, int value){    if (root == null)    {        return -1;    }     int left = computeDistance(root.left, value);    int right = computeDistance(root.right, value);     // If right and left subtree did not    // have node whose key is value    if (left == -1 && right == -1)    {                 // Check if the current node        // is equal to value        if (root.key == value)        {            return 1;        }        else            return -1;    }     // If the left subtree has no node    // whose key is equal to value    if (left == -1)    {        return right + 1;    }     // If the right subtree has no node    // whose key is equal to value    if (right == -1)    {        return left + 1;    }    else    {        return 1 + Math.max(left, right);    }} // Function that finds if the distance// between any same nodes is at most Kstatic void solve(Node root, int dist){     // Create the map to look    // for same value of nodes    HashMap map = new HashMap();     // Counting the frequency of nodes    frequencyCounts(map, root);    int flag = 0;     for(Map.Entry it : map.entrySet())    {        if (it.getValue() > 1)        {                         // If the returned value of            // distance is exceeds dist            int result = computeDistance(                         root, it.getKey());             if (result > dist || result == -1)            {                flag = 1;                break;            }        }    }     // Print the result    if(flag == 0)        System.out.print("Yes\n");    else        System.out.print("No\n");} // Driver Codepublic static void main(String[] args){    Node root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);         root.left.left = newNode(4);    root.left.right = newNode(3);    root.right.right = newNode(4);    root.right.left = newNode(4);     int dist = 7;     solve(root, dist);}} // This code is contributed by Rajput-Ji

## Python3

 # Python3 program to implement# the above approach # Structure of a Tree node# Function to create a new nodemp = {} class newNode:       def __init__(self, key):               self.key = key        self.left = None        self.right = None # Function to count the frequency# of node value present in the treedef frequencyCounts(root):       global mp         if (root == None):        return           mp[root.key] = mp.get(root.key, 0) + 1    frequencyCounts(root.left)    frequencyCounts(root.right) # Function that returns the max# distance between the nodes that# have the same keydef computeDistance(root, value):       if (root == None):        return -1     left = computeDistance(root.left,                           value)    right = computeDistance(root.right,                            value)     # If right and left subtree    # did not have node whose    # key is value    if (left == -1 and        right == -1):               # Check if the current node        # is equal to value        if (root.key == value):            return 1        else:            return -1     # If the left subtree has    # no node whose key is equal    # to value    if (left == -1):        return right + 1     # If the right subtree has    # no node whose key is equal    # to value    if (right == -1):        return left + 1    else:        return 1 + max(left, right)    return -1 # Function that finds if the# distance between any same# nodes is at most Kdef solve(root, dist):       # Create the mp to look    # for same value of nodes    global mp     # Counting the frequency    # of nodes    frequencyCounts(root)    flag = 0     for key,value in mp.items():        if(value > 1):                       # If the returned value of            # distance is exceeds dist            result = computeDistance(root,                                     key)             if (result > dist or                result == -1):                flag = 1                break     # Print the result    if flag == 0:        print("Yes")    else:        print("No") # Driver Codeif __name__ == '__main__':       root = newNode(1)    root.left = newNode(2)    root.right = newNode(3)    root.left.left = newNode(4)    root.left.right = newNode(3)    root.right.right = newNode(4)    root.right.left = newNode(4)    dist = 7    solve(root, dist) # This code is contributed by SURENDRA_GANGWAR

## C#

 // C# program to implement// the above approachusing System;using System.Collections.Generic; class GFG{ // Structure of a Tree nodepublic  class Node{    public  int key;    public  Node left, right;}; // Function to create a new nodestatic Node newNode(int key){    Node temp = new Node();    temp.key = key;    temp.left = temp.right = null;    return (temp);} // Function to count the frequency of// node value present in the treestatic void frequencyCounts(Dictionary map,                            Node root){    if (root == null)        return;             if(map.ContainsKey(root.key))        map[root.key] = map[root.key]+1;    else        map[root.key] = 1;     frequencyCounts(map, root.left);    frequencyCounts(map, root.right);} // Function that returns the max distance// between the nodes that have the same keystatic int computeDistance(Node root, int value){    if (root == null)    {        return -1;    }     int left = computeDistance(root.left, value);    int right = computeDistance(root.right, value);     // If right and left subtree did not    // have node whose key is value    if (left == -1 && right == -1)    {                 // Check if the current node        // is equal to value        if (root.key == value)        {            return 1;        }        else            return -1;    }     // If the left subtree has no node    // whose key is equal to value    if (left == -1)    {        return right + 1;    }     // If the right subtree has no node    // whose key is equal to value    if (right == -1)    {        return left + 1;    }    else    {        return 1 + Math.Max(left, right);    }} // Function that finds if the distance// between any same nodes is at most Kstatic void solve(Node root, int dist){     // Create the map to look    // for same value of nodes    Dictionary map = new Dictionary();     // Counting the frequency of nodes    frequencyCounts(map, root);    int flag = 0;     foreach(KeyValuePair it in map)    {        if (it.Value > 1)        {                         // If the returned value of            // distance is exceeds dist            int result = computeDistance(                         root, it.Key);             if (result > dist || result == -1)            {                flag = 1;                break;            }        }    }     // Print the result    if(flag == 0)        Console.Write("Yes\n");    else        Console.Write("No\n");} // Driver Codepublic static void Main(String[] args){    Node root = newNode(1);    root.left = newNode(2);    root.right = newNode(3);         root.left.left = newNode(4);    root.left.right = newNode(3);    root.right.right = newNode(4);    root.right.left = newNode(4);     int dist = 7;     solve(root, dist);}} // This code is contributed by gauravrajput1

## Javascript



Output:

Yes

Time Complexity: O(N2)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up