Given a Binary Tree, the task is to count the number of Fibonacci paths in the given Binary Tree.
Fibonacci Path is a path which contains all nodes in root to leaf path are terms of Fibonacci series.
Example:
Input:
0
/ \
1 1
/ \ / \
1 10 70 1
/ \
81 2
Output: 2
Explanation:
There are 2 Fibonacci path for
the above Binary Tree, for x = 3,
Path 1: 0 1 1
Path 2: 0 1 1 2
Input:
8
/ \
4 81
/ \ / \
3 2 70 243
/ \
81 909
Output: 0
Approach: The idea is to use Preorder Tree Traversal. During preorder traversal of the given binary tree do the following:
- First calculate the Height of binary tree .
- Now create a vector of length equals height of tree, such that it contains Fibonacci Numbers.
- If current value of the node at ith level is not equal to ith term of fibonacci series 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 Fibonacci paths for a given binary tree.
Below is the implementation of the above approach:
C++
// C++ program to count all of// Fibonacci paths in a Binary tree#include <bits/stdc++.h>using namespace std;// Vector to store the fibonacci seriesvector<int> fib;// Binary Tree Nodestruct node { struct node* left; int data; struct node* right;};// Function to create a new tree nodenode* newNode(int data){ node* temp = new node; temp->data = data; temp->left = NULL; temp->right = NULL; return temp;}// Function to find the height// of the given treeint height(node* root){ int ht = 0; if (root == NULL) return 0; return (max(height(root->left), height(root->right)) + 1);}// Function to make fibonacci series// upto n termsvoid FibonacciSeries(int n){ fib.push_back(0); fib.push_back(1); for (int i = 2; i < n; i++) fib.push_back(fib[i - 1] + fib[i - 2]);}// Preorder Utility function to count// exponent path in a given Binary treeint CountPathUtil(node* root, int i, int count){ // Base Condition, when node pointer // becomes null or node value is not // a number of pow(x, y ) if (root == NULL || !(fib[i] == root->data)) { return count; } // Increment count when // encounter leaf node if (!root->left && !root->right) { count++; } // Left recursive call // save the value of count count = CountPathUtil( root->left, i + 1, count); // Right recursive call and // return value of count return CountPathUtil( root->right, i + 1, count);}// Function to find whether// fibonacci path exists or notvoid CountPath(node* root){ // To find the height int ht = height(root); // Making fibonacci series // upto ht terms FibonacciSeries(ht); cout << CountPathUtil(root, 0, 0);}// Driver codeint main(){ // Create binary tree node* root = newNode(0); root->left = newNode(1); root->right = newNode(1); root->left->left = newNode(1); root->left->right = newNode(4); root->right->right = newNode(1); root->right->right->left = newNode(2); // Function Call CountPath(root); return 0;} |
Java
// Java program to count all of// Fibonacci paths in a Binary treeimport java.util.*;class GFG{// Vector to store the fibonacci seriesstatic Vector<Integer> fib = new Vector<Integer>();// Binary Tree Nodestatic class node { node left; int data; node right;};// Function to create a new tree nodestatic node newNode(int data){ node temp = new node(); temp.data = data; temp.left = null; temp.right = null; return temp;}// Function to find the height// of the given treestatic int height(node root){ if (root == null) return 0; return (Math.max(height(root.left), height(root.right)) + 1);}// Function to make fibonacci series// upto n termsstatic void FibonacciSeries(int n){ fib.add(0); fib.add(1); for (int i = 2; i < n; i++) fib.add(fib.get(i - 1) + fib.get(i - 2));}// Preorder Utility function to count// exponent path in a given Binary treestatic int CountPathUtil(node root, int i, int count){ // Base Condition, when node pointer // becomes null or node value is not // a number of Math.pow(x, y ) if (root == null || !(fib.get(i) == root.data)) { return count; } // Increment count when // encounter leaf node if (root.left != null && root.right != null) { count++; } // Left recursive call // save the value of count count = CountPathUtil( root.left, i + 1, count); // Right recursive call and // return value of count return CountPathUtil( root.right, i + 1, count);}// Function to find whether// fibonacci path exists or notstatic void CountPath(node root){ // To find the height int ht = height(root); // Making fibonacci series // upto ht terms FibonacciSeries(ht); System.out.print(CountPathUtil(root, 0, 0));}// Driver codepublic static void main(String[] args){ // Create binary tree node root = newNode(0); root.left = newNode(1); root.right = newNode(1); root.left.left = newNode(1); root.left.right = newNode(4); root.right.right = newNode(1); root.right.right.left = newNode(2); // Function Call CountPath(root);}}// This code is contributed by 29AjayKumar |
Python3
# Python3 program to count all of# Fibonacci paths in a Binary tree # Vector to store the fibonacci seriesfib = [] # Binary Tree Nodeclass node: def __init__(self, data): self.data = data self.left = None self.right = None # Function to create a new tree nodedef newNode(data): temp = node(data) return temp # Function to find the height# of the given treedef height(root): ht = 0 if (root == None): return 0 return (max(height(root.left), height(root.right)) + 1)# Function to make fibonacci series# upto n termsdef FibonacciSeries(n): fib.append(0) fib.append(1) for i in range(2, n): fib.append(fib[i - 1] + fib[i - 2])# Preorder Utility function to count# exponent path in a given Binary treedef CountPathUtil(root, i, count): # Base Condition, when node pointer # becomes null or node value is not # a number of pow(x, y ) if (root == None or not (fib[i] == root.data)): return count # Increment count when # encounter leaf node if (not root.left and not root.right): count += 1 # Left recursive call # save the value of count count = CountPathUtil(root.left, i + 1, count) # Right recursive call and # return value of count return CountPathUtil(root.right, i + 1, count)# Function to find whether# fibonacci path exists or notdef CountPath(root): # To find the height ht = height(root) # Making fibonacci series # upto ht terms FibonacciSeries(ht) print(CountPathUtil(root, 0, 0))# Driver codeif __name__=='__main__': # Create binary tree root = newNode(0) root.left = newNode(1) root.right = newNode(1) root.left.left = newNode(1) root.left.right = newNode(4) root.right.right = newNode(1) root.right.right.left = newNode(2) # Function Call CountPath(root) # This code is contributed by rutvik_56 |
C#
// C# program to count all of// Fibonacci paths in a Binary treeusing System;using System.Collections.Generic;class GFG{ // List to store the fibonacci seriesstatic List<int> fib = new List<int>(); // Binary Tree Nodeclass node { public node left; public int data; public node right;}; // Function to create a new tree nodestatic node newNode(int data){ node temp = new node(); temp.data = data; temp.left = null; temp.right = null; return temp;} // Function to find the height// of the given treestatic int height(node root){ if (root == null) return 0; return (Math.Max(height(root.left), height(root.right)) + 1);} // Function to make fibonacci series// upto n termsstatic void FibonacciSeries(int n){ fib.Add(0); fib.Add(1); for (int i = 2; i < n; i++) fib.Add(fib[i - 1] + fib[i - 2]);} // Preorder Utility function to count// exponent path in a given Binary treestatic int CountPathUtil(node root, int i, int count){ // Base Condition, when node pointer // becomes null or node value is not // a number of Math.Pow(x, y) if (root == null || !(fib[i] == root.data)) { return count; } // Increment count when // encounter leaf node if (root.left != null && root.right != null) { count++; } // Left recursive call // save the value of count count = CountPathUtil( root.left, i + 1, count); // Right recursive call and // return value of count return CountPathUtil( root.right, i + 1, count);} // Function to find whether// fibonacci path exists or notstatic void CountPath(node root){ // To find the height int ht = height(root); // Making fibonacci series // upto ht terms FibonacciSeries(ht); Console.Write(CountPathUtil(root, 0, 0));} // Driver codepublic static void Main(String[] args){ // Create binary tree node root = newNode(0); root.left = newNode(1); root.right = newNode(1); root.left.left = newNode(1); root.left.right = newNode(4); root.right.right = newNode(1); root.right.right.left = newNode(2); // Function Call CountPath(root);}}// This code is contributed by Princi Singh |
Javascript
<script> // JavaScript program to count all of // Fibonacci paths in a Binary tree // Vector to store the fibonacci series let fib = []; // Binary Tree Node class node { constructor(data) { this.left = null; this.right = null; this.data = data; } }; // Function to create a new tree node function newNode(data) { let temp = new node(data); return temp; } // Function to find the height // of the given tree function height(root) { if (root == null) return 0; return (Math.max(height(root.left), height(root.right)) + 1); } // Function to make fibonacci series // upto n terms function FibonacciSeries(n) { fib.push(0); fib.push(1); for (let i = 2; i < n; i++) fib.push(fib[i - 1] + fib[i - 2]); } // Preorder Utility function to count // exponent path in a given Binary tree function CountPathUtil(root, i, count) { // Base Condition, when node pointer // becomes null or node value is not // a number of Math.pow(x, y ) if (root == null || !(fib[i] == root.data)) { return count; } // Increment count when // encounter leaf node if (root.left != null && root.right != null) { count++; } // Left recursive call // save the value of count count = CountPathUtil(root.left, i + 1, count); // Right recursive call and // return value of count return CountPathUtil(root.right, i + 1, count); } // Function to find whether // fibonacci path exists or not function CountPath(root) { // To find the height let ht = height(root); // Making fibonacci series // upto ht terms FibonacciSeries(ht); document.write(CountPathUtil(root, 0, 0)); } // Create binary tree let root = newNode(0); root.left = newNode(1); root.right = newNode(1); root.left.left = newNode(1); root.left.right = newNode(4); root.right.right = newNode(1); root.right.right.left = newNode(2); // Function Call CountPath(root); </script> |
Output:
2
Time Complexity: O(n), where n is the number of nodes in the given tree.
Auxiliary Space: O(h), where h is the height of the tree.
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
