docs(docs): add Approach diagrams and Explanation sections to LeetCode problem documentation

apps/docs/content/(tree)/102-binary-tree-level-order-traversal.mdx

@@ -25,6 +25,26 @@ sidebar:
 - 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
@@ -59,3 +79,7 @@ class Solution:
 
         return res
 ```
+
+## Explanation
+
+<YouTube id="6ZnyEApgFYg" title="Binary Tree Level Order Traversal - BFS - Leetcode 102" />

apps/docs/content/(tree)/104-maximum-depth-of-binary-tree.mdx

@@ -21,6 +21,16 @@ sidebar:
 - The number of nodes in the tree is in the range [0, 10^4].
 - `-100 <= Node.val <= 100`
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["maxDepth(root)"]) --> B{"root is None?"}
+  B -- yes --> Z(["return 0"])
+  B -- no --> L["l = maxDepth(root.left), r = maxDepth(root.right)"]
+  L --> E(["return 1 + max(l, r) — this node adds one level above its deeper subtree"])
+```
+
 ## Solution
 
 ```py
@@ -37,3 +47,7 @@ class Solution:
 
         return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
 ```
+
+## Explanation
+
+<YouTube id="hTM3phVI6YQ" title="Maximum Depth of Binary Tree - 3 Solutions - Leetcode 104 - Python" />

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

@@ -28,6 +28,22 @@ sidebar:
 - 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
@@ -50,3 +66,7 @@ class Solution:
 
         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" />

apps/docs/content/(tree)/199-binary-tree-right-side-view.mdx

@@ -29,6 +29,26 @@ sidebar:
 - 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
@@ -62,3 +82,7 @@ class Solution:
 
         return res
 ```
+
+## Explanation
+
+<YouTube id="d4zLyf32e3I" title="Binary Tree Right Side View - Breadth First Search - Leetcode 199" />

apps/docs/content/(tree)/226-invert-binary-tree.mdx

@@ -25,6 +25,17 @@ sidebar:
 - The number of nodes in the tree is in the range [0, 100].
 - `-100 <= Node.val <= 100`
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["invertTree(root)"]) --> B{"root is None?"}
+  B -- yes --> Z(["return None"])
+  B -- no --> L["left = invertTree(root.left), right = invertTree(root.right) — both subtrees are already inverted"]
+  L --> X["root.left = right, root.right = left"]
+  X --> E(["return root"])
+```
+
 ## Solution
 
 ```py
@@ -47,3 +58,7 @@ class Solution:
 
         return root
 ```
+
+## Explanation
+
+<YouTube id="OnSn2XEQ4MY" title="Invert Binary Tree - Depth First Search - Leetcode 226" />

apps/docs/content/(tree)/230-kth-smallest-element-in-a-bst.mdx

@@ -26,6 +26,23 @@ If the BST is modified often (i.e., we can do insert and delete operations) and
 - `1 <= k <= n <= 10^4`
 - `0 <= Node.val <= 10^4`
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["kthSmallest(root, k)"]) --> I["n = 0, stack = [], cur = root"]
+  I --> W{"cur or stack?"}
+  W -- no --> E(["fall off the loop — unreachable, k <= n"])
+  W -- yes --> L{"cur?"}
+  L -- yes --> P["stack.append(cur), cur = cur.left — push the whole left spine"]
+  P --> L
+  L -- no --> O["cur = stack.pop(), n += 1 — nodes pop in ascending order"]
+  O --> K{"n == k?"}
+  K -- yes --> R(["return cur.val"])
+  K -- no --> N["cur = cur.right"]
+  N --> W
+```
+
 ## Solution
 
 ```py
@@ -52,3 +69,7 @@ class Solution:
                 return cur.val
             cur = cur.right
 ```
+
+## Explanation
+
+<YouTube id="5LUXSvjmGCw" title="Kth Smallest Element in a BST - Leetcode 230 - Python" />

apps/docs/content/(tree)/235-lowest-common-ancestor-of-a-binary-search-tree.mdx

@@ -30,6 +30,22 @@ sidebar:
 - `p != q`
 - p and q will exist in the BST.
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["lowestCommonAncestor(root, p, q)"]) --> I["cur = root"]
+  I --> W{"cur?"}
+  W -- no --> E(["fall off the loop — unreachable, p and q exist in the BST"])
+  W -- yes --> A{"p.val < cur.val and q.val < cur.val?"}
+  A -- yes --> L["cur = cur.left — both sit in the left subtree"]
+  L --> W
+  A -- no --> B{"p.val > cur.val and q.val > cur.val?"}
+  B -- yes --> R["cur = cur.right — both sit in the right subtree"]
+  R --> W
+  B -- no --> C(["return cur — the paths to p and q split here"])
+```
+
 ## Solution
 
 ```py
@@ -54,3 +70,7 @@ class Solution:
             else:
                 return cur
 ```
+
+## Explanation
+
+<YouTube id="gs2LMfuOR9k" title="Lowest Common Ancestor of a Binary Search Tree - Leetcode 235 - Python" />

apps/docs/content/(tree)/236-lowest-common-ancestor-of-a-binary-tree.mdx

@@ -30,6 +30,21 @@ sidebar:
 - `p != q`
 - p and q will exist in the tree.
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["lowestCommonAncestor(root, p, q)"]) --> B{"not root?"}
+  B -- yes --> N(["return None"])
+  B -- no --> M{"root == p or root == q?"}
+  M -- yes --> R(["return root — a node is its own ancestor"])
+  M -- no --> L["l = self.lowestCommonAncestor(root.left, p, q)"]
+  L --> Q["r = self.lowestCommonAncestor(root.right, p, q)"]
+  Q --> D{"l and r?"}
+  D -- yes --> A(["return root — p and q were found on different sides"])
+  D -- no --> E(["return l or r — pass up whichever side found something"])
+```
+
 ## Solution
 
 ```py

apps/docs/content/(tree)/98-validate-binary-search-tree.mdx

@@ -22,6 +22,23 @@ sidebar:
 - The number of nodes in the tree is in the range [1, 10^4].
 - `-2^31 <= Node.val <= 2^31 - 1`
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["isValidBST(root)"]) --> C["valid(root, float('-inf'), float('inf')) — the root may hold any value"]
+  C --> E(["return that result"])
+  subgraph valid["valid(node, low, high)"]
+    V1{"not node?"}
+    V1 -- yes --> V2(["return True"])
+    V1 -- no --> V3{"not (low < node.val < high)?"}
+    V3 -- yes --> V4(["return False — node breaks a bound set by an ancestor"])
+    V3 -- no --> V5["valid(node.left, low, node.val) and valid(node.right, node.val, high) — each child tightens one bound"]
+    V5 --> V6(["return that result"])
+  end
+  C --> V1
+```
+
 ## Solution
 
 ```py
@@ -44,3 +61,7 @@ class Solution:
 
         return valid(root, float("-inf"), float("inf"))
 ```
+
+## Explanation
+
+<YouTube id="s6ATEkipzow" title="Validate Binary Search Tree - Depth First Search - Leetcode 98" />