feat(content): add new problem pages, reorganize docs into (problems) subfolders, and update meta display to page

apps/docs/content/(03-hierarchical)/tree-bfs/(problems)/102_binary-tree-level-order-traversal.mdx

@@ -0,0 +1,86 @@
+---
+title: '102. Binary Tree Level Order Traversal'
+description: Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level)
+icon: dot
+topics:
+  - { name: "Tree", slug: "tree" }
+  - { name: "Breadth-First Search", slug: "breadth-first-search" }
+  - { name: "Binary Tree", slug: "binary-tree" }
+video: "6ZnyEApgFYg"
+issue: "https://github.com/prdlk/leetcode/issues/106"
+sidebar:
+  label: 'Binary Tree Level Order Traversal'
+  badge: 'Medium'
+---
+
+### Example 1:
+- Input: `root = [3,9,20,null,null,15,7]`
+- Output: `[[3],[9,20],[15,7]]`
+
+### Example 2:
+- Input: `root = [1]`
+- Output: `[[1]]`
+
+### Example 3:
+- Input: `root = []`
+- Output: `[]`
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [0, 2000].
+- `-1000 <= Node.val <= 1000`
+
+## Approach
+
+```mermaid
+flowchart TD
+  S(["levelOrder(root)"]) --> I["res = [], q = deque(), q.append(root)"]
+  I --> W{"q non-empty?"}
+  W -- no --> E(["return res"])
+  W -- yes --> L["qLen = len(q), level = [] — qLen freezes the current level's size"]
+  L --> F{"more i in range(qLen)?"}
+  F -- no --> V{"level non-empty?"}
+  V -- yes --> A["res.append(level)"]
+  A --> W
+  V -- no --> W
+  F -- yes --> P["node = q.popleft()"]
+  P --> N{"node is not None?"}
+  N -- no --> F
+  N -- yes --> C["level.append(node.val), q.append(node.left), q.append(node.right) — None children are filtered on the next level"]
+  C --> F
+```
+
+## 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
+from collections import deque
+
+
+class Solution:
+    # T: O(n) S: O(n)
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        res = []
+
+        q = deque()
+        q.append(root)
+
+        while q:
+            qLen = len(q)
+            level = []
+            for i in range(qLen):
+                node = q.popleft()
+                if node:
+                    level.append(node.val)
+                    q.append(node.left)
+                    q.append(node.right)
+            if level:
+                res.append(level)
+
+        return res
+```

apps/docs/content/(03-hierarchical)/tree-bfs/(problems)/1448_count-good-nodes-in-binary-tree.mdx

@@ -0,0 +1,74 @@
+---
+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"
+issue: "https://github.com/prdlk/leetcode/issues/108"
+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)
+```

apps/docs/content/(03-hierarchical)/tree-bfs/(problems)/199_binary-tree-right-side-view.mdx

@@ -0,0 +1,90 @@
+---
+title: '199. Binary Tree Right Side View'
+description: Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom
+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: "d4zLyf32e3I"
+issue: "https://github.com/prdlk/leetcode/issues/107"
+sidebar:
+  label: 'Binary Tree Right Side View'
+  badge: 'Medium'
+---
+
+### Example 1:
+- Input: `root = [1,2,3,null,5,null,4]`
+- Output: `[1,3,4]`
+
+### Example 2:
+- Input: `root = [1,2,3,4,null,null,null,5]`
+- Output: `[1,3,4,5]`
+
+### Example 3:
+- Input: `root = [1,null,3]`
+- Output: `[1,3]`
+
+### Example 4:
+- Input: `root = []`
+- Output: `[]`
+
+### Constraints:
+
+- The number of nodes in the tree is in the range [0, 100].
+- `-100 <= Node.val <= 100`
+
+## Approach
+
+```mermaid
+flowchart TD
+  S(["rightSideView(root)"]) --> I["res = [], q = deque([root])"]
+  I --> W{"q non-empty?"}
+  W -- no --> E(["return res"])
+  W -- yes --> L["rightSide = None, qLen = len(q) — qLen freezes the current level's size"]
+  L --> F{"more i in range(qLen)?"}
+  F -- no --> V{"rightSide is not None?"}
+  V -- yes --> A["res.append(rightSide.val) — the last real node popped on this level is the rightmost"]
+  A --> W
+  V -- no --> W
+  F -- yes --> P["node = q.popleft()"]
+  P --> N{"node is not None?"}
+  N -- no --> F
+  N -- yes --> C["rightSide = node, q.append(node.left), q.append(node.right)"]
+  C --> F
+```
+
+## 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
+from collections import deque
+
+
+class Solution:
+    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
+        res = []
+        q = deque([root])
+
+        while q:
+            rightSide = None
+            qLen = len(q)
+
+            for i in range(qLen):
+                node = q.popleft()
+                if node:
+                    rightSide = node
+                    q.append(node.left)
+                    q.append(node.right)
+
+            if rightSide:
+                res.append(rightSide.val)
+
+        return res
+```