Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Count of Fibonacci paths in a Binary tree

  • Difficulty Level : Medium
  • Last Updated : 07 Jul, 2021

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.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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:  

  1. First calculate the Height of binary tree .
  2. Now create a vector of length equals height of tree, such that it contains Fibonacci Numbers.
  3. 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.
  4. If the current node is a leaf node then increment the count by 1.
  5. Recursively call for the left and right subtree with the updated count.
  6. 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 series
vector<int> fib;
 
// Binary Tree Node
struct node {
    struct node* left;
    int data;
    struct node* right;
};
 
// Function to create a new tree node
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 tree
int 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 terms
void 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 tree
int 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 not
void 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 code
int 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 tree
import java.util.*;
 
class GFG{
 
// Vector to store the fibonacci series
static Vector<Integer> fib = new Vector<Integer>();
 
// Binary Tree Node
static class node {
    node left;
    int data;
    node right;
};
 
// Function to create a new tree node
static 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 tree
static 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 terms
static 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 tree
static 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 not
static 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 code
public 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 series
fib = []
  
# Binary Tree Node
class node:
     
    def __init__(self, data):
         
        self.data = data
        self.left = None
        self.right = None
  
# Function to create a new tree node
def newNode(data):
 
    temp = node(data)
    return temp
  
# Function to find the height
# of the given tree
def 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 terms
def 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 tree
def 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 not
def CountPath(root):
 
    # To find the height
    ht = height(root)
  
    # Making fibonacci series
    # upto ht terms
    FibonacciSeries(ht)
     
    print(CountPathUtil(root, 0, 0))
 
# Driver code
if __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 tree
using System;
using System.Collections.Generic;
 
class GFG{
  
// List to store the fibonacci series
static List<int> fib = new List<int>();
  
// Binary Tree Node
class node {
    public node left;
    public int data;
    public node right;
};
  
// Function to create a new tree node
static 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 tree
static 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 terms
static 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 tree
static 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 not
static 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 code
public 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

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!