Count Good Nodes in Binary Tree

Author: dksifoua

README.md

@@ -59,6 +59,7 @@
 | 0853 | Medium     | Car Fleet                                      | Array, Stack, Sorting, Monotonic Stack                               | [solution](./docs/0853-Car-Fleet.md)                                      |
 | 0875 | Medium     | Koko Eating Bananas                            | Array, Binary Search                                                 | [solution](./docs/0875-Koko-Eating-Bananas.md)                            |
 | 0981 | Medium     | Time Based Key-Value Store                     | Hash Table, String, Binary Search, Design                            | [solution](./docs/0981-Time-Based-Key-Value-Store.md)                     |
+| 1448 | Medium     | Count Good Nodes in Binary Tree                | Tree, Depth-First Search, Breadth-First Search, Binary Tree          | [solution](./docs/1448-Count-Good-Nodes-in-Binary-Tree.md)                |
 | 1768 | Easy       | Merge Strings Alternately                      | Two Pointers, String                                                 | [solution](./docs/1768-Merge-Strings-Alternately.md)                      |
 
 ![Alt](https://repobeats.axiom.co/api/embed/3071ed0c351defe6d37f0d25b516d3314bbf9f30.svg "RepoBeats analytics image")

docs/1448-Count-Good-Nodes-in-Binary-Tree.md

@@ -0,0 +1,40 @@
+# [Count Good Nodes in Binary Tree](https://leetcode.com/problems/count-good-nodes-in-binary-tree/description/)
+
+## Intuition
+
+A node in the binary tree is considered “good” if its value is greater than or equal to the maximum value encountered on
+the path from the root to that node. The problem can be solved efficiently using a Breadth-First Search (BFS) approach
+where we maintain the maximum value encountered so far at each level of traversal.
+
+## Approach
+
+1. **Breadth-First Search (BFS):**
+    - Use a queue to traverse the binary tree level by level.
+    - Each element in the queue is a tuple (`Tuple2<TreeNode, Integer>`) consisting of the current node and the maximum
+      value observed from the root to that node.
+2. **Check for Good Nodes:**
+    - For each node dequeued:
+        - Compare its value with the maximum value in its path.
+        - If the node’s value is greater than or equal to this maximum value, it is a good node, and we increment the
+          result.
+        - Update the maximum value for the path by taking the larger of the current node’s value and the previous
+          maximum.
+    - Enqueue the left and right children of the current node (if they exist) along with the updated maximum value.
+3. **Return the Result:** After completing the BFS traversal, result contains the total number of good nodes.
+
+## Complexity
+
+- **Time Complexity: `O(n)`, where `n` is the number of nodes in the tree. Each node is visited once during the
+  traversal.
+- **Space Complexity: `O(n)`**, for the queue, which may hold up to `n` nodes in the worst case (e.g., for a complete
+  binary tree).
+
+## Code
+
+- [Java](../src/main/java/io/dksifoua/leetcode/countgoodnodesinbinarytree/Solution.java)
+
+## Summary
+
+This BFS solution efficiently counts the “good” nodes in a binary tree by maintaining the maximum value along each path.
+Using a queue to traverse the tree ensures a level-by-level exploration, and the algorithm achieves optimal `O(n)` time
+complexity. The use of a tuple makes it easy to pass and update the maximum value dynamically during traversal.

src/main/java/io/dksifoua/leetcode/countgoodnodesinbinarytree/Solution.java

@@ -0,0 +1,34 @@
+package io.dksifoua.leetcode.countgoodnodesinbinarytree;
+
+import io.dksifoua.leetcode.utils.TreeNode;
+import io.dksifoua.leetcode.utils.Tuple2;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Solution {
+
+    public int goodNodes(TreeNode root) {
+        int result = 0;
+        if (root == null) return result;
+
+        Queue<Tuple2<TreeNode, Integer>> queue = new LinkedList<>() {{
+            add(new Tuple2<>(root, Integer.MIN_VALUE));
+        }};
+        while (!queue.isEmpty()) {
+            Tuple2<TreeNode, Integer> tuple2 = queue.remove();
+            TreeNode node = tuple2.first();
+            Integer maxValue = tuple2.second();
+
+            if (node.getValue() >= maxValue) {
+                maxValue = node.getValue();
+                result += 1;
+            }
+
+            if (node.getLeft() != null) queue.add(new Tuple2<>(node.getLeft(), maxValue));
+            if (node.getRight() != null) queue.add(new Tuple2<>(node.getRight(), maxValue));
+        }
+
+        return result;
+    }
+}

src/test/java/io/dksifoua/leetcode/countgoodnodesinbinarytree/SolutionTest.java

@@ -0,0 +1,27 @@
+package io.dksifoua.leetcode.countgoodnodesinbinarytree;
+
+import io.dksifoua.leetcode.utils.TreeNode;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class SolutionTest {
+
+    final Solution solution = new Solution();
+
+    @Test
+    void test1() {
+        assertEquals(4, solution.goodNodes(TreeNode.build(new Integer[] { 3, 1, 4, 3, null, 1, 5 })));
+    }
+
+    @Test
+    void test2() {
+        assertEquals(3, solution.goodNodes(TreeNode.build(new Integer[] { 3, 3, null, 4, 2 })));
+    }
+
+    @Test
+    void test3() {
+        assertEquals(1, solution.goodNodes(TreeNode.build(new Integer[] { 1 })));
+    }
+}