docs(docs): add meta files and reorganize topics with updated badges and directory structure

apps/docs/content/(tree-bfs)/1448-count-good-nodes-in-binary-tree.mdx

@@ -0,0 +1,72 @@
+---
+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
+sidebar:
+  label: 'Count Good Nodes in Binary Tree'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Tree</Badge>
+
+### 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)
+```
+
+## Explanation
+
+<YouTube id="7cp5imvDzl4" title="Microsoft's Most Asked Question 2021 - Count Good Nodes in a Binary Tree - Leetcode 1448 - Python" />