Skip to content
Related Articles

Related Articles

Count paths in a Binary Tree consisting of nodes in non-decreasing order

Improve Article
Save Article
Like Article
  • Last Updated : 24 Sep, 2021

Given a Binary Tree consisting of N nodes, the task is to find the number of paths from the root to any node X, such that all the node values in that path are at most X.

Examples:

Input: Below is the given Tree:

Output: 4
Explanation:

The paths from the root to any node X that have value at most values of node X are:

  • Node 3(root node): It always follows the given property.
  • Node 4: The path starting from the root to node with value 4 has order (3 → 4), with the maximum value of a node being 4.
  • Node 5: The path starting from the root to node with value 5 has order (3 → 4 → 5), with the maximum value of a node being 5.
  • Node 3: The path starting from the root to node with value 3 has order (3 → 1 → 3), with the maximum value of a node being 3.

Therefore, the count of required paths is 4.

Input: Below is the given Tree:

Output: 3

Approach – using DFS: The idea is to traverse the tree using a Depth First Search traversal while checking if the maximum value from root to any node X is equal to X or not. 
Follow the steps below to solve the problem:

  • Initialize a variable, say count as 0 to store the count of paths from the root to any node X having all the node values in that path is at most X.
  • Traverse the tree recursively using depth-first-search and perform the following steps:
    • Every recursive call for DFS Traversal, apart from the parent node, pass the maximum value of the node obtained so far in that path.
    • Check if the current node value is greater or equal to the maximum value obtained so far, then increment the value of count by 1 and update the maximum value to the current node value.
  • After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Node structure of the binary tree
struct Node {
    int val;
    Node *left, *right;
};
 
// Function for creating new node
struct Node* newNode(int data)
{
    // Allocate memory for new node
    struct Node* temp = new Node();
 
    // Assigning data value
    temp->val = data;
    temp->left = NULL;
    temp->right = NULL;
 
    // Return the Node
    return temp;
}
 
// Function to perform the DFS Traversal
// to find the number of paths having
// root to node X has value at most X
int countNodes(Node* root, int max)
{
    // If the root node is NULL
    if (!root)
        return 0;
 
    // Check if the current value is
    // greater than the maximum value
    // in path from root to current node
    if (root->val >= max)
        return 1 + countNodes(root->left,
                              root->val)
               + countNodes(root->right, root->val);
 
    // Otherwise
    return countNodes(root->left,
                      max)
           + countNodes(root->right,
                        max);
}
 
// Driver Code
int main()
{
    // Given Binary Tree
    Node* root = NULL;
    root = newNode(3);
    root->left = newNode(1);
    root->right = newNode(4);
    root->left->left = newNode(3);
    root->right->left = newNode(1);
    root->right->right = newNode(5);
 
    cout << countNodes(root, INT_MIN);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
 
// Class containing left and
// right child of current
// node and key value
class Node {
  
    int data;
    Node left, right;
  
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
  
 
class GFG {
     
    // Root of the Binary Tree
    Node root;
  
    public GFG()
    {
        root = null;
    }
     
    // Function to perform the DFS Traversal
// to find the number of paths having
// root to node X has value at most X
static int countNodes(Node root, int max)
{
   
    // If the root node is NULL
    if (root == null)
        return 0;
 
    // Check if the current value is
    // greater than the maximum value
    // in path from root to current node
    if (root.data >= max)
        return 1 + countNodes(root.left,
                              root.data)
               + countNodes(root.right, root.data);
 
    // Otherwise
    return countNodes(root.left,
                      max)
           + countNodes(root.right,
                        max);
}
 
  // Driver code
public static void main (String[] args)
{
   
      GFG tree = new GFG();
        tree.root = new Node(3);
        tree.root.left = new Node(1);
        tree.root.right = new Node(4);
        tree.root.left.left = new Node(3);
        tree.root.right.left = new Node(1);
        tree.root.right.right = new Node(5);
      System.out.println(countNodes(tree.root, Integer.MIN_VALUE));
    }
}
 
// This code is contributed by offbeat

Python3




# Python3 program for the above approach
 
# Node structure of the binary tree
class Node:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
 
# Function to perform the DFS Traversal
# to find the number of paths having
# root to node X has value at most X
def countNodes(root, max):
    # If the root node is NULL
    if (not root):
        return 0
 
    # Check if the current value is
    # greater than the maximum value
    #in path from root to current node
    if (root.val >= max):
        return 1 + countNodes(root.left,root.val) + countNodes(root.right, root.val)
 
    # Otherwise
    return countNodes(root.left, max) + countNodes(root.right, max)
 
# Driver Code
if __name__ == '__main__':
   
    # Given Binary Tree
    root = Node(3)
    root.left = Node(1)
    root.right = Node(4)
    root.left.left = Node(3)
    root.right.left = Node(1)
    root.right.right = Node(5)
 
    print(countNodes(root, -10**19))
 
# This code is contributed by mohit kumar 29.

C#




// C# program to count frequencies of array items
using System;
 
// Class containing left and
// right child of current
// node and key value
class Node {
  
    public int data;
    public Node left, right;
  
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
  
public class GFG
{
     
    // Root of the Binary Tree
    Node root;
    public GFG()
    {
        root = null;
    }
     
// Function to perform the DFS Traversal
// to find the number of paths having
// root to node X has value at most X
static int countNodes(Node root, int max)
{
   
    // If the root node is NULL
    if (root == null)
        return 0;
 
    // Check if the current value is
    // greater than the maximum value
    // in path from root to current node
    if (root.data >= max)
        return 1 + countNodes(root.left,
                              root.data)
               + countNodes(root.right, root.data);
 
    // Otherwise
    return countNodes(root.left,
                      max)
           + countNodes(root.right,
                        max);
}
 
// Driver code
public static void Main(String []args)
{
        GFG tree = new GFG();
        tree.root = new Node(3);
        tree.root.left = new Node(1);
        tree.root.right = new Node(4);
        tree.root.left.left = new Node(3);
        tree.root.right.left = new Node(1);
        tree.root.right.right = new Node(5);
        Console.WriteLine(countNodes(tree.root, Int32.MinValue));
    }
}
 
// This code is contributed by jana_sayantan.

Javascript




<script>
    // Javascript program for the above approach
     
    // Class containing left and
    // right child of current
    // node and key value
    class Node
    {
        constructor(item) {
           this.left = null;
           this.right = null;
           this.data = item;
        }
    }
     
    // Root of the Binary Tree
    let root;
     
    class GFG
    {
        constructor() {
           root = null;
        }
    }
     
    // Function to perform the DFS Traversal
    // to find the number of paths having
    // root to node X has value at most X
    function countNodes(root, max)
    {
 
        // If the root node is NULL
        if (root == null)
            return 0;
 
        // Check if the current value is
        // greater than the maximum value
        // in path from root to current node
        if (root.data >= max)
            return 1 + countNodes(root.left, root.data)
                   + countNodes(root.right, root.data);
 
        // Otherwise
        return countNodes(root.left, max)
               + countNodes(root.right, max);
    }
     
    let tree = new GFG();
    tree.root = new Node(3);
    tree.root.left = new Node(1);
    tree.root.right = new Node(4);
    tree.root.left.left = new Node(3);
    tree.root.right.left = new Node(1);
    tree.root.right.right = new Node(5);
      document.write(countNodes(tree.root, Number.MIN_VALUE));
 
// This code is contributed by sureh07.
</script>
Output: 
4

 

Time Complexity: O(N)
Auxiliary Space: O(N)

Approach using BFS: The idea is to traverse the tree using breadth-first search while checking if the maximum value from root to X is equal to X. Follow the steps below to solve the problem:

  • Initialize a variable, say count as 0 to store the count of paths from the root to any node X having all the node values in that path is at most X and a queue Q of pairs to perform the BFS Traversal.
  • Push the root node with INT_MIN as the maximum value in the queue.
  • Now, until Q is non-empty perform the following:
    • Pop the front node from the queue.
    • If the front node value is at least the current maximum value obtained so far, then increment the value of count by 1.
    • Update the maximum value that occurred so far with the current node value.
    • If the left and right nodes exist for the current popped node then push it into the queue Q with the updated maximum value in the above step.
  • After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Node of the binary tree
struct Node {
    int val;
    Node *left, *right;
};
 
// Function for creating new node
struct Node* newNode(int data)
{
    // Allocate memory for new node
    struct Node* temp = new Node();
    temp->val = data;
    temp->left = NULL;
    temp->right = NULL;
 
    // Return the created node
    return temp;
}
 
// Function to perform the DFS Traversal
// to find the number of paths having
// root to node X has value at most X
int countNodes(Node* root)
{
    // Initialize queue
    queue<pair<Node*, int> > q;
    int m = INT_MIN;
 
    // Push root in queue with the
    // maximum value m
    q.push({ root, m });
 
    // Stores the count of good nodes
    int count = 0;
 
    // Traverse all nodes
    while (!q.empty()) {
 
        // Store the front node of
        // the queue
        auto temp = q.front();
        q.pop();
        Node* node = temp.first;
        int num = temp.second;
 
        // Check is current node is
        // greater than the maximum
        // value in path from root to
        // the current node
        if (node->val >= num)
            count++;
 
        // Update the maximum value m
        m = max(node->val, num);
 
        // If left child is not null,
        // push it to queue with the
        // maximum value m
        if (node->left)
            q.push({ node->left, m });
 
        // If right child is not null,
        // push it to queue with the
        // maximum value m
        if (node->right)
            q.push({ node->right, m });
    }
 
    // Returns the answer
    return count;
}
 
// Driver Code
int main()
{
    // Construct a Binary Tree
    Node* root = NULL;
    root = newNode(3);
    root->left = newNode(1);
    root->right = newNode(4);
    root->left->left = newNode(3);
    root->right->left = newNode(1);
    root->right->right = newNode(5);
 
    cout << countNodes(root);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
 
// Node of the binary tree
class Node {
   
    int val;
    Node left, right;
   
    public Node(int data)
    {
        val = data;
        left = right = null;
    }
}
 
// User defined Pair class
class Pair {
    Node x;
    int y;
   
    // Constructor
    public Pair(Node x, int y)
    {
        this.x = x;
        this.y = y;
    }
}
     
public class Main
{
    // Function for creating new node
    static Node newNode(int data)
    {
        // Allocate memory for new node
        Node temp = new Node(data);
       
        // Return the created node
        return temp;
    }
       
    // Function to perform the DFS Traversal
    // to find the number of paths having
    // root to node X has value at most X
    static int countNodes(Node root)
    {
        // Initialize queue
        Vector<Pair> q = new Vector<Pair>();
        int m = Integer.MIN_VALUE;
       
        // Push root in queue with the
        // maximum value m
        q.add(new Pair(root, m));
       
        // Stores the count of good nodes
        int count = 0;
       
        // Traverse all nodes
        while (q.size() > 0) {
       
            // Store the front node of
            // the queue
            Pair temp = q.get(0);
            q.remove(0);
            Node node = temp.x;
            int num = temp.y;
       
            // Check is current node is
            // greater than the maximum
            // value in path from root to
            // the current node
            if (node.val >= num)
                count++;
       
            // Update the maximum value m
            m = Math.max(node.val, num);
       
            // If left child is not null,
            // push it to queue with the
            // maximum value m
            if (node.left != null)
                q.add(new Pair(node.left, m));
       
            // If right child is not null,
            // push it to queue with the
            // maximum value m
            if (node.right != null)
                q.add(new Pair(node.right, m));
        }
       
        // Returns the answer
        return count;
    }
 
    public static void main(String[] args) {
        // Construct a Binary Tree
        Node root = null;
        root = newNode(3);
        root.left = newNode(1);
        root.right = newNode(4);
        root.left.left = newNode(3);
        root.right.left = newNode(1);
        root.right.right = newNode(5);
       
        System.out.println(countNodes(root));
    }
}
 
// This code is contributed by mukesh07.

Python3




# Python3 program for the above approach
import sys
 
# Node of the binary tree
class Node:
    def __init__(self, data):
        self.val = data
        self.left = None
        self.right = None
 
# Function for creating new node
def newNode(data):
    # Allocate memory for new node
    temp = Node(data)
 
    # Return the created node
    return temp
 
# Function to perform the DFS Traversal
# to find the number of paths having
# root to node X has value at most X
def countNodes(root):
    # Initialize queue
    q = []
    m = -sys.maxsize
 
    # Push root in queue with the
    # maximum value m
    q.append([ root, m ])
 
    # Stores the count of good nodes
    count = 0
 
    # Traverse all nodes
    while (len(q) > 0):
        # Store the front node of
        # the queue
        temp = q[0]
        q.pop(0)
        node = temp[0]
        num = temp[1]
 
        # Check is current node is
        # greater than the maximum
        # value in path from root to
        # the current node
        if (node.val >= num):
            count+=1
 
        # Update the maximum value m
        m = max(node.val, num)
 
        # If left child is not null,
        # push it to queue with the
        # maximum value m
        if (node.left != None):
            q.append([ node.left, m ])
 
        # If right child is not null,
        # push it to queue with the
        # maximum value m
        if (node.right != None):
            q.append([ node.right, m ])
 
    # Returns the answer
    return count
 
# Construct a Binary Tree
root = None
root = newNode(3)
root.left = newNode(1)
root.right = newNode(4)
root.left.left = newNode(3)
root.right.left = newNode(1)
root.right.right = newNode(5)
 
print(countNodes(root))
 
# This code is contributed by rameshtravel07.

C#




// C# program for the above approach
using System;
using System.Collections;
class GFG {
     
    // Node of the binary tree
    class Node {
        
        public int val;
        public Node left, right;
        
        public Node(int data)
        {
            val = data;
            left = right = null;
        }
    }
     
    // Function for creating new node
    static Node newNode(int data)
    {
        // Allocate memory for new node
        Node temp = new Node(data);
      
        // Return the created node
        return temp;
    }
      
    // Function to perform the DFS Traversal
    // to find the number of paths having
    // root to node X has value at most X
    static int countNodes(Node root)
    {
        // Initialize queue
        Queue q = new Queue();
        int m = Int32.MinValue;
      
        // Push root in queue with the
        // maximum value m
        q.Enqueue(new Tuple<Node, int>(root, m));
      
        // Stores the count of good nodes
        int count = 0;
      
        // Traverse all nodes
        while (q.Count > 0) {
      
            // Store the front node of
            // the queue
            Tuple<Node, int> temp = (Tuple<Node, int>)q.Peek();
            q.Dequeue();
            Node node = temp.Item1;
            int num = temp.Item2;
      
            // Check is current node is
            // greater than the maximum
            // value in path from root to
            // the current node
            if (node.val >= num)
                count++;
      
            // Update the maximum value m
            m = Math.Max(node.val, num);
      
            // If left child is not null,
            // push it to queue with the
            // maximum value m
            if (node.left != null)
                q.Enqueue(new Tuple<Node, int>(node.left, m));
      
            // If right child is not null,
            // push it to queue with the
            // maximum value m
            if (node.right != null)
                q.Enqueue(new Tuple<Node, int>(node.right, m));
        }
      
        // Returns the answer
        return count;
    }
     
  // Driver code
  static void Main()
  {
     
    // Construct a Binary Tree
    Node root = null;
    root = newNode(3);
    root.left = newNode(1);
    root.right = newNode(4);
    root.left.left = newNode(3);
    root.right.left = newNode(1);
    root.right.right = newNode(5);
  
    Console.Write(countNodes(root));
  }
}
 
// This code is contributed by decode2207.

Javascript




<script>
 
    // JavaScript program for the above approach
     
    class Node
    {
        constructor(data) {
           this.left = null;
           this.right = null;
           this.val = data;
        }
    }
     
    // Function for creating new node
    function newNode(data)
    {
        // Allocate memory for new node
        let temp = new Node(data);
 
        // Return the created node
        return temp;
    }
 
    // Function to perform the DFS Traversal
    // to find the number of paths having
    // root to node X has value at most X
    function countNodes(root)
    {
        // Initialize queue
        let q = [];
        let m = Number.MIN_VALUE;
 
        // Push root in queue with the
        // maximum value m
        q.push([ root, m ]);
 
        // Stores the count of good nodes
        let count = 0;
 
        // Traverse all nodes
        while (q.length > 0) {
 
            // Store the front node of
            // the queue
            let temp = q[0];
            q.shift();
            let node = temp[0];
            let num = temp[1];
 
            // Check is current node is
            // greater than the maximum
            // value in path from root to
            // the current node
            if (node.val >= num)
                count++;
 
            // Update the maximum value m
            m = Math.max(node.val, num);
 
            // If left child is not null,
            // push it to queue with the
            // maximum value m
            if (node.left)
                q.push([ node.left, m ]);
 
            // If right child is not null,
            // push it to queue with the
            // maximum value m
            if (node.right)
                q.push([ node.right, m ]);
        }
 
        // Returns the answer
        return count;
    }
     
    // Construct a Binary Tree
    let root = null;
    root = newNode(3);
    root.left = newNode(1);
    root.right = newNode(4);
    root.left.left = newNode(3);
    root.right.left = newNode(1);
    root.right.right = newNode(5);
  
    document.write(countNodes(root));
     
</script>
Output: 
4

 

Time Complexity: O(N)
Auxiliary Space: O(N)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!