---
title: '1448. Count Good Nodes in Binary Tree'
description: Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X
icon: dot
topics:
  - { name: "Tree", slug: "tree" }
  - { name: "Depth-First Search", slug: "depth-first-search" }
  - { name: "Breadth-First Search", slug: "breadth-first-search" }
  - { name: "Binary Tree", slug: "binary-tree" }
video: "7cp5imvDzl4"
sidebar:
  label: 'Count Good Nodes in Binary Tree'
  badge: 'Medium'
---

### Example 1:
- Input: `root = [3,1,4,3,null,1,5]`
- Output: `4`
- Explanation: Nodes in blue are good. Root Node `(3`) is always a good node. Node `4` -> (3,4) is the maximum value in the path starting from the `root`. Node `5` -> (3,4,5) is the maximum value in the path Node `3` -> (3,1,3) is the maximum value in the path.

### Example 2:
- Input: `root = [3,3,null,4,2]`
- Output: `3`
- Explanation: Node `2` -> `(3`, `3`, `2`) is not good, because `"3`" is higher than it.

### Example 3:
- Input: `root = [1]`
- Output: `1`
- Explanation: Root is considered as good.

### Constraints:

- The number of nodes in the binary tree is in the range [1, 10^5].
- Each node's value is between [-10^4, 10^4].

## Approach

```mermaid
flowchart TD
  S(["goodNodes(root)"]) --> C["dfs(root, root.val) — the root is always good"]
  C --> E(["return that count"])
  subgraph dfs["dfs(node, max_val)"]
    D1{"node is None?"} -- yes --> D2(["return 0"])
    D1 -- no --> D3["is_good = 1 if node.val >= max_val else 0 — max_val is the largest value on the path so far"]
    D3 --> D4["new_max = max(max_val, node.val)"]
    D4 --> D5["l = dfs(node.left, new_max), r = dfs(node.right, new_max)"]
    D5 --> D6(["return is_good + l + r"])
  end
  C --> dfs
```

## Solution

```py
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def goodNodes(self, root: TreeNode) -> int:
        def dfs(node, max_val):
            if not node:
                return 0

            is_good = 1 if node.val >= max_val else 0
            new_max = max(max_val, node.val)

            return is_good + dfs(node.left, new_max) + dfs(node.right, new_max)

        return dfs(root, root.val)
```