Given a Binary Tree, the task is to count the number of Exponential paths in the given Binary Tree.
Exponential Path is a path where root to leaf path contains all nodes being equal to xy, & where x is a minimum possible positive constant & y is a variable positive integer.
Example:
Input: 27 / \ 9 81 / \ / \ 3 10 70 243 / \ 81 909 Output: 2 Explanation: There are 2 exponential path for the above Binary Tree, for x = 3, Path 1: 27 -> 9 -> 3 Path 2: 27 -> 81 -> 243 -> 81 Input: 8 / \ 4 81 / \ / \ 3 2 70 243 / \ 81 909 Output: 1
Approach: The idea is to use Preorder Tree Traversal. During preorder traversal of the given binary tree do the following:
- First find the value of x for which xy=root & x is minimum possible & y>0.
- If current value of the node is not equal to xy for some y>0, or pointer becomes NULL then return the count.
- If the current node is a leaf node then increment the count by 1.
- Recursively call for the left and right subtree with the updated count.
- After all recursive call, the value of count is number of exponential paths for a given binary tree.
Below is the implementation of the above approach:
C++
// C++ program to find the count // exponential paths in Binary Tree #include <bits/stdc++.h> using namespace std; // A Tree node struct Node { int key; struct Node *left, *right; }; // Function to create a new node Node* newNode( int key) { Node* temp = new Node; temp->key = key; temp->left = temp->right = NULL; return (temp); } // function to find x int find_x( int n) { if (n == 1) return 1; double num, den, p; // Take log10 of n num = log10 (n); int x, no; for ( int i = 2; i <= n; i++) { den = log10 (i); // Log(n) with base i p = num / den; // Raising i to the power p no = ( int )( pow (i, int (p))); if ( abs (no - n) < 1e-6) { x = i; break ; } } return x; } // function To check // whether the given node // equals to x^y for some y>0 bool is_key( int n, int x) { double p; // Take logx(n) with base x p = log10 (n) / log10 (x); int no = ( int )( pow (x, int (p))); if (n == no) return true ; return false ; } // Utility function to count // the exponent path // in a given Binary tree int evenPaths( struct Node* node, int count, int x) { // Base Condition, when node pointer // becomes null or node value is not // a number of pow(x, y ) if (node == NULL || !is_key(node->key, x)) { return count; } // Increment count when // encounter leaf node if (!node->left && !node->right) { count++; } // Left recursive call // save the value of count count = evenPaths( node->left, count, x); // Right reursive call and // return value of count return evenPaths( node->right, count, x); } // function to count exponential paths int countExpPaths( struct Node* node, int x) { return evenPaths(node, 0, x); } // Driver Code int main() { // create Tree Node* root = newNode(27); root->left = newNode(9); root->right = newNode(81); root->left->left = newNode(3); root->left->right = newNode(10); root->right->left = newNode(70); root->right->right = newNode(243); root->right->right->left = newNode(81); root->right->right->right = newNode(909); // retrieve the value of x int x = find_x(root->key); // Function call cout << countExpPaths(root, x); return 0; } |
Java
// Java program to find the count // exponential paths in Binary Tree import java.util.*; import java.lang.*; class GFG{ // Structure of a Tree node static class Node { int key; Node left, right; } // Function to create a new node static Node newNode( int key) { Node temp = new Node(); temp.key = key; temp.left = temp.right = null ; return (temp); } // Function to find x static int find_x( int n) { if (n == 1 ) return 1 ; double num, den, p; // Take log10 of n num = Math.log10(n); int x = 0 , no = 0 ; for ( int i = 2 ; i <= n; i++) { den = Math.log10(i); // Log(n) with base i p = num / den; // Raising i to the power p no = ( int )(Math.pow(i, ( int )p)); if (Math.abs(no - n) < 1e- 6 ) { x = i; break ; } } return x; } // Function to check whether the // given node equals to x^y for some y>0 static boolean is_key( int n, int x) { double p; // Take logx(n) with base x p = Math.log10(n) / Math.log10(x); int no = ( int )(Math.pow(x, ( int )p)); if (n == no) return true ; return false ; } // Utility function to count // the exponent path in a // given Binary tree static int evenPaths(Node node, int count, int x) { // Base Condition, when node pointer // becomes null or node value is not // a number of pow(x, y ) if (node == null || !is_key(node.key, x)) { return count; } // Increment count when // encounter leaf node if (node.left == null && node.right == null ) { count++; } // Left recursive call // save the value of count count = evenPaths(node.left, count, x); // Right reursive call and // return value of count return evenPaths(node.right, count, x); } // Function to count exponential paths static int countExpPaths(Node node, int x) { return evenPaths(node, 0 , x); } // Driver code public static void main(String[] args) { // Create Tree Node root = newNode( 27 ); root.left = newNode( 9 ); root.right = newNode( 81 ); root.left.left = newNode( 3 ); root.left.right = newNode( 10 ); root.right.left = newNode( 70 ); root.right.right = newNode( 243 ); root.right.right.left = newNode( 81 ); root.right.right.right = newNode( 909 ); // Retrieve the value of x int x = find_x(root.key); // Function call System.out.println(countExpPaths(root, x)); } } // This code is contributed by offbeat |
C#
// C# program to find the count // exponential paths in Binary Tree using System; class GFG{ // Structure of a Tree node public class Node { public int key; public Node left, right; } // Function to create a new node static Node newNode( int key) { Node temp = new Node(); temp.key = key; temp.left = temp.right = null ; return (temp); } // Function to find x static int find_x( int n) { if (n == 1) return 1; double num, den, p; // Take log10 of n num = Math.Log10(n); int x = 0, no = 0; for ( int i = 2; i <= n; i++) { den = Math.Log10(i); // Log(n) with base i p = num / den; // Raising i to the power p no = ( int )(Math.Pow(i, ( int )p)); if (Math.Abs(no - n) < 0.000001) { x = i; break ; } } return x; } // Function to check whether the // given node equals to x^y for some y>0 static bool is_key( int n, int x) { double p; // Take logx(n) with base x p = Math.Log10(n) / Math.Log10(x); int no = ( int )(Math.Pow(x, ( int )p)); if (n == no) return true ; return false ; } // Utility function to count // the exponent path in a // given Binary tree static int evenPaths(Node node, int count, int x) { // Base Condition, when node pointer // becomes null or node value is not // a number of pow(x, y ) if (node == null || !is_key(node.key, x)) { return count; } // Increment count when // encounter leaf node if (node.left == null && node.right == null ) { count++; } // Left recursive call // save the value of count count = evenPaths(node.left, count, x); // Right reursive call and // return value of count return evenPaths(node.right, count, x); } // Function to count exponential paths static int countExpPaths(Node node, int x) { return evenPaths(node, 0, x); } // Driver code public static void Main( string [] args) { // Create Tree Node root = newNode(27); root.left = newNode(9); root.right = newNode(81); root.left.left = newNode(3); root.left.right = newNode(10); root.right.left = newNode(70); root.right.right = newNode(243); root.right.right.left = newNode(81); root.right.right.right = newNode(909); // Retrieve the value of x int x = find_x(root.key); // Function call Console.Write(countExpPaths(root, x)); } } // This code is contributed by rutvik_56 |
2
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.