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

apps/docs/content/(array)/215-kth-largest-element-in-an-array.mdx

@@ -21,6 +21,20 @@ sidebar:
 - `1 <= k <= nums.length <= 10^5`
 - `-10^4 <= nums[i] <= 10^4`
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["findKthLargest(nums, k)"]) --> F{"more i in range(len(nums))?"}
+  F -- yes --> N["nums[i] = -nums[i] — negate so the min-heap acts as a max-heap"]
+  N --> F
+  F -- no --> H["heapq.heapify(nums)"]
+  H --> W{"more _ in range(k - 1)?"}
+  W -- yes --> P["heapq.heappop(nums) — discard the k-1 largest"]
+  P --> W
+  W -- no --> E(["return -heapq.heappop(nums)"])
+```
+
 ## Solution
 
 ```py
@@ -39,3 +53,7 @@ class Solution:
 
         return -heapq.heappop(nums)
 ```
+
+## Explanation
+
+<YouTube id="XEmy13g1Qxc" title="Kth Largest Element in an Array - Quick Select - Leetcode 215 - Python" />

apps/docs/content/(array)/271-encode-and-decode-strings.mdx

@@ -27,6 +27,27 @@ Could you write a generalized algorithm to work on any possible set of character
 - `0 <= strs[i].length <= 200`
 - `strs[i]` contains any possible characters out of 256 valid ASCII characters.
 
+## Approach
+
+::::warning
+The diagram traces the code below literally. That code does not solve the problem: both `encode` and `decode` have only a docstring for a body, so each returns `None` and `codec.decode(codec.encode(strs))` yields `None` instead of `strs`.
+::::
+
+```mermaid
+flowchart TD
+  subgraph state["state — Codec holds no fields"]
+    X["Codec() — nothing is stored between encode and decode"]
+  end
+  subgraph encode["encode(strs)"]
+    E1["docstring only — no statement runs"] --> E2(["return None"])
+  end
+  subgraph decode["decode(s)"]
+    D1["docstring only — no statement runs"] --> D2(["return None"])
+  end
+  state --> encode
+  state --> decode
+```
+
 ## Solution
 
 ```py
@@ -46,3 +67,7 @@ class Codec:
 # codec = Codec()
 # codec.decode(codec.encode(strs))
 ```
+
+## Explanation
+
+<YouTube id="B1k_sxOSgv8" title="Encode and Decode Strings - Leetcode 271 - Python" />

apps/docs/content/(array)/48-rotate-image.mdx

@@ -22,6 +22,22 @@ sidebar:
 - `1 <= n <= 20`
 - `-1000 <= matrix[i][j] <= 1000`
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["rotate(matrix)"]) --> N["n = len(matrix)"]
+  N --> F{"more r in range(n)?"}
+  F -- yes --> G{"more c in range(r + 1, n)?"}
+  G -- yes --> T["swap matrix[r][c] and matrix[c][r] — transpose across the diagonal"]
+  T --> G
+  G -- no --> F
+  F -- no --> H{"more r in range(n)?"}
+  H -- yes --> R["matrix[r].reverse() — transpose then mirror is a clockwise turn"]
+  R --> H
+  H -- no --> E(["return None — rotated in place"])
+```
+
 ## Solution
 
 ```py
@@ -35,3 +51,7 @@ class Solution:
         for r in range(n):
             matrix[r].reverse()
 ```
+
+## Explanation
+
+<YouTube id="fMSJSS7eO1w" title="Rotate Image - Matrix - Leetcode 48" />

apps/docs/content/(array)/54-spiral-matrix.mdx

@@ -23,6 +23,24 @@ sidebar:
 - `1 <= m, n <= 10`
 - `-100 <= matrix[i][j] <= 100`
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["spiralOrder(matrix)"]) --> I["res = [], top = 0, bottom = len(matrix) - 1, left = 0, right = len(matrix[0]) - 1"]
+  I --> W{"top <= bottom and left <= right?"}
+  W -- no --> E(["return res"])
+  W -- yes --> T["append matrix[top][c] for c in left..right, then top += 1 — top row, shrink from above"]
+  T --> R["append matrix[r][right] for r in top..bottom, then right -= 1 — right column"]
+  R --> B{"top <= bottom?"}
+  B -- yes --> C["append matrix[bottom][c] for c in right down to left, then bottom -= 1 — bottom row"]
+  C --> L{"left <= right?"}
+  B -- no --> L
+  L -- yes --> D["append matrix[r][left] for r in bottom down to top, then left += 1 — left column"]
+  D --> W
+  L -- no --> W
+```
+
 ## Solution
 
 ```py
@@ -57,3 +75,7 @@ class Solution:
 
         return res
 ```
+
+## Explanation
+
+<YouTube id="BJnMZNwUk1M" title="Spiral Matrix - Microsoft Interview Question - Leetcode 54" />

apps/docs/content/(array)/73-set-matrix-zeroes.mdx

@@ -30,6 +30,35 @@ You must do it in place.
 - A simple improvement uses O(m + n) space, but still not the best solution.
 - Could you devise a constant space solution?
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["setZeroes(matrix)"]) --> I["m = len(matrix), n = len(matrix[0])"]
+  I --> Z["row0_zero = any(matrix[0][c] == 0), col0_zero = any(matrix[r][0] == 0) — remember before they become markers"]
+  Z --> F{"more r in range(1, m)?"}
+  F -- yes --> G{"more c in range(1, n)?"}
+  G -- yes --> Q{"matrix[r][c] == 0?"}
+  Q -- yes --> M["matrix[r][0] = 0, matrix[0][c] = 0 — row 0 and column 0 are the marker lists"]
+  M --> G
+  Q -- no --> G
+  G -- no --> F
+  F -- no --> H{"more r in range(1, m)?"}
+  H -- yes --> J{"more c in range(1, n)?"}
+  J -- yes --> K{"matrix[r][0] == 0 or matrix[0][c] == 0?"}
+  K -- yes --> W["matrix[r][c] = 0"]
+  W --> J
+  K -- no --> J
+  J -- no --> H
+  H -- no --> A{"row0_zero?"}
+  A -- yes --> B["matrix[0][c] = 0 for c in range(n)"]
+  B --> C{"col0_zero?"}
+  A -- no --> C
+  C -- yes --> D["matrix[r][0] = 0 for r in range(m)"]
+  D --> E(["return None — zeroed in place"])
+  C -- no --> E
+```
+
 ## Solution
 
 ```py
@@ -65,3 +94,7 @@ class Solution:
             for r in range(m):
                 matrix[r][0] = 0
 ```
+
+## Explanation
+
+<YouTube id="T41rL0L3Pnw" title="Set Matrix Zeroes - In-place - Leetcode 73" />

apps/docs/content/(array)/973-k-closest-points-to-origin.mdx

@@ -23,6 +23,23 @@ sidebar:
 - `1 <= k <= points.length <= 10^4`
 - `-10^4 <= xi, yi <= 10^4`
 
+## Approach
+
+```mermaid
+flowchart TD
+  S(["kClosest(points, k)"]) --> I["minHeap = []"]
+  I --> F{"more x, y in points?"}
+  F -- yes --> D["dist = x**2 + y**2 — squared distance orders the same as sqrt"]
+  D --> A["minHeap.append([dist, x, y])"]
+  A --> F
+  F -- no --> H["heapq.heapify(minHeap), res = [] — O(n) build, smallest dist on top"]
+  H --> W{"k > 0?"}
+  W -- yes --> P["dist, x, y = heapq.heappop(minHeap)"]
+  P --> R["res.append([x, y]), k -= 1"]
+  R --> W
+  W -- no --> E(["return res"])
+```
+
 ## Solution
 
 ```py
@@ -46,3 +63,7 @@ class Solution:
 
         return res
 ```
+
+## Explanation
+
+<YouTube id="rI2EBUEMfTk" title="K Closest Points to Origin - Heap / Priority Queue - Leetcode 973 - Python" />