二叉树中的指数路径计数

给定二叉树，任务是计算给定二叉树中的指数路径数。

Exponential Path is a path where root to leaf path contains all nodes being equal to x^y, & where x is a minimum possible positive constant & y is a variable positive integer.

例子：

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

方法：想法是使用预排序树遍历。在对给定的二叉树进行遍历时，请执行以下操作：

1. 首先找到x的值，其中x ^y = root和x最小可能且y> 0。
2. 如果对于某个y> 0，该节点的当前值不等于x ^y ，或者指针变为NULL，则返回计数。
3. 如果当前节点是叶节点，则将计数增加1。
4. 递归调用与更新的计左和右子树。
5. 在所有递归调用之后，count的值是给定二叉树的指数路径数。

下面是上述方法的实现：

C++

// C++ program to find the count
// exponential paths in Binary Tree
 
#include 
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