# Count of 1’s in any path in a Binary Tree

Given a binary tree of 0s and 1s, the task is to find the maximum number of 1s in any path in the tree. The path may start and end at any node in the tree.

Example:

```Input:
1
/ \
0   1
/ \
1   1
/ \
1   0

Output: 4
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. A function countUntil has been created which returns the maximum count of 1 in any vertical path below that node.
2. This path must be a single path and this path must include at-most one child of the node as well as its itself. i.e countUntil returns the max count of 1 in either left child or right child and also includes itself in count if its value is 1.
3. So, from any node countUntil(node->left) + countUntil(node->right) + node->value will give the number of 1s in the path which contains the node and its left and right path and no ancestor of the node is considered.
4. Taking the maximum of all nodes will give the required answer.

Below is the implementation of the above approach

## C++

 `// C++ implementation of the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// A binary tree node ` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node *left, *right; ` `}; ` ` `  `// A utility function to allocate a new node ` `struct` `Node* newNode(``int` `data) ` `{ ` `    ``struct` `Node* newNode = ``new` `Node; ` `    ``newNode->data = data; ` `    ``newNode->left = newNode->right = NULL; ` `    ``return` `(newNode); ` `} ` ` `  `// This function updates overall count of 1 in 'res' ` `// And returns count 1s going through root. ` `int` `countUntil(Node* root, ``int``& res) ` `{ ` `    ``// Base Case ` `    ``if` `(root == NULL) ` `        ``return` `0; ` ` `  `    ``// l and r store count of 1s going through left and ` `    ``// right child of root respectively ` `    ``int` `l = countUntil(root->left, res); ` `    ``int` `r = countUntil(root->right, res); ` ` `  `    ``// maxCount represents the count of 1s when the Node under ` `    ``// consideration is the root of the maxCount path and no ` `    ``// ancestors of the root are there in maxCount path ` `    ``int` `maxCount; ` ` `  `    ``// if the value at node is 1 then its ` `    ``// count will be considered ` `    ``// including the leftCount and the rightCount ` `    ``if` `(root->data == 1) ` `        ``maxCount = l + r + 1; ` `    ``else` `        ``maxCount = l + r; ` ` `  `    ``// Store the Maximum Result. ` `    ``res = max(res, maxCount); ` ` `  `    ``// return max count in a single path. ` `    ``// This path must include at-most one child ` `    ``// of the root as well as itself ` ` `  `    ``// if the value at node is 1 ` `    ``// then its count will be considered ` `    ``// including the maximum of leftCount or the rightCount ` `    ``if` `(root->data == 1) ` `        ``return` `max(l, r) + 1; ` `    ``else` `        ``return` `max(l, r); ` `} ` ` `  `// Returns maximum count of 1 in any path ` `// in tree with given root ` `int` `findMaxCount(Node* root) ` `{ ` `    ``// Initialize result ` `    ``int` `res = INT_MIN; ` ` `  `    ``// Compute and return result ` `    ``countUntil(root, res); ` `    ``return` `res; ` `} ` ` `  `// Driver program ` `int` `main(``void``) ` `{ ` `    ``struct` `Node* root = newNode(1); ` `    ``root->left = newNode(0); ` `    ``root->right = newNode(1); ` `    ``root->left->left = newNode(1); ` `    ``root->left->right = newNode(1); ` `    ``root->left->right->left = newNode(1); ` `    ``root->left->right->right = newNode(0); ` `    ``cout << findMaxCount(root); ` `    ``return` `0; ` `} `

## Java

 `// Java implementation of the above approach ` `class` `GFG ` `{ ` ` `  `    ``// A binary tree node ` `    ``static` `class` `Node  ` `    ``{ ` `        ``int` `data; ` `        ``Node left, right; ` `    ``}; ` ` `  `    ``static` `int` `res; ` ` `  `    ``// A utility function to allocate a new node ` `    ``static` `Node newNode(``int` `data) ` `    ``{ ` `        ``Node newNode = ``new` `Node(); ` `        ``newNode.data = data; ` `        ``newNode.left = newNode.right = ``null``; ` `        ``return` `(newNode); ` `    ``} ` ` `  `    ``// This function updates overall count of 1 in 'res' ` `    ``// And returns count 1s going through root. ` `    ``static` `int` `countUntil(Node root)  ` `    ``{ ` `        ``// Base Case ` `        ``if` `(root == ``null``) ` `            ``return` `0``; ` ` `  `        ``// l and r store count of 1s going through left and ` `        ``// right child of root respectively ` `        ``int` `l = countUntil(root.left); ` `        ``int` `r = countUntil(root.right); ` ` `  `        ``// maxCount represents the count of 1s when the Node under ` `        ``// consideration is the root of the maxCount path and no ` `        ``// ancestors of the root are there in maxCount path ` `        ``int` `maxCount; ` ` `  `        ``// if the value at node is 1 then its ` `        ``// count will be considered ` `        ``// including the leftCount and the rightCount ` `        ``if` `(root.data == ``1``) ` `            ``maxCount = l + r + ``1``; ` `        ``else` `            ``maxCount = l + r; ` ` `  `        ``// Store the Maximum Result. ` `        ``res = Math.max(res, maxCount); ` ` `  `        ``// return max count in a single path. ` `        ``// This path must include at-most one child ` `        ``// of the root as well as itself ` ` `  `        ``// if the value at node is 1 ` `        ``// then its count will be considered ` `        ``// including the maximum of leftCount or the rightCount ` `        ``if` `(root.data == ``1``) ` `            ``return` `Math.max(l, r) + ``1``; ` `        ``else` `            ``return` `Math.max(l, r); ` `    ``} ` ` `  `    ``// Returns maximum count of 1 in any path ` `    ``// in tree with given root ` `    ``static` `int` `findMaxCount(Node root)  ` `    ``{ ` `        ``// Initialize result ` `        ``res = Integer.MIN_VALUE; ` ` `  `        ``// Compute and return result ` `        ``countUntil(root); ` `        ``return` `res; ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``Node root = newNode(``1``); ` `        ``root.left = newNode(``0``); ` `        ``root.right = newNode(``1``); ` `        ``root.left.left = newNode(``1``); ` `        ``root.left.right = newNode(``1``); ` `        ``root.left.right.left = newNode(``1``); ` `        ``root.left.right.right = newNode(``0``); ` `        ``System.out.print(findMaxCount(root)); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## C#

 `     `  `// C# implementation of the above approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `    ``// A binary tree node ` `    ``class` `Node  ` `    ``{ ` `        ``public` `int` `data; ` `        ``public` `Node left, right; ` `    ``}; ` ` `  `    ``static` `int` `res; ` ` `  `    ``// A utility function to allocate a new node ` `    ``static` `Node newNode(``int` `data) ` `    ``{ ` `        ``Node newNode = ``new` `Node(); ` `        ``newNode.data = data; ` `        ``newNode.left = newNode.right = ``null``; ` `        ``return` `(newNode); ` `    ``} ` ` `  `    ``// This function updates overall count of 1 in 'res' ` `    ``// And returns count 1s going through root. ` `    ``static` `int` `countUntil(Node root)  ` `    ``{ ` `        ``// Base Case ` `        ``if` `(root == ``null``) ` `            ``return` `0; ` ` `  `        ``// l and r store count of 1s going through left and ` `        ``// right child of root respectively ` `        ``int` `l = countUntil(root.left); ` `        ``int` `r = countUntil(root.right); ` ` `  `        ``// maxCount represents the count of 1s when the Node under ` `        ``// consideration is the root of the maxCount path and no ` `        ``// ancestors of the root are there in maxCount path ` `        ``int` `maxCount; ` ` `  `        ``// if the value at node is 1 then its ` `        ``// count will be considered ` `        ``// including the leftCount and the rightCount ` `        ``if` `(root.data == 1) ` `            ``maxCount = l + r + 1; ` `        ``else` `            ``maxCount = l + r; ` ` `  `        ``// Store the Maximum Result. ` `        ``res = Math.Max(res, maxCount); ` ` `  `        ``// return max count in a single path. ` `        ``// This path must include at-most one child ` `        ``// of the root as well as itself ` ` `  `        ``// if the value at node is 1 ` `        ``// then its count will be considered ` `        ``// including the maximum of leftCount or the rightCount ` `        ``if` `(root.data == 1) ` `            ``return` `Math.Max(l, r) + 1; ` `        ``else` `            ``return` `Math.Max(l, r); ` `    ``} ` ` `  `    ``// Returns maximum count of 1 in any path ` `    ``// in tree with given root ` `    ``static` `int` `findMaxCount(Node root)  ` `    ``{ ` `        ``// Initialize result ` `        ``res = ``int``.MinValue; ` ` `  `        ``// Compute and return result ` `        ``countUntil(root); ` `        ``return` `res; ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``Node root = newNode(1); ` `        ``root.left = newNode(0); ` `        ``root.right = newNode(1); ` `        ``root.left.left = newNode(1); ` `        ``root.left.right = newNode(1); ` `        ``root.left.right.left = newNode(1); ` `        ``root.left.right.right = newNode(0); ` `        ``Console.Write(findMaxCount(root)); ` `    ``} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```4
```

Time Complexity: O(n)
where n is number of nodes in Binary Tree.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : 29AjayKumar, princiraj1992