Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Count pairs of nodes having minimum distance between them equal to the difference of their distances from root

Given an N-ary Tree consisting of N nodes valued from [1, N], where node 1 is the root, the task is to count the pairs of nodes having minimum distance between them equal to the difference between the distances of both the nodes from the root.

Examples:



Input: N = 3, Edges[][] = {{1, 2}, {1, 3}}, Below is the Tree:
                        1
                      / \
                   2   3
Output: 5   
Explanation: The following pairs satisfy the conditions: {(1, 1), (2, 2), (3, 3), (2, 1), (3, 1)}.

Input: N = 4, Edges[][] = {{1, 2}, {1, 3}, {2, 4}}, Below is the Tree:
                     1
                   / \
                2   3
               |
             4
Output: 8 



Naive Approach: The simplest approach is to find the distance between all possible pairs (i, j) and check for each pair of nodes (i, j), whether distance(i, j) = distance(1, i) – distance(1, j) or not by using Depth-First Search Traversal. 
Time Complexity: O(N2)
Auxiliary Space: O(N)

Efficient Approach: The above approach can be optimized based on the following observations:

The minimum distance from node X and the ancestor of node X satisfy the above criteria. Therefore, the task is reduced to finding all the ancestors of every node of the tree.

Follow the steps below to solve the problem:

Below is the implementation of the above approach:




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Stores the count of pairs
long long ans = 0;
 
// Store the adjacency list of
// the connecting vertex
vector<int> adj[int(1e5) + 1];
 
// Function for theto perform DFS
// traversal of the given tree
void dfsUtil(int u, int par, int depth)
{
    // Traverse the adjacency list
    // of the current node u
    for (auto it : adj[u]) {
 
        // If the current node
        // is the parent node
        if (it != par) {
            dfsUtil(it, u, depth + 1);
        }
    }
 
    // Add number of ancestors, which
    // is same as depth of the node
    ans += depth;
}
 
// Function for DFS traversal of
// the given tree
void dfs(int u, int par, int depth)
{
    dfsUtil(u, par, depth);
 
    // Print the result
    cout << ans << endl;
}
 
// Function to find the count of pairs
// such that the minimum distance
// between them is equal to the difference
// between distance of the nodes from root node
void countPairs(vector<vector<int> > edges)
{
    for (int i = 0; i < edges.size(); i++) {
 
        int u = edges[i][0];
        int v = edges[i][1];
 
        // Add edges to adj[]
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
 
    dfs(1, 1, 1);
}
 
// Driver Code
int main()
{
    vector<vector<int> > edges
        = { { 1, 2 }, { 1, 3 }, { 2, 4 } };
 
    countPairs(edges);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program for the above approach



import java.util.*;




class GFG



{


 


// Stores the count of pairs



static int ans = 0;



 


// Store the adjacency list of


// the connecting vertex



static ArrayList<Integer> []adj = new ArrayList[(int)(1e5) + 1];




static{




    for(int i = 0; i < adj.length; i++)




        adj[i] = new ArrayList<>();



}



   


// Function for theto perform DFS


// traversal of the given tree



static void dfsUtil(int u, int par, int depth)



{



   



    // Traverse the adjacency list




    // of the current node u




    for (int it : adj[u]) {



 



        // If the current node




        // is the parent node




        if (it != par) {




            dfsUtil(it, u, depth + 1);




        }




    }



 



    // Add number of ancestors, which




    // is same as depth of the node




    ans += depth;



}


 


// Function for DFS traversal of


// the given tree



static void dfs(int u, int par, int depth)



{



    dfsUtil(u, par, depth);



 



    // Print the result




    System.out.print(ans +"\n");



}


 


// Function to find the count of pairs


// such that the minimum distance


// between them is equal to the difference


// between distance of the nodes from root node



static void countPairs(int [][]edges)



{



    for (int i = 0; i < edges.length; i++) {



 



        int u = edges[i][0];




        int v = edges[i][1];



 



        // Add edges to adj[]




        adj[u].add(v);




        adj[v].add(u);




    }



 



    dfs(1, 1, 1);



}


 


// Driver Code



public static void main(String[] args)



{



    int [][]edges




        = { { 1, 2 }, { 1, 3 }, { 2, 4 } };



 



    countPairs(edges);



}


}


 


// This code is contributed by 29AjayKumar


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 program for the above approach


 


# Stores the count of pairs



ans = 0



 


# Store the adjacency list of


# the connecting vertex



adj = [[] for i in range(10**5+1)]



 


# Function for theto perform DFS


# traversal of the given tree



def dfsUtil(u, par, depth):




    global adj, ans




     



    # Traverse the adjacency list




    # of the current node u




    for it in adj[u]:



 



        # If the current node




        # is the parent node




        if (it != par):




            dfsUtil(it, u, depth + 1)



 



    # Add number of ancestors, which




    # is same as depth of the node




    ans += depth



 


# Function for DFS traversal of


# the given tree



def dfs(u, par, depth):




    global ans




    dfsUtil(u, par, depth)




     



    # Print result




    print (ans)



 


# Function to find the count of pairs


# such that the minimum distance


# between them is equal to the difference


# between distance of the nodes from root node



def countPairs(edges):




    global adj




    for i in range(len(edges)):




        u = edges[i][0]




        v = edges[i][1]



 



        # Add edges to adj[]




        adj[u].append(v)




        adj[v].append(u)




    dfs(1, 1, 1)



 


# Driver Code



if __name__ == '__main__':




    edges = [ [ 1, 2 ], [ 1, 3 ], [ 2, 4 ] ]



 



    countPairs(edges)



 



    # This code is contributed by mohit kumar 29.



















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program for the above approach



using System;




using System.Collections.Generic;




public class GFG



{


 


// Stores the count of pairs



static int ans = 0;



 


// Store the adjacency list of


// the connecting vertex



static List<int> []adj = new List<int>[(int)(1e5) + 1];




   


// Function for theto perform DFS


// traversal of the given tree



static void dfsUtil(int u, int par, int depth)



{



   



    // Traverse the adjacency list




    // of the current node u




    foreach (int it in adj[u]) {



 



        // If the current node




        // is the parent node




        if (it != par) {




            dfsUtil(it, u, depth + 1);




        }




    }



 



    // Add number of ancestors, which




    // is same as depth of the node




    ans += depth;



}


 


// Function for DFS traversal of


// the given tree



static void dfs(int u, int par, int depth)



{



    dfsUtil(u, par, depth);



 



    // Print the result




    Console.Write(ans +"\n");



}


 


// Function to find the count of pairs


// such that the minimum distance


// between them is equal to the difference


// between distance of the nodes from root node



static void countPairs(int [,]edges)



{



    for (int i = 0; i < edges.GetLength(0); i++) 




    {



 



        int u = edges[i,0];




        int v = edges[i,1];



 



        // Add edges to []adj




        adj[u].Add(v);




        adj[v].Add(u);




    }



 



    dfs(1, 1, 1);



}


 


// Driver Code



public static void Main(String[] args)



{



    int [,]edges




        = { { 1, 2 }, { 1, 3 }, { 2, 4 } };



 



    for(int i = 0; i < adj.GetLength(0); i++)




        adj[i] = new List<int>();




    countPairs(edges);



}


}


 


// This code is contributed by 29AjayKumar


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


 


// Javascript program for the above approach


 


// Stores the count of pairs



var ans = 0;



 


// Store the adjacency list of


// the connecting vertex



var adj = Array.from(Array(100001), ()=>Array());



 


// Function for theto perform DFS


// traversal of the given tree



function dfsUtil(u, par, depth)



{



    // Traverse the adjacency list




    // of the current node u




    adj[u].forEach(it => {




         


 



        // If the current node




        // is the parent node




        if (it != par) {




            dfsUtil(it, u, depth + 1);




        }




    });



 



    // Add number of ancestors, which




    // is same as depth of the node




    ans += depth;



}


 


// Function for DFS traversal of


// the given tree



function dfs(u, par, depth)



{



    dfsUtil(u, par, depth);



 



    // Print the result




    document.write( ans + "<br>");



}


 


// Function to find the count of pairs


// such that the minimum distance


// between them is equal to the difference


// between distance of the nodes from root node



function countPairs(edges)



{



    for (var i = 0; i < edges.length; i++) {



 



        var u = edges[i][0];




        var v = edges[i][1];



 



        // Add edges to adj[]




        adj[u].push(v);




        adj[v].push(u);




    }



 



    dfs(1, 1, 1);



}


 


// Driver Code



var edges




    = [ [ 1, 2 ], [ 1, 3 ], [ 2, 4 ] ];



countPairs(edges);


 


// This code is contributed by itsok.


</script>


















                        






                        








Output: 

8


 


Time Complexity: O(N)
Auxiliary Space: O(N)

	

        Article Tags : 
        

            DSA
Mathematical
Misc
Recursion
Searching
Tree        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Count of nodes in a given N-ary tree having distance to all leaf nodes equal in their subtree

          
2. Count pairs of points having distance between them equal to integral values in a K-dimensional space

          
3. Count the pairs in an array such that the difference between them and their indices is equal

          
4. Count nodes having Bitwise XOR of all edges in their path from the root equal to K

          
5. Maximum sum of a subsequence having difference between their indices equal to the difference between their values

          
6. Count of pairs in given range having their ratio equal to ratio of product of their digits

          
7. Count pairs of vertices in Tree such that distance between them is even

          
8. Count pairs from an array having product of their sum and difference equal to 0

          
9. Count pairs from an array having product of their sum and difference equal to 1

          
10. Count of nodes in a binary tree having their nodes in range [L, R]

          
11. Find the distance covered to collect items at equal distances

          
12. Count of pairs in a given range with sum of their product and sum equal to their concatenated number

          
13. Count of pairs in given Array with product of their values equal to sum of their indices (arr[i]*arr[j] = i+j)

          
14. Smallest character in a string having minimum sum of distances between consecutive repetitions

          
15. Minimize steps to make two integers equal by incrementing them or doing bitwise OR of them

          
16. Check if a pair of integers A and B can coincide by shifting them by distances arr[(A%N +N)%N] and arr[(B%N +N)%N]

          
17. Count pairs from an array having sum of twice of their AND and XOR equal to K

          
18. Count pairs up to N having sum equal to their XOR

          
19. Count pairs in an array having sum of elements with their respective sum of digits equal

          
20. Minimize remaining array element by removing pairs and replacing them by their absolute difference

          
21. Count ways to split array into two subsets having difference between their sum equal to K

          
22. Count of nodes which are at a distance X from root and leaves

          
23. Minimum of the Maximum distances from any node to all other nodes of given Tree

          
24. Assign stalls to K cows to maximize the minimum distance between them

          
25. Maximize count of elements that can be selected having minimum difference between their sum and K