Count of exponential paths in a Binary Tree
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 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 find xint 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>0bool 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 treeint 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 pathsint countExpPaths( struct Node* node, int x){ return evenPaths(node, 0, x);}// Driver Codeint 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;} |
chevron_right
filter_none
Java
// Java program to find the count // exponential paths in Binary Tree import java.util.*;import java.lang.*;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 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 codepublic 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 |
chevron_right
filter_none
C#
// C# program to find the count // exponential paths in Binary Tree using System;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 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 codepublic 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 |
chevron_right
filter_none
Output:
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.
