Count paths in a Binary Tree consisting of nodes in non-decreasing order
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 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 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# 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.
<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>
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 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 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# 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.
<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>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Count the number of Nodes in a Binary Tree in Constant Space Given a binary tree having N nodes, count the number of nodes using constant O(1) space. This can be done by simple traversals like- Preorder, InOrder, PostOrder, and LevelOrder but these traversals require an extra space which is equal to the height of the tree. Examples: Input: Output: 5Explanatio
10 min read
Count of nodes in a binary tree having their nodes in range [L, R] Given a Binary Tree consisting of n nodes and two positive integers l and r, the task is to find the count of nodes having their value in the range [l, r].Examples:Input: l = 4, r = 15Output: 4Explanation: The nodes in the given Tree that lies in the range [4, 15] are {4, 5, 6, 7}.Input: l = 1, r =
10 min read
Count levels in a Binary Tree consisting of nodes valued 1 grouped together Given a Binary Tree consisting of 0s and 1s only, the task is to print the count of levels in the Binary Tree in which all the 1s are placed consecutively in a single group. Examples: Input: 0 / \ 1 0 / \ / \ 1 0 1 0 Output: 2 Explanation: In Levels 1 and 2, all the nodes with value 1 are placed con
10 min read
Count of strictly increasing and decreasing paths in directed Binary Tree Given a directed binary tree of N nodes whose edges are directed from the parent to the child, the task is to count the number of strictly increasing and decreasing paths. Note: A path starts at the root and ends at any leaf. Examples: Input: N = 6tree = 6 / \ 4 7 \ / \ 5 6 8Output: 10 8Explanation:
12 min read
Count levels in a Binary Tree consisting of node values having set bits at different positions Given a Binary Tree consisting of N nodes, the task is to count the number of levels in a Binary Tree such that the set bits of all the node values at the same level is at different positions. Examples: Input: 5 / \ 6 9 / \ \ 1 4 7 Output: 2 Explanation: Level 1 has only 5 (= (101)2). Level 2 has 6
10 min read
Count root to leaf paths having exactly K distinct nodes in a Binary Tree Given a Binary Tree consisting of N nodes rooted at 1, an integer K and an array arr[] consisting of values assigned to each node, the task is to count the number of root to leaf paths having exactly K distinct nodes in the given Binary Tree. Examples: Input: N = 3, Edges[][] = {{1, 2}, {1, 3}}, arr
11 min read