diff --git a/.gitignore b/.gitignore
index cde7748..3ed341f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -104,3 +104,4 @@ node_modules/
 package-lock.json
 
 .claude/skills
+prompt
diff --git a/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/Minimum_Depth_of_Binary_Tree_Python.md b/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/Minimum_Depth_of_Binary_Tree_Python.md
new file mode 100644
index 0000000..19796f5
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/Minimum_Depth_of_Binary_Tree_Python.md	
@@ -0,0 +1,348 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Python (CPython 3.11.10)
+> 適用ルールセット: 共通5ルール + Python固有ルール
+> 参照ファイル: references/common.md + references/python.md
+
+---
+
+# 🌳 Minimum Depth of Binary Tree — Python 完全解説
+
+---
+
+## 1. 問題分析結果
+
+> 💡 **一言で言うと**：「木の根から最も近い"末端ノード（葉）"までの、最短の道のり（ノード数）を求める問題」です。
+
+### ⚠️ Python/CPython 特有の注意点（最初に確認）
+
+BFS（幅優先探索）の実装では、Python標準リスト `list` の `pop(0)` を使いたくなりますが、**リストの先頭削除は O(n) のコスト**がかかります（全要素を1つずつ左にずらすため）。代わりに `collections.deque`（デック）の `popleft()` を使うことで O(1) に改善できます。ノード数が最大 `10^5` の場合、この差は無視できません。また、再帰（DFS）を使う場合は Python のデフォルト再帰深度制限（`sys.getrecursionlimit()` = 1000）に注意が必要です。
+
+---
+
+### 競技プログラミング視点
+
+- **制約分析**：ノード数は最大 `10^5`。O(n) のアルゴリズムで十分
+- **最速手法**：BFS で最初の葉を見つけた瞬間に即 `return`（早期終了）
+- **メモリ最小化**：`deque` を使いキューのサイズを木の幅に抑える
+- **CPython最適化**：`collections.deque` は C 実装。`popleft()` が O(1) でリストより大幅に速い
+
+### 業務開発視点
+
+- **型安全設計**：`Optional[TreeNode]` を正しく使い、pylance エラーが出ないようにする
+- **エラーハンドリング**：`root` が `None` のケース（空の木）を先に処理する
+- **可読性**：BFS の「なぜこう書くか」をコメントで明示する
+
+### Python特有分析
+
+| 観点                    | 採用           | 理由                                       |
+| ----------------------- | -------------- | ------------------------------------------ |
+| `collections.deque`     | ✅             | `popleft()` が O(1)。`list.pop(0)` は O(n) |
+| 再帰（DFS）             | 参考として提示 | 深い木で再帰制限リスクあり                 |
+| `sys.setrecursionlimit` | 競技版で考慮   | デフォルト1000を超える木に対応             |
+
+> 📖 **このセクションで登場した用語**
+>
+> - **CPython**：最も広く使われるPythonの実装。C言語で書かれており、`deque`などの組み込みデータ構造がC実装のため高速
+> - **O(n)**：ノード数が2倍になると処理も約2倍になること
+> - **GIL**：Pythonスレッドが同時に実行されないようにするロック機構。今回はシングルスレッドなので影響なし
+> - **再帰深度制限**：Pythonが再帰呼び出しを許可する最大回数。デフォルトは1000回
+
+---
+
+## 2. 採用アルゴリズムと根拠
+
+> 💡 同じ問題でも解き方は複数あります。「速さ」「メモリ」「Pythonとの相性」の3軸で比べて最適なものを選びます。
+
+| アプローチ        | 時間計算量 | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用           | CPython最適化    | 備考                     |
+| ----------------- | ---------- | ---------- | ---------------- | ------ | ---------------------------- | ---------------- | ------------------------ |
+| **BFS（deque）**  | O(n)       | O(w)※1     | 低               | ★★★    | `collections.deque`（C実装） | ◎ 適             | **採用**：早期終了で最速 |
+| DFS 再帰          | O(n)       | O(h)※2     | 最低             | ★★★    | なし                         | △ 深い木でリスク | 再帰制限に注意           |
+| DFS 反復（stack） | O(n)       | O(h)       | 低               | ★★☆    | `list`（スタック代用）       | △                | 全葉を確認が必要         |
+
+※1 `w` = 木の最大幅（完全二分木では O(n/2)）
+※2 `h` = 木の高さ（最悪 O(n)、平均 O(log n)）
+
+**選択理由**：「最短深さ」を求める問題では **BFS が自然に最適**です。BFS は浅い層から順に探索するため、最初に葉を見つけた瞬間にそれが確実に最短距離です。DFS（再帰）は全葉を確認してから比較するため、BFS の早期終了の恩恵がありません。さらに `collections.deque` は C 実装なので、Pure Python のリストより `popleft()` が大幅に高速です。
+
+> 📖 **このセクションで登場した用語**
+>
+> - **BFS（幅優先探索）**：木を「浅い順・横に広がる順」に探索する方法。キュー（FIFO）を使う
+> - **DFS（深さ優先探索）**：木を「根から葉まで一本道に深く潜る」方法。再帰またはスタックを使う
+> - **collections.deque**：前からも後ろからも O(1) で出し入れできる「両端開きの箱」。C実装のため`list`より高速
+> - **早期終了**：答えが確定した瞬間にループを抜けること。不要な処理をスキップして高速化できる
+
+---
+
+## 3. 実装パターン
+
+> 💡 **コードの大まかな骨格**
+>
+> 1. `root` が `None`（空の木）なら即 `0` を返す
+> 2. `deque` にルートノードと深さ `1` を入れてBFS開始
+> 3. キューから取り出し → 葉なら即 `return`、子があればキューに追加
+> 4. （到達しないが）全探索後のフォールバック
+
+---
+
+### 【業務開発版を使う場面】
+
+チームで長期間メンテナンスするプロダクションコードに向きます。型ヒントと `pylance` 対応、docstring、入力検証を完備しており、コードを初めて読む人でも意図が理解しやすい構造になっています。
+
+```python
+from typing import Optional
+from collections import deque
+
+
+# LeetCodeが提供するTreeNodeクラス（定義済みなので実際には不要）
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+
+
+class Solution:
+    def minDepth(self, root: Optional[TreeNode]) -> int:
+        """
+        二分木の最小深さ（根から最も近い葉までのノード数）を返す。
+
+        アルゴリズム: BFS（幅優先探索）
+        - deque を使いキューを O(1) で操作する
+        - 最初に葉を見つけた時点で即 return（早期終了）
+
+        Args:
+            root: 二分木の根ノード。None の場合は空の木を意味する
+
+        Returns:
+            最小深さ（整数）。空の木の場合は 0。
+
+        Raises:
+            特に例外は発生しない（None は正常入力として処理する）
+
+        Time Complexity:  O(n) — 最悪ケースで全ノードを1回ずつ処理
+        Space Complexity: O(w) — w は木の最大幅（キューに同時に入る最大ノード数）
+        """
+
+        # ────────────────────────────────────────
+        # エッジケース: 空の木（root が None）
+        # 根がなければ「葉までの道」自体が存在しないため 0 を返す
+        # ────────────────────────────────────────
+        if root is None:
+            return 0
+
+        # ────────────────────────────────────────
+        # BFS 用キューを初期化する
+        # deque を使う理由：
+        #   list の popleft() は O(n)（全要素を左にずらすコストが発生する）
+        #   deque の popleft() は O(1)（ポインタを動かすだけで完結する）
+        # タプル (ノード, 現在の深さ) でペアを管理し、深さを外部変数で持たずに済ませる
+        # ────────────────────────────────────────
+        queue: deque[tuple[TreeNode, int]] = deque()
+        queue.append((root, 1))  # 根ノードは深さ1からスタート
+
+        # ────────────────────────────────────────
+        # キューが空になるまでBFSを続ける
+        # ────────────────────────────────────────
+        while queue:
+
+            # キューの先頭からノードと深さを取り出す
+            # popleft() で FIFO（先入れ先出し）を実現 → 浅い順に処理される
+            node, depth = queue.popleft()
+
+            # ────────────────────────────────────
+            # 葉ノード判定: 左も右も子がない = 葉
+            # BFS は浅い順に処理するため、最初に見つかった葉が
+            # 必ず最小深さを持つ → 即 return できる
+            # ────────────────────────────────────
+            if node.left is None and node.right is None:
+                return depth  # 🎯 最小深さ確定
+
+            # 左の子が存在する場合のみキューに追加
+            # None の子を追加すると後で NullPointerError 相当のバグになるため
+            # ここで必ずチェックする
+            if node.left is not None:
+                queue.append((node.left, depth + 1))
+
+            # 右の子が存在する場合のみキューに追加（左と同様の理由）
+            if node.right is not None:
+                queue.append((node.right, depth + 1))
+
+        # ────────────────────────────────────────
+        # ここには通常到達しない
+        # root が None でない有効な木なら必ず葉が存在するため
+        # pylance に「int を返す」ことを保証するためのフォールバック
+        # ────────────────────────────────────────
+        return 0
+```
+
+---
+
+### 動作トレース（業務開発版）
+
+#### Example 1: `root = [3,9,20,null,null,15,7]`
+
+```
+         3
+        / \
+       9   20
+          /  \
+         15    7
+
+初期状態:
+  queue = deque([ (Node(3), 1) ])
+
+─── ループ1回目 ───
+  popleft() → (Node(3), depth=1)
+  Node(3).left  = Node(9)  → null でない
+  Node(3).right = Node(20) → null でない
+  → 葉でない（両方に子がいる）
+  queue に追加: (Node(9), 2), (Node(20), 2)
+  queue = deque([ (Node(9),2), (Node(20),2) ])
+
+─── ループ2回目 ───
+  popleft() → (Node(9), depth=2)
+  Node(9).left  = None
+  Node(9).right = None
+  → 🎯 両方 None = 葉ノード！ return 2
+
+Answer: 2 ✅
+```
+
+#### Example 2: `root = [2,null,3,null,4,null,5,null,6]`（⚠️ 罠あり）
+
+```
+  2
+   \
+    3
+     \
+      4
+       \
+        5
+         \
+          6  ← 唯一の葉
+
+─── ループ1回目 ───
+  popleft() → (Node(2), depth=1)
+  Node(2).left  = None  ← None だが...
+  Node(2).right = Node(3)  ← 右の子がある！
+  → ⚠️ 罠：left が None でも right がいるので葉ではない
+  → left は追加しない、right だけ追加
+  queue = deque([ (Node(3), 2) ])
+
+─── ループ2〜5回目（同様に繰り返し）───
+  Node(3) → right=Node(4) → 葉でない、深さ3追加
+  Node(4) → right=Node(5) → 葉でない、深さ4追加
+  Node(5) → right=Node(6) → 葉でない、深さ5追加
+
+─── ループ6回目 ───
+  popleft() → (Node(6), depth=5)
+  Node(6).left  = None
+  Node(6).right = None
+  → 🎯 葉ノード発見！ return 5
+
+Answer: 5 ✅
+```
+
+---
+
+### 【競技プログラミング版を使う場面】
+
+LeetCode・AtCoder など制限時間内に正解を出すことが目的のコードに向きます。型ヒントや docstring は最小限にし、コードの短さと実行速度を優先した書き方になっています。
+
+```python
+from typing import Optional
+from collections import deque
+
+
+class Solution:
+    def minDepth(self, root: Optional[TreeNode]) -> int:
+        # 空の木は深さ0
+        if not root:
+            return 0
+
+        # deque でキューを初期化（popleft が O(1) のため list より高速）
+        q: deque[tuple[TreeNode, int]] = deque([(root, 1)])
+
+        while q:
+            node, d = q.popleft()
+
+            # 葉ノード発見 → 即 return（BFS なのでこれが最小深さ）
+            if not node.left and not node.right:
+                return d
+
+            # 子を追加（None は追加しない）
+            if node.left:
+                q.append((node.left, d + 1))
+            if node.right:
+                q.append((node.right, d + 1))
+
+        return 0  # pylance 用フォールバック（実際には到達しない）
+```
+
+---
+
+### 参考：DFS 再帰版（可読性最高・競技向け）
+
+> **DFS 再帰版を使う際の注意**：Python のデフォルト再帰深度は `1000` です。直線状の木（例2のような木）でノード数が 1000 を超えると `RecursionError` が発生します。LeetCode では制約上ノード数が最大 `10^5` なので、**競技版でもBFS推奨**です。参考として示します。
+
+```python
+from typing import Optional
+
+
+class Solution:
+    def minDepth(self, root: Optional[TreeNode]) -> int:
+        # ベースケース: 木が空なら深さ0
+        if root is None:
+            return 0
+
+        # ────────────────────────────────────────
+        # 重要な罠：片方が None のノードは葉ではない
+        # 左が None → 左方向に葉はない → 右だけ再帰する
+        # ────────────────────────────────────────
+        if root.left is None:
+            # 左の子がないので右方向のみ探索し、自分自身の分(+1)を足す
+            return 1 + self.minDepth(root.right)
+
+        if root.right is None:
+            # 右の子がないので左方向のみ探索し、自分自身の分(+1)を足す
+            return 1 + self.minDepth(root.left)
+
+        # 両方の子が存在する場合: 両方探索して小さい方 + 自分自身の1
+        return 1 + min(self.minDepth(root.left), self.minDepth(root.right))
+```
+
+---
+
+## 4. 検証
+
+> 💡 エッジケースのテストは、アルゴリズムが「ふつうの入力」だけでなく「極端な入力」でも正しく動くかを確かめるためのものです。
+
+| ケース              | 入力                      | 期待値 | 理由                    |
+| ------------------- | ------------------------- | ------ | ----------------------- |
+| 空の木              | `root = None`             | `0`    | 根がなければ葉もない    |
+| 根のみ（ノード1つ） | `root = [1]`              | `1`    | 根自体が葉              |
+| 左偏り木            | `[1, 2, null, 3]`         | `3`    | 右がないので左のみ      |
+| 右偏り木（直線）    | `[2,null,3,null,4]`       | `3`    | 全ノードが一直線        |
+| 完全二分木          | `[3,9,20,null,null,15,7]` | `2`    | 深さ2の葉が最短         |
+| 最大制約            | ノード数 `10^5`           | —      | TLE・MLE が起きないこと |
+
+> 📖 **このセクションで登場した用語**
+>
+> - **エッジケース**：空のツリー・ノード1つ・直線状の木など、境界的な条件のこと
+> - **RecursionError**：再帰の呼び出し回数が `sys.getrecursionlimit()`（デフォルト1000）を超えたときに発生するエラー
+> - **TLE（Time Limit Exceeded）**：制限時間超過。計算量が大きすぎると発生する
+> - **MLE（Memory Limit Exceeded）**：メモリ制限超過。大きなデータ構造を持ちすぎると発生する
+> - **フォールバック**：「本来は到達しないが念のため書いておく処理」。pylance の型チェックを通すためにも必要
+
+---
+
+## まとめ
+
+| 観点                  | 内容                                                                     |
+| --------------------- | ------------------------------------------------------------------------ |
+| **問題の本質**        | 根から最も近い葉までの最短ノード数                                       |
+| **最大の罠**          | 片方の子が `None` のノードは「葉」ではない                               |
+| **採用手法**          | BFS（`collections.deque` で O(1) popleft）                               |
+| **時間計算量**        | O(n)：最悪ケースで全ノード探索                                           |
+| **空間計算量**        | O(w)：キューの最大サイズは木の最大幅                                     |
+| **Python のポイント** | `list.pop(0)` ではなく `deque.popleft()` を使うことで O(n) → O(1) に改善 |
diff --git a/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/Minimum_Depth_of_Binary_Tree_Typescript.md b/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/Minimum_Depth_of_Binary_Tree_Typescript.md
new file mode 100644
index 0000000..309204b
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/Minimum_Depth_of_Binary_Tree_Typescript.md	
@@ -0,0 +1,387 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: TypeScript
+> 適用ルールセット: 共通5ルール + TS固有5ルール
+> 参照ファイル: references/common.md + references/typescript.md
+
+---
+
+# 🌳 Minimum Depth of Binary Tree — 完全解説
+
+---
+
+## 1. 問題の分析
+
+> 💡 **この問題を一言で言うと**：「木の根（root）から葉（leaf）までの最短の道のりを求める問題」です。ただし **重大な罠** があります。
+
+---
+
+### ⚠️ 初学者が必ずハマる罠：「葉ノード」の定義
+
+「最短距離だから `Math.min(左の深さ, 右の深さ)` でよいのでは？」と思うかもしれません。ところが**それは間違いです**。
+
+**葉ノード（leaf node）とは「左も右も子どもを持たないノード」**のことです。片方だけ子がある場合は、葉ではありません。
+
+```
+Example 2: root = [2,null,3,null,4,null,5,null,6]
+
+      2
+       \
+        3
+         \
+          4
+           \
+            5
+             \
+              6  ← ここが唯一の葉ノード
+```
+
+もし単純に `Math.min(左=0, 右=5)` = `0` を返してしまうと、**左の子がいない（depth=0）が「葉」と誤解されて答えが間違います**。左の子が `null` のときは、その方向は無効として無視し、右方向だけを辿らなければなりません。
+
+---
+
+### 競技プログラミング視点での分析
+
+- **BFS（幅優先探索）** が最適。根から層（レベル）ごとに探索し、**最初に葉に当たった瞬間に即終了**できるため、最短ケースで非常に高速
+- 深く偏った木（例2のような直線状）でも、DFSは全ノード走破が必要だが、BFSも最悪ケースでは同様になる
+- ノード数の上限が `10^5` なので、O(n) であれば十分
+
+### 業務開発視点での分析
+
+- 型安全性：`TreeNode | null` の Union型（2つの可能性を `|` で表す型）を正しく扱うことが重要
+- 再帰的DFSは実装が直感的で保守しやすいが、深い木でスタックオーバーフロー（＝呼び出し回数が深くなりすぎてメモリが溢れること）のリスクがある
+- BFSはキュー（待ち行列）を使うため、メモリ消費が明示的で制御しやすい
+
+### TypeScript特有の考慮点
+
+- `TreeNode | null` という **Union型**で null安全性（`null`によるクラッシュを防ぐ仕組み）を表現できる
+- `!` 非null アサーション（`queue.shift()!` のように、絶対にnullでないとコンパイラに伝える記号）はなるべく避け、明示的チェックを優先する
+
+> 📖 **このセクションで登場した用語**
+>
+> - **葉ノード（leaf node）**：左も右も子どもがないノード。木の末端
+> - **BFS（Breadth-First Search / 幅優先探索）**：木や図（グラフ）を「深さの浅い順」に探索する方法。階層ごとに横に広がりながら探す
+> - **DFS（Depth-First Search / 深さ優先探索）**：木を「根から葉まで一本道を掘り進んで」探索する方法。再帰で実装されることが多い
+> - **Union型**：`A | B` のように複数の型のどちらかである可能性を表すTypeScript固有の型表記
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+> 💡 同じ問題でも解き方は複数あります。「速さ（時間計算量）」「メモリ（空間計算量）」「TypeScriptとの相性」の観点で比べて最適なものを選びます。
+
+| アプローチ                  | 時間計算量         | 空間計算量 | TS実装コスト | 型安全性 | 可読性 | 備考                         |
+| --------------------------- | ------------------ | ---------- | ------------ | -------- | ------ | ---------------------------- |
+| **BFS（幅優先探索）**       | O(n) ※早期終了あり | O(w)※1     | 中           | 高       | 高     | 最初の葉で即終了できる最速解 |
+| DFS 再帰（Recursive）       | O(n)               | O(h)※2     | 低           | 高       | 最高   | 偏った木でスタック溢れリスク |
+| DFS 反復（Iterative Stack） | O(n)               | O(n)       | 中           | 高       | 中     | スタック溢れを回避できる     |
+
+※1 `w` = 木の最大幅（1レベルに存在する最大ノード数）。完全二分木では O(n/2)
+※2 `h` = 木の高さ（根から最も深い葉まで）。最悪 O(n)、平均 O(log n)
+
+> 💡 **Big-O記法の読み方**（初学者向け）
+>
+> - `O(1)`：入力の大きさに関わらず、常に一定の時間・メモリで済む
+> - `O(n)`：ノード数が2倍になると、処理も約2倍になる
+> - `O(h)`：木の高さに比例。バランスの取れた木なら `O(log n)` と同等
+
+> 📖 **このセクションで登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **スタックオーバーフロー**：再帰の呼び出しが深くなりすぎてメモリが溢れるエラー
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**: **BFS（幅優先探索）**
+
+- **理由**:
+    - 「最短」を求める問題では、「浅いレベルから順に探す BFS」が自然に一致する。DFSは全ての葉を確認してから比較するのに対し、**BFSは最初の葉を見つけた瞬間に確実に最小深さと言える**
+    - 例2のような直線状の木でも DFS（再帰）は O(n) のスタックを消費するが、BFS はキューで管理するためスタックオーバーフローが起きない
+    - TypeScript では配列をキューとして使う実装がシンプルで型安全に書きやすい
+
+- **TypeScript特有の最適化ポイント**:
+    - タプル型（＝複数の異なる型の値を一組にまとめた配列の型）`[TreeNode, number]` でノードと深さをペアとして管理し、型安全にキューを表現
+    - `null` チェックを TypeScript の型システムが強制するため、葉判定の漏れをコンパイル時に防げる
+
+> 📖 **このセクションで登場した用語**
+>
+> - **キュー（Queue）**：「先に入れたものを先に取り出す」データ構造。「ファストフードの行列」と同じイメージ
+> - **タプル型**：`[string, number]` のように、要素の数と各要素の型が固定された配列の型
+> - **コンパイル時**：TypeScriptコードをJavaScriptに変換する段階。ここでエラーを検出できると実行時バグを防げる
+
+---
+
+## 4. 実装コード
+
+> 💡 **コード全体の骨格**（先に構造を把握してからコードを読みましょう）
+>
+> 1. **根が null なら 0 を返す**（空の木の特別ケース）
+> 2. **BFS 用のキューに根ノードと深さ1を入れて開始**
+> 3. **キューから取り出し → 葉なら即 return、子があればキューに追加**
+> 4. **（念のため）全ノード探索しても葉がなければ 0 を返す**
+
+### 🏆 最終解答（LeetCode 提出フォーマット）
+
+```typescript
+// Runtime 1 ms
+// Beats 84.75%
+// Memory 94.50 MB
+// Beats 56.90%
+
+function minDepth(root: TreeNode | null): number {
+    // ────────────────────────────────────────────────
+    // ▼ ケース1：木が空（根がnull）なら深さは0
+    //   nullチェックをここで行うことで、後続の処理で
+    //   「rootが絶対に存在する」と安全に仮定できる
+    // ────────────────────────────────────────────────
+    if (root === null) return 0;
+
+    // ────────────────────────────────────────────────
+    // ▼ BFS用のキューを初期化する
+    //   タプル型 [TreeNode, number] = [ノード, 現在の深さ]
+    //   最初は根ノードを深さ1として投入する
+    //   （なぜ1か：根ノード自体が1番目のノードだから）
+    // ────────────────────────────────────────────────
+    const queue: Array<[TreeNode, number]> = [[root, 1]];
+
+    // ────────────────────────────────────────────────
+    // ▼ キューが空になるまでループ（= 全ノードを探索）
+    //   葉が見つかった瞬間に return するので
+    //   通常はキューが空になる前に終了する
+    // ────────────────────────────────────────────────
+    while (queue.length > 0) {
+        // キューの先頭からノードと深さを取り出す
+        // shift() は配列の先頭要素を取り出す操作（BFSの本質）
+        // 「! 」は「shift()の結果がundefinedでない」とコンパイラに保証するための記号
+        // ※ while条件 queue.length > 0 で空でないことを確認済みなので安全
+        const [node, depth] = queue.shift()!;
+
+        // ────────────────────────────────────────────
+        // ▼ 葉ノードの判定：左も右も子がない = 葉
+        //   BFSは浅い順に探索するため、最初に見つかった
+        //   葉が必ず最小深さを持つ → 即座にreturnできる
+        // ────────────────────────────────────────────
+        if (node.left === null && node.right === null) {
+            return depth; // 🎯 最短深さが確定！
+        }
+
+        // ────────────────────────────────────────────
+        // ▼ 左の子がある場合：キューに追加（深さを+1）
+        //   null チェックを先に行うことで、
+        //   存在しない子を追加する無駄を防ぐ
+        // ────────────────────────────────────────────
+        if (node.left !== null) {
+            queue.push([node.left, depth + 1]);
+        }
+
+        // ────────────────────────────────────────────
+        // ▼ 右の子がある場合：同様にキューに追加
+        // ────────────────────────────────────────────
+        if (node.right !== null) {
+            queue.push([node.right, depth + 1]);
+        }
+    }
+
+    // ────────────────────────────────────────────────
+    // ▼ ここには通常到達しない（根がnullでない有効な木なら
+    //   必ずどこかに葉が存在するため）
+    //   TypeScriptのコンパイラを満足させるため（関数が
+    //   必ず値を返すことを保証するため）に記述する
+    // ────────────────────────────────────────────────
+    return 0;
+}
+```
+
+---
+
+### 🔍 動作トレース：2つの例で変数がどう変わるか
+
+#### Example 1：`root = [3,9,20,null,null,15,7]`
+
+```
+        3          ← 深さ 1
+       / \
+      9   20       ← 深さ 2
+         /  \
+        15    7    ← 深さ 3
+```
+
+```
+初期状態:
+  queue = [ [Node(3), 1] ]
+
+─── ループ1回目 ───
+  取り出し: [Node(3), depth=1]
+  Node(3).left  = Node(9)   → null ではない
+  Node(3).right = Node(20)  → null ではない
+  → 葉ではない
+  queue に追加: [Node(9), 2], [Node(20), 2]
+  queue = [ [Node(9), 2], [Node(20), 2] ]
+
+─── ループ2回目 ───
+  取り出し: [Node(9), depth=2]
+  Node(9).left  = null
+  Node(9).right = null
+  → 🎯 両方 null = 葉ノード発見！
+  return 2  ← 答え確定！残りのキューは処理不要
+```
+
+#### Example 2：`root = [2,null,3,null,4,null,5,null,6]`（直線状の木）
+
+```
+  2            ← 深さ 1
+   \
+    3          ← 深さ 2
+     \
+      4        ← 深さ 3
+       \
+        5      ← 深さ 4
+         \
+          6    ← 深さ 5（唯一の葉）
+```
+
+```
+初期: queue = [ [Node(2), 1] ]
+
+ループ1: Node(2) → left=null, right=Node(3)
+  → 葉でない（leftがnullでもrightがあるため！）
+  → 罠：leftがnullだからといって葉と判断してはいけない
+  queue = [ [Node(3), 2] ]
+
+ループ2: Node(3) → left=null, right=Node(4)
+  → 葉でない、queue = [ [Node(4), 3] ]
+
+ループ3: Node(4) → left=null, right=Node(5)
+  → 葉でない、queue = [ [Node(5), 4] ]
+
+ループ4: Node(5) → left=null, right=Node(6)
+  → 葉でない、queue = [ [Node(6), 5] ]
+
+ループ5: Node(6) → left=null, right=null
+  → 🎯 葉ノード発見！ return 5
+```
+
+---
+
+### ✨ 参考：DFS 再帰版（可読性重視・業務開発向け）
+
+こちらも紹介します。コードが非常に短く直感的ですが、**深い木でスタックオーバーフローのリスク**があります。
+
+> このコードの構造：
+>
+> 1. `null` なら 0 を返す（ベースケース）
+> 2. 左だけある → 左に進む（右方向を無視する）
+> 3. 右だけある → 右に進む（左方向を無視する）
+> 4. 両方ある → 両方探索し `Math.min` で小さい方を返す
+
+```typescript
+function minDepth(root: TreeNode | null): number {
+    // ベースケース（＝再帰の終了条件）：
+    // 根が null なら深さ0。このチェックがないと
+    // null.left にアクセスしてクラッシュする
+    if (root === null) return 0;
+
+    // ────────────────────────────────────────────────
+    // ▼ 重要：片方の子だけが null の場合の処理
+    //   左が null → 左方向には葉がない → 右方向のみ探索
+    //   「null の方向の深さ = 0」を最小値に使ってしまうと
+    //   誤って0+1=1が最小値になるバグになる！
+    // ────────────────────────────────────────────────
+    if (root.left === null) {
+        // 左の子が存在しない場合：右方向の最小深さ + 自分自身の1
+        return 1 + minDepth(root.right);
+    }
+    if (root.right === null) {
+        // 右の子が存在しない場合：左方向の最小深さ + 自分自身の1
+        return 1 + minDepth(root.left);
+    }
+
+    // 両方の子が存在する場合：
+    // 左右それぞれの最小深さを求め、小さい方 + 自分自身の1
+    return 1 + Math.min(minDepth(root.left), minDepth(root.right));
+}
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`Array.shift()`**：配列の先頭要素を取り出してその値を返す操作。BFSで「最初に追加したものを最初に処理する」ために使う
+> - **タプル型**：`[TreeNode, number]` のように要素数と各型が固定された配列の型（JavaScriptには存在せず、TypeScript固有の仕組み）
+> - **ベースケース**：再帰関数の「これ以上深く潜らなくてよい」終了条件
+> - **`readonly`修飾子**：変数を変更できないようにする TypeScript 固有の機能。JavaScriptには相当する構文がなく、意図せぬ書き換えをコンパイル時に防ぐ
+
+---
+
+## 5. ビジュアル解説（BFS の動き）---
+
+## 6. TypeScript 固有の最適化観点
+
+### 型安全性の活用
+
+**Union型（共用体型）**による null 安全性の確保：
+
+```typescript
+// JavaScriptにはない概念：型レベルでnullの可能性を明示できる
+// TreeNode | null → 「TreeNodeかnullのどちらかである」と型で表明
+// コンパイラが null チェックを強制してくれる
+
+// 🔴 JavaScriptなら実行時まで気付かない（クラッシュする）
+const left = root.left.val; // root.left が null なら TypeError!
+
+// ✅ TypeScriptなら null チェックを忘れるとコンパイルエラーになる
+if (node.left !== null) {
+    queue.push([node.left, depth + 1]); // ここでは left が TreeNode と確定
+}
+```
+
+**タプル型**でキューの要素を厳密に型定義：
+
+```typescript
+// JavaScriptにはない構文：要素数と各型が固定された配列の型
+// [TreeNode, number] → 「1番目はTreeNode、2番目はnumber」と保証
+// [Node(3), 1] のように使うことで、ノードと深さが常にペアになる
+
+// 「as const」を使うとさらに型を絞り込める（const assertionと呼ぶ）
+// ※ this problem doesn't need it, but good to know
+
+const queue: Array<[TreeNode, number]> = [[root, 1]];
+//                   ↑           ↑
+//              ノード型      深さ（数値型）
+// この型定義により、誤って [1, root] の順で入れるとコンパイルエラーになる
+```
+
+### readonly と Pure function（純粋関数）
+
+BFS 解法はすでに Pure function の性質を持っています：
+
+```typescript
+// ✅ 入力の root を変更していない（読むだけ）
+// ✅ 外部の変数（グローバル状態）に依存していない
+// ✅ 同じ root を入れれば必ず同じ深さが返ってくる
+
+function minDepth(root: TreeNode | null): number {
+    // root を変更する操作（例：root.val = 999）は一切行っていない
+    // → 副作用がない = Pure function
+}
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **Union型（共用体型）**：`A | B` のように複数の型のどちらかを表す TypeScript 固有の型表記。`TreeNode | null` は「TreeNodeかnullのどちらか」
+> - **タプル型**：`[string, number]` のように要素数と各要素の型が固定された配列の型。インデックスで `[0]` がstring、`[1]` がnumberと保証される
+> - **Pure function（純粋関数）**：同じ入力を与えると必ず同じ出力を返し、外部の状態を変えない関数。テストしやすく、バグが少ない
+> - **const assertion**：`as const` と書くことで、変数の型をリテラル型（具体的な値そのもの）に絞り込む TypeScript 固有の機能
+
+---
+
+## まとめ
+
+| 観点               | 内容                                                                 |
+| ------------------ | -------------------------------------------------------------------- |
+| **問題の本質**     | 根から最も近い葉まての最短距離                                       |
+| **最大の罠**       | 片方の子が `null` のノードは「葉」ではない                           |
+| **選択解法**       | BFS（最初の葉 = 確実に最浅）                                         |
+| **時間計算量**     | O(n) — 最悪ケースで全ノード探索                                      |
+| **空間計算量**     | O(w) — キューの最大サイズは木の最大幅                                |
+| **TypeScript貢献** | `TreeNode \| null` による null 安全 + タプル型でキューを型安全に管理 |
diff --git a/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README.md b/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README.md
new file mode 100644
index 0000000..080ecab
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README.md	
@@ -0,0 +1,862 @@
+# Minimum Depth of Binary Tree — 根から最短で葉に到達する深さを求める
+
+> **LeetCode #111** · 難易度: Easy · カテゴリ: Tree / BFS
+
+---
+
+## 目次
+
+- [概要](#overview)
+- [アルゴリズム要点（TL;DR）](#tldr)
+- [図解](#figures)
+- [正しさのスケッチ](#correctness)
+- [計算量](#complexity)
+- [Python 実装](#impl)
+- [CPython 最適化ポイント](#cpython)
+- [エッジケースと検証観点](#edgecases)
+- [FAQ](#faq)
+
+---
+
+<h2 id="overview">3. 概要</h2>
+
+> 💡 **一言で言うと**：「木の根（root）から、最も近い"末端ノード（葉）"までのノード数を数える問題」です。
+
+### 問題の内容
+
+二分木（＝各ノードが最大2つの子を持つ木）が与えられます。
+根ノード（ツリーの頂点）から葉ノード（左右ともに子がない末端のノード）まで、
+最も短いパスをたどったときの**ノードの個数**を返してください。
+
+### なぜこの問題が難しいのか
+
+一見「左右の深さを再帰で計算して `min()` で小さい方を返せばよい」と思えます。
+ところが **大きな罠** があります。それは「片方の子が `None`（存在しない）のノードは葉ではない」という点です。
+
+たとえば下の木を考えてみましょう。
+
+```
+  2
+   \
+    3
+     \
+      4
+       \
+        5
+         \
+          6  ← 唯一の葉
+```
+
+ノード `2` は左の子が `None` ですが、右の子 `3` があります。
+単純に `min(左の深さ=0, 右の深さ=4)` を計算してしまうと `0 + 1 = 1` という誤答になります。
+正しい答えは `5`（根から葉 `6` までの 5 ノード）です。
+**「片方が `None` のときは、その方向を無視して有効な方向だけを探索する」という特別な処理が必要です。**
+
+### 制約
+
+| 項目       | 値                        |
+| ---------- | ------------------------- |
+| ノード数   | 0 以上 10^5 以下          |
+| ノードの値 | -1000 以上 1000 以下      |
+| 空の木     | ありえる（`root = None`） |
+
+> 📖 **この章で登場した用語**
+>
+> - **二分木**：各ノードが最大 2 つの子（左・右）を持つ木構造のデータ
+> - **根ノード（root）**：木の頂点にある1つのノード。入口となる
+> - **葉ノード（leaf）**：左の子も右の子も持たないノード。木の末端
+> - **パス**：木の上を根から葉まで辿る経路。親から子へ一方向にしか進めない
+> - **制約**：入力として与えられる値の範囲や条件のこと
+
+---
+
+<h2 id="tldr">4. アルゴリズム要点（TL;DR）</h2>
+
+> 💡 **TL;DR（Too Long; Didn't Read）**とは「長くて全部読めない人向けの短い要約」を意味します。
+> ここではアルゴリズム全体の戦略を箇条書きでまとめます。
+> 「なんとなくこういう手順で解くんだな」というイメージを掴む章として位置づけています。
+
+### 戦略：BFS（幅優先探索）で根から層ごとに探す
+
+1. **BFS を選ぶ理由**：「最短」を求める問題には BFS が自然に合致する。
+   BFS は浅い層から順に探索するため、**最初に葉を見つけた瞬間**、それが確実に最小深さです。
+   DFS（深さ優先探索）のように全葉を比較する必要がなく、早期終了できます。
+
+2. **データ構造：`collections.deque`（デック）を使う**
+   キュー（＝先に入れたものを先に取り出す「行列」のようなデータ構造）として `deque` を使います。
+   `list` の先頭削除（`pop(0)`）は O(n) のコストがかかりますが、`deque.popleft()` は O(1) です。
+
+3. **ノードと深さをセットで管理**
+   キューの各要素を `(ノード, 現在の深さ)` のタプルで持ちます。
+   外部のカウンタ変数を使わないので、コードがシンプルになります。
+
+4. **葉ノードの判定を正しく行う**
+   `node.left is None and node.right is None` の場合だけが葉です。
+   片方が `None` でも、もう片方に子がいれば葉ではありません。
+
+5. **計算量のまとめ**
+    - 時間計算量：O(n) — 最悪ケースで全ノードを 1 回ずつ処理する
+    - 空間計算量：O(w) — w は木の最大幅（キューに同時に入る最大ノード数）
+
+> 📖 **この章で登場した用語**
+>
+> - **BFS（幅優先探索）**：木を「浅い層から順に横に広がりながら」探索する方法。キューを使う
+> - **DFS（深さ優先探索）**：木を「根から葉まで深く一本道を掘り進んで」探索する方法。再帰やスタックを使う
+> - **deque（デック）**：前からも後ろからも O(1) で出し入れできる「両端開きの箱」のようなデータ構造
+> - **タプル**：複数の値を一組にまとめた変更不可のデータ。`(node, 1)` のように書く
+> - **早期終了**：答えが確定した瞬間にループを抜けること。無駄な処理をスキップして高速化できる
+
+---
+
+<h2 id="figures">5. 図解</h2>
+
+> 💡 **Mermaid フローチャートの読み方**
+>
+> - **長方形（`[]`）**：何かの処理を行うステップです
+> - **ひし形（`{}`）**：条件を判定する分岐点です。「Yes/No」「True/False」で次の矢印が変わります
+> - **矢印（`-->`）**：処理の流れを示します。ラベルが付いているときはその条件のときに進みます
+
+### フローチャート
+
+この図は `minDepth` 関数全体の処理の流れを表しています。上から下へ読み進めてください。
+特に `LeafTest`（葉判定）の部分が、この問題の核心です。
+
+```mermaid
+flowchart TD
+    Start[Start minDepth] --> NullCheck{root is None}
+    NullCheck -- Yes --> R0[Return 0]
+    NullCheck -- No --> Init[Init deque with root at depth 1]
+    Init --> Loop{queue not empty}
+    Loop -- No --> Fallback[Return 0 fallback]
+    Loop -- Yes --> Pop[popleft node and depth]
+    Pop --> LeafTest{left is None AND right is None}
+    LeafTest -- Yes --> Ret[Return depth]
+    LeafTest -- No --> LeftEx{left exists}
+    LeftEx -- Yes --> PushL[Append left child at depth plus 1]
+    LeftEx -- No --> RightEx{right exists}
+    PushL --> RightEx
+    RightEx -- Yes --> PushR[Append right child at depth plus 1]
+    RightEx -- No --> Loop
+    PushR --> Loop
+```
+
+**主要なノードの意味：**
+
+- `Start[Start minDepth]`：関数の入口。`root` を受け取る
+- `NullCheck{root is None}`：空の木かどうかを最初に確認する分岐（エッジケース処理）
+- `Init[Init deque...]`：BFS 用キューに根ノードと深さ 1 を入れて探索を開始する
+- `Loop{queue not empty}`：キューにノードが残っている間ループを続ける分岐
+- `Pop[popleft node and depth]`：キューの先頭からノードと深さを取り出す（BFS の核心）
+- `LeafTest{left is None AND right is None}`：葉ノードかどうかを判定する分岐（この問題の罠がここ）
+- `Ret[Return depth]`：葉が見つかったので最小深さを返す（早期終了）
+- `PushL / PushR`：子ノードが存在する場合だけキューに追加する
+
+---
+
+### データフロー図
+
+この図は「入力の木構造がどのようにキューを通って最終的な深さの数値に変換されるか」のデータの流れを表しています。
+
+```mermaid
+graph LR
+    subgraph Input
+        A[TreeNode root]
+    end
+    subgraph BFS_Queue
+        B[deque init]
+        C[popleft node depth]
+        D[is leaf check]
+        E[push children]
+    end
+    subgraph Output
+        F[min depth int]
+    end
+    A --> B
+    B --> C
+    C --> D
+    D -- leaf found --> F
+    D -- not leaf --> E
+    E --> C
+```
+
+**主要な流れの説明：**
+
+- `A → B`：根ノードをキューに投入し BFS を開始する
+- `B → C`：キューから先頭要素を取り出す（popleft）
+- `C → D`：取り出したノードが葉かどうかを判定する
+- `D -- leaf found → F`：葉なら即座に深さを返す（早期終了）
+- `D -- not leaf → E`：葉でなければ子をキューに追加して探索を継続する
+- `E → C`：ループ（次のノードを取り出す）
+
+---
+
+### 代表例でのトレース
+
+#### Example 1：`root = [3, 9, 20, null, null, 15, 7]` → 期待値: `2`
+
+```
+木の形状:
+        3        ← 深さ 1
+       / \
+      9   20     ← 深さ 2
+         /  \
+        15    7  ← 深さ 3
+
+Step 0: キュー初期化
+  queue = deque([ (Node(val=3), depth=1) ])
+
+Step 1: popleft → (Node(3), depth=1)
+  Node(3).left  = Node(9)   → None ではない
+  Node(3).right = Node(20)  → None ではない
+  → LeafTest: False（両方に子がいる）
+  → PushL: queue に (Node(9),  depth=2) を追加
+  → PushR: queue に (Node(20), depth=2) を追加
+  queue = deque([ (Node(9),2), (Node(20),2) ])
+
+Step 2: popleft → (Node(9), depth=2)
+  Node(9).left  = None  ← None
+  Node(9).right = None  ← None
+  → LeafTest: True！（両方 None = 葉ノード）
+  → Return 2  ← 🎯 最小深さ確定！残りのキューは処理不要
+
+Answer: 2 ✅
+```
+
+#### Example 2：`root = [2, null, 3, null, 4, null, 5, null, 6]` → 期待値: `5`
+
+```
+木の形状:
+  2            ← 深さ 1（左の子が null）
+   \
+    3          ← 深さ 2
+     \
+      4        ← 深さ 3
+       \
+        5      ← 深さ 4
+         \
+          6    ← 深さ 5（唯一の葉）
+
+Step 0: キュー初期化
+  queue = deque([ (Node(2), depth=1) ])
+
+Step 1: popleft → (Node(2), depth=1)
+  Node(2).left  = None     ← None
+  Node(2).right = Node(3)  ← None ではない！
+  → LeafTest: False（right に子がいる → 葉ではない）
+  ⚠️ 罠: left が None でも right があれば葉でないことに注意
+  → PushL: スキップ（left は None なので追加しない）
+  → PushR: queue に (Node(3), depth=2) を追加
+  queue = deque([ (Node(3),2) ])
+
+Step 2〜5: 同様に Node(3)→Node(4)→Node(5) を処理
+  各ノードの right のみキューに追加
+  queue の状態:
+    Step 2後: deque([ (Node(4),3) ])
+    Step 3後: deque([ (Node(5),4) ])
+    Step 4後: deque([ (Node(6),5) ])
+
+Step 5: popleft → (Node(6), depth=5)
+  Node(6).left  = None  ← None
+  Node(6).right = None  ← None
+  → LeafTest: True！（両方 None = 葉ノード）
+  → Return 5  ← 🎯 最小深さ確定！
+
+Answer: 5 ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **フローチャート**：処理の手順を図形と矢印で表したもの。ひし形=条件分岐、長方形=処理ステップ
+> - **データフロー図**：データがどのように変換・移動するかを示す図。処理の手順ではなく「データの変化」に着目する
+> - **トレース**：具体的な入力を使ってアルゴリズムの各ステップで変数がどう変わるかを追うこと
+
+---
+
+<h2 id="correctness">6. 正しさのスケッチ</h2>
+
+> 💡 **「正しさのスケッチ」とは**：アルゴリズムが常に正しい答えを返せる根拠を整理したものです。
+> 厳密な数学的証明ではなく「なぜ正しいと言えるのか」の直感的な説明です。
+
+### 不変条件（ループ中ずっと成り立つべき条件）
+
+**「キューに入っているノードは、その深さが正しく記録されている」**
+
+- キューに最初に入れる `(root, 1)` は根ノードの深さ 1 で正しい
+- 子ノードを追加するとき `depth + 1` とするのは、「親より 1 深い位置にある」という木の定義から正しい
+- したがって、ループを何回繰り返しても「キュー内の各要素のノードと深さの組み合わせ」は常に正しい
+
+### 網羅性（すべてのケースを処理できているか）
+
+BFS は同じ層のノードをすべてキューに入れてから次の層に進みます。
+これにより「深さ 1 のノード → 深さ 2 のノード → ...」と順番に処理されます。
+あるノードを「スキップ」することはないため、全てのノードを1回ずつ処理します。
+
+> **ただし**、葉が見つかった時点で即 `return` するため、残りのノードは処理されません。
+> これは問題ありません。なぜなら BFS の性質上、**最初に見つかった葉が確実に最小深さの葉**だからです。
+
+### 基底条件（終了条件）
+
+二重の終了条件があります：
+
+1. **`root is None`**：空の木は葉への道がないため深さ 0 を返す。この処理がないと `None.left` でクラッシュする
+2. **`node.left is None and node.right is None`**：葉ノードを見つけたら即 `return`。BFS は浅い順に処理するので最初の葉 = 最小深さ
+
+### 終了性（必ず有限ステップで終わるか）
+
+- ノード数は有限（最大 10^5）
+- 各ノードは一度だけキューに追加される（親から子への一方向）
+- したがってループは最大でもノード数回で終了する
+
+> 📖 **この章で登場した用語**
+>
+> - **不変条件（ループ不変式）**：アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件
+> - **網羅性**：すべてのケースをもれなく処理できているという保証
+> - **基底条件**：再帰やループの終了条件。これがないと無限ループ/クラッシュになる
+> - **終了性**：アルゴリズムが必ず有限ステップで終わるという保証
+
+---
+
+<h2 id="complexity">7. 計算量</h2>
+
+> 💡 **計算量とは**：「入力が大きくなるにつれて、処理にかかる時間・メモリがどう増えるか」の目安です。
+> Big-O 記法（O(n) のような書き方）を使って表します。
+
+| 記法       | 意味                   | 直感的なイメージ               |
+| ---------- | ---------------------- | ------------------------------ |
+| O(1)       | 入力サイズによらず一定 | 辞書で直接ページを開く         |
+| O(n)       | 入力に比例して増加     | リストを端から順に読む         |
+| O(n log n) | n よりやや速く増加     | 辞書を二分探索で引く × n 回    |
+| O(n²)      | 入力の 2 乗で増加      | 全ペアを総当たりで確認する     |
+| O(w)       | 木の最大幅に比例       | その層に存在するノード数に依存 |
+
+### この問題の計算量
+
+| 観点           | 計算量 | 説明                                                                                                                                 |
+| -------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------ |
+| **時間計算量** | O(n)   | 全ノード数を n とすると、各ノードを最大 1 回だけキューから取り出す。葉が見つかれば早期終了するため、平均的にはさらに速い             |
+| **空間計算量** | O(w)   | w は木の最大幅（1 つの層に存在する最大ノード数）。キューには同じ層のノードが同時に入るため、キューサイズの最大値は木の最大幅に等しい |
+
+### 最悪ケースでの空間計算量
+
+- **完全二分木**（バランスの取れた木）：最下層のノード数は n/2 個なので **O(n)**
+- **直線状の木**（一方向にのみ伸びる木）：常に 1 ノードずつキューに入るため **O(1)**
+
+### DFS（再帰）との比較
+
+| 手法            | 時間計算量 | 空間計算量 | 備考                                         |
+| --------------- | ---------- | ---------- | -------------------------------------------- |
+| **BFS（採用）** | O(n)       | O(w)       | 早期終了あり。葉が浅い場合に高速             |
+| DFS（再帰）     | O(n)       | O(h)       | h = 木の高さ。直線状の木で再帰制限リスクあり |
+| DFS（反復）     | O(n)       | O(h)       | スタックオーバーフローを回避できる           |
+
+> ※ h = 木の高さ（最悪 O(n)、完全二分木では O(log n)）
+> 📖 **この章で登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **木の幅（w）**：ある 1 つの層に存在するノードの個数。BFS のキューサイズはこれに比例する
+> - **木の高さ（h）**：根から最も深い葉までのノード数。DFS の再帰深度はこれに比例する
+> - **早期終了**：答えが確定した瞬間に処理を打ち切ること。平均的な実行時間を短縮できる
+
+---
+
+<h2 id="impl">8. Python 実装</h2>
+
+> 💡 **コードを読む前に：実装の全体的な骨格**
+>
+> 1. `from __future__ import annotations` で型ヒントの前方参照（自己参照）を有効にする
+> 2. `TreeNode` のフォールバック定義を `try/except NameError` で用意する（LeetCode 環境では不要）
+> 3. `root is None` のエッジケースを最初に処理する
+> 4. `deque` でキューを初期化し、根ノードと深さ 1 を入れる
+> 5. BFS ループで `popleft()` → 葉判定 → 子をキューに追加 を繰り返す
+> 6. 最初に葉を見つけた時点で `return depth`（早期終了）
+
+```python
+from __future__ import annotations
+# 型ヒントの前方参照を文字列として遅延評価する（TreeNode が自分自身を参照するため）
+
+from collections import deque
+# deque: popleft() が O(1) のキュー用データ構造。list.pop(0) は O(n) なので使わない
+
+from typing import Optional, TYPE_CHECKING
+# Optional[X]: X か None のどちらかであることを表す型ヒント
+
+# ──────────────────────────────────────────────────────────────────
+# TreeNode の定義
+#
+# LeetCode 環境では TreeNode が自動的に定義されている。
+# ローカル実行（テストや IDE）では NameError が発生するため、
+# try/except でフォールバック定義を用意しておく。
+#
+# if TYPE_CHECKING: ブロックは pylance（型チェッカー）だけが読むブロックで、
+# 実行時には評価されない。pylance に正確な型情報を伝えるために使う。
+# ──────────────────────────────────────────────────────────────────
+if TYPE_CHECKING:
+    # pylance 向けの型スタブ（実行時には読まれない）
+    class TreeNode:
+        val: int
+        left: Optional[TreeNode]
+        right: Optional[TreeNode]
+
+        def __init__(
+            self,
+            val: int = 0,
+            left: Optional[TreeNode] = None,
+            right: Optional[TreeNode] = None,
+        ) -> None: ...
+
+try:
+    TreeNode  # noqa: F821  LeetCode 環境で定義済みかチェック
+except NameError:
+    class TreeNode:  # type: ignore[no-redef]
+        """
+        ローカル実行用の最小定義。
+        __slots__ を使うことでインスタンスごとの辞書作成を避け、
+        メモリを節約する。
+        """
+        __slots__ = ("val", "left", "right")
+
+        def __init__(
+            self,
+            val: int = 0,
+            left: Optional[TreeNode] = None,
+            right: Optional[TreeNode] = None,
+        ) -> None:
+            self.val: int = val
+            self.left: Optional[TreeNode] = left
+            self.right: Optional[TreeNode] = right
+
+
+class Solution:
+    def minDepth(self, root: Optional[TreeNode]) -> int:
+        """
+        二分木の最小深さを BFS（幅優先探索）で求める。
+
+        最小深さとは「根から最も近い葉ノードまでのノード数」のこと。
+        葉ノードとは左右どちらにも子を持たないノードを指す。
+
+        Args:
+            root: 二分木の根ノード。None の場合は空の木を表す。
+
+        Returns:
+            最小深さ（整数）。空の木の場合は 0 を返す。
+
+        Time Complexity:  O(n)  — 最悪ケースで n 個のノードを 1 回ずつ処理する
+        Space Complexity: O(w)  — w はキューの最大サイズ（木の最大幅）
+        """
+        # ────────────────────────────────────────────────────────────
+        # エッジケース: 空の木（root が None）
+        # 根がなければ葉への道も存在しないため、深さは 0 を返す。
+        # ここでチェックしないと、次行の queue.append((root, 1)) で
+        # None をキューに入れてしまい、後で node.left にアクセスする際
+        # AttributeError が発生する。
+        # ────────────────────────────────────────────────────────────
+        if root is None:
+            return 0
+
+        # ────────────────────────────────────────────────────────────
+        # BFS 用キューの初期化
+        #
+        # なぜ list ではなく deque を使うのか：
+        #   list.pop(0) は O(n) → 先頭削除のたびに全要素を 1 つ左にずらす
+        #   deque.popleft() は O(1) → ポインタを動かすだけで完結する
+        #   ノード数が最大 10^5 の場合、この差は無視できない
+        #
+        # キューの各要素は (ノード, 現在の深さ) のタプル。
+        # 深さを外部のカウンタで管理せず、ノードと一緒に持ち運ぶことで
+        # バグが入り込む余地を減らしている。
+        # ────────────────────────────────────────────────────────────
+        queue: deque[tuple[TreeNode, int]] = deque()
+        queue.append((root, 1))  # 根ノードの深さは 1
+
+        # ────────────────────────────────────────────────────────────
+        # BFS メインループ
+        # キューが空になるまで（= 全ノードを処理し終えるまで）繰り返す
+        # ────────────────────────────────────────────────────────────
+        while queue:
+            # 先頭から取り出す（FIFO: 先に入れたものを先に取り出す）
+            # popleft() は O(1) の操作（deque を使う主な理由）
+            node, depth = queue.popleft()
+
+            # ──────────────────────────────────────────────────────
+            # 葉ノード判定
+            #
+            # 葉の条件: 左の子も右の子も None であること
+            # ※ 片方だけ None のノードは葉ではない（重要な罠）
+            #
+            # BFS は浅い層から順に処理するため、
+            # 最初に葉を見つけた時点でそれが確実に最小深さ。
+            # 残りのキューを処理する必要はないので即 return する。
+            # ──────────────────────────────────────────────────────
+            if node.left is None and node.right is None:
+                return depth  # 🎯 最小深さ確定、即 return
+
+            # ──────────────────────────────────────────────────────
+            # 子ノードをキューに追加する
+            #
+            # None の子を追加しないよう、必ず存在チェックを先に行う。
+            # None をキューに入れると次のループで node.left にアクセス
+            # できず AttributeError が発生する。
+            # ──────────────────────────────────────────────────────
+            if node.left is not None:
+                # 左の子が存在する場合のみキューに追加
+                # 深さは親の深さ + 1（1 段深くなるため）
+                queue.append((node.left, depth + 1))
+
+            if node.right is not None:
+                # 右の子が存在する場合のみキューに追加（左と同様）
+                queue.append((node.right, depth + 1))
+
+        # ────────────────────────────────────────────────────────────
+        # フォールバック（通常はここに到達しない）
+        #
+        # root が None でない有効な木には必ず葉が存在するため、
+        # while ループ内の return で必ず値が返る。
+        # pylance に「関数が必ず int を返す」ことを保証するために記述。
+        # ────────────────────────────────────────────────────────────
+        return 0
+```
+
+---
+
+### コードの動作トレース
+
+#### Example 1：`root = [3, 9, 20, null, null, 15, 7]`
+
+```
+呼び出し: solution.minDepth(root)
+  root = Node(3)
+
+  1. if root is None → False（root は存在する）→ 通過
+  2. queue 初期化: deque([ (Node(3), 1) ])
+
+  === ループ 1 回目 ===
+  popleft → node=Node(3), depth=1
+  葉判定: Node(3).left=Node(9) is None → False → 葉でない
+  PushL: Node(3).left=Node(9) is not None → queue.append((Node(9), 2))
+  PushR: Node(3).right=Node(20) is not None → queue.append((Node(20), 2))
+  queue = deque([ (Node(9),2), (Node(20),2) ])
+
+  === ループ 2 回目 ===
+  popleft → node=Node(9), depth=2
+  葉判定: Node(9).left=None AND Node(9).right=None → True！
+  → return 2  ← 🎯 確定
+
+最終結果: 2 ✅
+```
+
+#### Example 2：`root = [2, null, 3, null, 4, null, 5, null, 6]`
+
+```
+  1. if root is None → False → 通過
+  2. queue 初期化: deque([ (Node(2), 1) ])
+
+  === ループ 1 回目 ===
+  popleft → node=Node(2), depth=1
+  葉判定: Node(2).left=None, Node(2).right=Node(3)
+    → left は None だが right は None でない → False（葉でない！罠）
+  PushL: Node(2).left=None → スキップ
+  PushR: Node(2).right=Node(3) is not None → queue.append((Node(3), 2))
+  queue = deque([ (Node(3),2) ])
+
+  === ループ 2〜5 回目（同様）===
+  Node(3)→queue.append((Node(4),3))
+  Node(4)→queue.append((Node(5),4))
+  Node(5)→queue.append((Node(6),5))
+
+  === ループ 6 回目 ===
+  popleft → node=Node(6), depth=5
+  葉判定: Node(6).left=None AND Node(6).right=None → True！
+  → return 5  ← 🎯 確定
+
+最終結果: 5 ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **`from __future__ import annotations`**：型ヒントを文字列として遅延評価するようにする宣言。`TreeNode` が自分自身を型ヒントで参照するときに必要
+> - **`TYPE_CHECKING`**：実行時は `False`、pylance などの型チェッカー実行時は `True` になる定数。型スタブをこのブロックに書くことでランタイムコストを避けられる
+> - **`Optional[TreeNode]`**：`TreeNode` か `None` のどちらかであることを表す型ヒント。pylance が `None` チェックを強制してくれる
+> - **`__slots__`**：クラスのインスタンス変数を固定することで、通常の辞書の代わりに軽量な構造でメモリを節約する仕組み
+> - **フォールバック**：「本来は到達しないが念のため書いておく処理」。pylance に全パスで `int` を返すことを証明するために必要
+
+---
+
+<h2 id="cpython">9. CPython 最適化ポイント</h2>
+
+> 💡 **この章では**：同じ処理でも Python の書き方によって速さが変わる理由を説明します。
+> 「最適化前 → 最適化後 → なぜ速くなるか」の 3 点セットで解説します。
+
+### 最適化ポイント 1：`list.pop(0)` を `deque.popleft()` に置き換える
+
+BFS の実装でよく見かける間違いが、`list` をキューとして使うことです。
+
+```python
+# ❌ 最適化前：list を使ったキュー（遅い）
+queue: list[tuple[TreeNode, int]] = [(root, 1)]
+# ...
+node, depth = queue.pop(0)  # O(n): 全要素を左に 1 つずつずらす処理が発生する
+
+# ✅ 最適化後：deque を使ったキュー（速い）
+from collections import deque
+queue: deque[tuple[TreeNode, int]] = deque([(root, 1)])
+# ...
+node, depth = queue.popleft()  # O(1): ポインタを移動するだけで完結する
+```
+
+**なぜ速くなるのか**：
+Python の `list` は内部的に連続したメモリ配列（C言語の配列）で実装されています。
+先頭要素を削除すると、残り全要素を 1 つ左にずらさなければならないため O(n) のコストがかかります。
+`deque` は双方向連結リスト（ポインタで繋がれた箱の連鎖）で実装されており、
+先頭のポインタを動かすだけで済むため O(1) で削除できます。
+
+ノード数が 10^5 の場合、`pop(0)` を使うと最悪 O(n²) に劣化しますが、`popleft()` なら O(n) を保てます。
+
+---
+
+### 最適化ポイント 2：早期終了（Early Return）を活用する
+
+BFS の利点は「最初に葉を見つけた瞬間に終了できる」ことです。
+
+```python
+# ✅ 葉を見つけた瞬間に return する（早期終了）
+if node.left is None and node.right is None:
+    return depth  # ← ここで即終了。残りのキューは処理しない
+```
+
+例えば完全二分木の場合、深さ k の葉を最初に見つけた時点で終了するため、
+より深い葉（深さ k+1, k+2, ...）の探索を完全にスキップできます。
+
+---
+
+### 最適化ポイント 3：`is None` vs `== None`
+
+```python
+# ❌ 最適化前（遅い・pylance 警告も出る）
+if node.left == None:
+    ...
+
+# ✅ 最適化後（速い・Pythonic）
+if node.left is None:
+    ...
+```
+
+**なぜ `is None` の方が速いのか**：
+`== None` は `__eq__` メソッドを呼び出して比較します（メソッド呼び出しのオーバーヘッドあり）。
+`is None` はオブジェクトの ID（メモリアドレス）を直接比較するため、より高速です。
+また Python の `None` はシングルトン（プログラム内で唯一のオブジェクト）なので `is` で正しく比較できます。
+
+---
+
+### 最適化ポイント 4：ノードと深さをタプルで一緒に管理する
+
+```python
+# ❌ 最適化前：外部のカウンタで深さを管理（バグが入りやすい）
+queue = deque([root])
+depth = 0
+level_size = 1
+while queue:
+    depth += 1
+    for _ in range(level_size):
+        node = queue.popleft()
+        if not node.left and not node.right:
+            return depth
+        ...
+    level_size = len(queue)
+
+# ✅ 最適化後：ノードと深さをタプルで一緒に持ち運ぶ（シンプル）
+queue: deque[tuple[TreeNode, int]] = deque([(root, 1)])
+while queue:
+    node, depth = queue.popleft()  # 深さが常にノードと一致する
+    ...
+```
+
+タプルアンパック（`node, depth = queue.popleft()`）は CPython 内部で最適化されており、
+辞書や別オブジェクトを使うよりもメモリ効率が良く、高速です。
+
+> 📖 **この章で登場した用語**
+>
+> - **連続したメモリ配列**：要素がメモリ上に隙間なく並んだデータ構造。先頭削除に O(n) かかる
+> - **双方向連結リスト**：各要素が前後の要素へのポインタを持つデータ構造。先頭・末尾操作が O(1)
+> - **シングルトン**：プログラム内で同じ型のインスタンスが 1 つしか存在しないオブジェクト。Python の `None`, `True`, `False` がこれにあたる
+> - **タプルアンパック**：`a, b = (1, 2)` のように、タプルの要素を複数の変数に同時に代入すること
+> - **O(n²) に劣化**：入力が 2 倍になると処理が 4 倍になること。`pop(0)` を n 回繰り返すと合計 O(n²) になる
+
+---
+
+<h2 id="edgecases">10. エッジケースと検証観点</h2>
+
+> 💡 **エッジケースとは**：「空のツリー・ノード 1 つ・直線状の木」など、境界的な入力のことです。
+> エッジケースを見落とすと、普通のテストは通るのに特定の入力でだけバグが発生します。
+> 各ケースについて「なぜそのケースが問題になりうるか」を確認しておきましょう。
+
+| #   | ケース名      | 入力例                           | 期待値 | なぜ問題になりうるか                                                                    |
+| --- | ------------- | -------------------------------- | ------ | --------------------------------------------------------------------------------------- |
+| 1   | 空の木        | `root = None`                    | `0`    | `root.left` にアクセスするとクラッシュする。最初に `None` チェックが必要                |
+| 2   | ノードが 1 つ | `root = [1]`                     | `1`    | 根自体が葉。`1 + min(left, right)` を使うアプローチでは深さ 0 を誤返却しがち            |
+| 3   | 左のみ偏り木  | `root = [1, 2]`                  | `2`    | 右の子がないため右方向の深さを 0 と誤解すると、`min(0+1, 2+1) = 1` という誤答になる     |
+| 4   | 右のみ偏り木  | `root = [1, null, 2]`            | `2`    | ケース 3 の左右を入れ替えたもの。同様の罠がある                                         |
+| 5   | 直線状の木    | `root = [2,null,3,null,...,6]`   | `5`    | Example 2 が該当。全ノードが右方向に一直線で、葉は最深部の 1 つだけ                     |
+| 6   | 完全二分木    | `root = [3,9,20,null,null,15,7]` | `2`    | Example 1 が該当。最浅の葉（深さ 2）を早期に発見できるかが鍵                            |
+| 7   | 左右完全対称  | `root = [1,2,2,3,3,3,3]`         | `3`    | どちら側から探索しても同じ深さ。BFS は問題なく処理できる                                |
+| 8   | 最大ノード数  | ノード数 10^5 の直線状の木       | `10^5` | `deque` を使わないと TLE（制限時間超過）になる。再帰 DFS では RecursionError が発生する |
+
+### ケース 3 の詳細（「左のみ偏り木」の罠）
+
+```
+入力: root = [1, 2]
+木の形状:
+    1       ← 深さ 1
+   /
+  2         ← 深さ 2（唯一の葉）
+
+間違ったアプローチ（min を単純に使う）:
+  minDepth(root) = 1 + min(minDepth(left), minDepth(right))
+                 = 1 + min(minDepth(Node(2)), minDepth(None))
+                 = 1 + min(1, 0)  ← 0 は「深さなし」ではなく誤り
+                 = 1              ← ❌ 誤答
+
+正しいアプローチ（BFS の場合）:
+  Step 1: popleft → Node(1), depth=1
+          left=Node(2) (not None), right=None → 葉でない
+          → PushL: queue.append((Node(2), 2))
+          → PushR: right は None なのでスキップ
+  Step 2: popleft → Node(2), depth=2
+          left=None AND right=None → 葉！
+          → return 2  ← ✅ 正答
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **エッジケース**：空の木・ノード 1 つ・最大サイズ入力など、境界的な条件の入力
+> - **TLE（Time Limit Exceeded）**：制限時間超過。O(n²) のアルゴリズムは大きな入力でこれが発生する
+> - **RecursionError**：Python の再帰呼び出し回数がデフォルト制限（1000 回）を超えたときのエラー。10^5 ノードの直線状の木で再帰 DFS を使うと発生する
+> - **偏り木（偏向木）**：一方向にのみ伸びる、直線に近い形の木。最悪ケースの代表例
+
+---
+
+<h2 id="faq">11. FAQ</h2>
+
+> 💡 **FAQ（Frequently Asked Questions）**：初学者がつまずきやすいポイントをまとめた Q&A です。
+
+---
+
+**Q1. なぜ `list.pop(0)` ではなく `deque.popleft()` を使うのですか？**
+
+**結論**：`list.pop(0)` は O(n) のコストがかかり、ノード数が多いと著しく遅くなるからです。
+
+**理由**：Python の `list` は内部的に連続したメモリ配列で実装されています。
+先頭要素を削除すると、残り全要素を 1 つずつ左にずらさなければなりません。
+例えばノードが 1000 個あれば、1 回の `pop(0)` で最大 999 個の要素を移動させます。
+これを 1000 回繰り返すと合計 O(n²) になります。
+
+**補足（具体例）**：
+
+```python
+# ❌ list を使った場合（ノード数 n で O(n²)）
+q = [1, 2, 3, 4, 5]
+q.pop(0)  # → [2, 3, 4, 5] ← 内部で 4 要素を左にずらした
+
+# ✅ deque を使った場合（ノード数 n で O(n)）
+from collections import deque
+q = deque([1, 2, 3, 4, 5])
+q.popleft()  # → deque([2, 3, 4, 5]) ← ポインタを動かすだけ（要素は移動しない）
+```
+
+---
+
+**Q2. なぜ片方の子が `None` でも葉にならないのですか？**
+
+**結論**：葉の定義が「左右どちらにも子がないノード」であるからです。
+片方だけ `None` の場合は、もう片方の方向に探索を続ける必要があります。
+
+**理由**：もし「片方が `None` なら葉扱い」にしてしまうと、
+Example 2 の `Node(2)` のように「右の子はあるが左の子はない」ノードを葉と判定してしまい、
+深さ 1 という誤答を返してしまいます。
+
+**補足（DFS 再帰の場合の正しい書き方）**：
+
+```python
+def minDepth(self, root: Optional[TreeNode]) -> int:
+    if root is None:
+        return 0
+    # 左の子がない場合 → 右方向のみ探索
+    if root.left is None:
+        return 1 + self.minDepth(root.right)
+    # 右の子がない場合 → 左方向のみ探索
+    if root.right is None:
+        return 1 + self.minDepth(root.left)
+    # 両方ある場合 → 両方探索して小さい方
+    return 1 + min(self.minDepth(root.left), self.minDepth(root.right))
+```
+
+---
+
+**Q3. DFS（再帰）ではダメなのですか？ BFS を選ぶ理由は何ですか？**
+
+**結論**：DFS（再帰）も正しい答えを返しますが、2 つのリスクがあります。
+BFS の方がこの問題の性質に自然に合致し、より安全です。
+
+**理由 1：再帰深度の制限**
+Python のデフォルト再帰深度制限は 1000 回です。
+直線状の木でノード数が 10^5 の場合、DFS 再帰は `RecursionError` で失敗します。
+BFS はスタックを使わないため、この問題が発生しません。
+
+**理由 2：「最短」問題に BFS が自然に合致する**
+DFS は全ての葉を探索してから `min()` で比較します。
+BFS は浅い層から探索するため、最初に葉を見つけた瞬間に終了できます（早期終了）。
+完全二分木のような「答えが浅い位置にある」ケースでは BFS が大幅に速いです。
+
+**補足**：`sys.setrecursionlimit()` で制限を増やす方法もありますが、
+スタックオーバーフロー（OS レベルのクラッシュ）を引き起こす可能性があり推奨されません。
+
+---
+
+**Q4. キューの要素を `(ノード, 深さ)` のタプルにする理由は何ですか？**
+
+**結論**：ノードと深さを常にセットで管理することで、コードがシンプルになりバグが入りにくくなります。
+
+**理由**：別の実装として「層ごとにループを回してカウンタを増やす」方法もあります。
+しかしその場合は「現在の層のサイズ」を別で管理する必要があり、コードが複雑になります。
+タプルでノードと深さを一緒に持ち運べば、どのノードを処理しても深さが常に正確に分かります。
+
+**補足（別実装との比較）**：
+
+```python
+# 別実装：層のサイズを管理する方法（複雑）
+while queue:
+    level_size = len(queue)       # 現在の層のノード数
+    depth += 1
+    for _ in range(level_size):   # 現在の層を全部処理してから深さを増やす
+        node = queue.popleft()
+        ...
+
+# 採用した実装：タプルで管理（シンプル）
+while queue:
+    node, depth = queue.popleft()  # 深さは常にノードと一致
+    ...
+```
+
+---
+
+**Q5. フォールバックの `return 0` は本当に必要ですか？**
+
+**結論**：ロジック的には到達しませんが、pylance（型チェッカー）のために必要です。
+
+**理由**：pylance は「関数の全コードパスで `int` が返ることを保証できるか」を静的に確認します。
+`while queue:` ブロックは「キューが空になれば通過する」可能性があると判断されるため、
+ブロックの後に `return` 文がないと「`None` を返す可能性がある」という型エラーを報告します。
+実際には `root is not None` であれば葉が必ず存在するためここには到達しませんが、
+pylance を満足させるために `return 0` を記述します。
+
+> 📖 **この章で登場した用語**
+>
+> - **FAQ**：Frequently Asked Questions の略。よくある質問と回答のこと
+> - **RecursionError**：Python の再帰呼び出しがデフォルト上限（1000 回）を超えたときのエラー
+> - **スタックオーバーフロー**：再帰呼び出しが深くなりすぎてメモリ（コールスタック）が溢れること
+> - **早期終了**：答えが確定した瞬間に処理を打ち切ること。BFS で最初の葉を見つけた瞬間がこれにあたる
+> - **静的型チェック**：プログラムを実行せずにコードを読むだけで型の不整合を検出する手法。pylance がこれを担う
+
+---
+
+_最終更新：CPython 3.11.10 / LeetCode #111 Minimum Depth of Binary Tree_
diff --git a/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html b/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html
new file mode 100644
index 0000000..da5f8e2
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html	
@@ -0,0 +1,1776 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 111 - Minimum Depth of Binary Tree | BFS解説</title>
+        <script src="https://unpkg.com/react@18/umd/react.development.js"></script>
+        <script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"></script>
+        <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
+        <script src="https://cdn.tailwindcss.com"></script>
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css"
+        />
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.css"
+        />
+        <link
+            rel="stylesheet"
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.css"
+        />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Inter', sans-serif;
+                background: linear-gradient(135deg, #f0fdf4 0%, #e0f2fe 100%);
+                min-height: 100vh;
+            }
+            code,
+            pre {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            pre[class*='language-'] {
+                border-radius: 0.75rem;
+                font-size: 0.82rem;
+            }
+            .code-toolbar > .toolbar .toolbar-item a,
+            .code-toolbar > .toolbar .toolbar-item button,
+            .code-toolbar > .toolbar .toolbar-item span {
+                background: #10b981 !important;
+                color: white !important;
+                border-radius: 6px !important;
+                padding: 3px 10px !important;
+                font-size: 12px !important;
+                border: none !important;
+                cursor: pointer !important;
+                box-shadow: none !important;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+        </style>
+    </head>
+    <body class="p-4 md:p-8">
+        <div class="max-w-4xl mx-auto">
+            <!-- ═══════════════════════════════════════════ HEADER ═══════════════════════════════════════════ -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.12)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex items-center gap-3 mb-2 flex-wrap">
+                    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >LeetCode 111</span
+                    >
+                    <span class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >Easy</span
+                    >
+                    <span class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >BFS</span
+                    >
+                </div>
+                <h1 class="text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Minimum Depth of Binary Tree
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    BFS（幅優先探索）による O(n) 実装
+                </p>
+                <p
+                    class="mt-3 text-base text-teal-800 bg-white/60 rounded-xl px-4 py-2 inline-block"
+                >
+                    💡
+                    一言で言うと：「根ノードから最も近い葉ノードまでの最短経路のノード数を求める問題」
+                </p>
+                <nav class="flex flex-wrap gap-3 mt-6">
+                    <a
+                        href="#overview"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ═══════════════════════════════════════════ OVERVIEW ═══════════════════════════════════════════ -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="mb-5 p-4 rounded-xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-semibold text-base">
+                        💡
+                        この問題を一言で言うと：「根ノードから最も近い葉ノードまでの最短経路のノード数を返す問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2">
+                        「最小深さ」とは、木の根（一番上）から出発して、最初に到達できる葉（子を持たないノード）までのノード数のことです。深さは根を1として数えます。葉ノードとは、左の子も右の子もどちらも存在しないノードのことです。
+                    </p>
+                </div>
+
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-semibold text-sm mb-2">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-600 text-sm space-y-2 list-disc list-inside">
+                        <li>
+                            <strong>「片側だけに子があるノード」が罠になる：</strong
+                            >左の子がない＝葉、ではありません。たとえば右の子だけを持つノードは葉ではなく、右へ続く経路がある「中間ノード」です。例2（[2,null,3,null,4,null,5,null,6]）がその典型で、最小深さはなんと
+                            5 になります。
+                        </li>
+                        <li>
+                            <strong>DFS（深さ優先）では最短を保証できない：</strong>DFS
+                            は「葉に到達するまで一方向に潜り続ける」性質があるため、偶然最初に見つかった葉が最短とは限りません。BFS
+                            なら浅いノードから順番に調べるので、最初に見つかった葉が必ず最短です。
+                        </li>
+                    </ul>
+                </div>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-6">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono">O(n)</div>
+                        <div class="text-xs mt-1">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono">O(w)</div>
+                        <div class="text-xs mt-1">空間計算量 (w=最大幅)</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono">BFS</div>
+                        <div class="text-xs mt-1">アルゴリズム</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">deque</div>
+                        <div class="text-xs mt-1">使用データ構造</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+                    <div class="p-4 rounded-xl bg-slate-50 border border-slate-200">
+                        <p class="font-semibold text-teal-800 text-sm mb-3">例1: 通常の二分木</p>
+                        <pre class="text-xs font-mono text-slate-700 leading-6 mb-0">
+入力: root = [3,9,20,null,null,15,7]
+
+      3
+     / \
+    9  20
+       / \
+      15   7
+
+出力: 2</pre
+                        >
+                        <p class="text-slate-500 text-xs mt-2 pt-2 border-t border-slate-200">
+                            根(3)→左の子(9)
+                            の経路が長さ2で最短。ノード9は左も右も子がない「葉」のため、深さ2が答えになります。
+                        </p>
+                    </div>
+                    <div class="p-4 rounded-xl bg-slate-50 border border-slate-200">
+                        <p class="font-semibold text-teal-800 text-sm mb-3">
+                            例2: 一方向にだけ伸びる木
+                        </p>
+                        <pre class="text-xs font-mono text-slate-700 leading-6 mb-0">
+入力: root = [2,null,3,null,4,null,5,null,6]
+
+2
+ \
+  3
+   \
+    4
+     \
+      5
+       \
+        6   ← 唯一の葉
+
+出力: 5</pre
+                        >
+                        <p class="text-slate-500 text-xs mt-2 pt-2 border-t border-slate-200">
+                            右方向にのみ子があり、唯一の葉はノード6。葉までの距離が5なのでその深さが答えです。
+                        </p>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ STEPS (React root) ═══════════════════════════════════════════ -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ CODE ═══════════════════════════════════════════ -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-4 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-1 list-decimal list-inside">
+                        <li>エッジケース処理：root が None（空の木）なら即座に 0 を返す</li>
+                        <li>BFS キューを初期化：deque に (根ノード, 深さ=1) のペアを入れる</li>
+                        <li>キューが空になるまで繰り返す：浅い順にノードを一つずつ処理する</li>
+                        <li>
+                            葉ノードに到達したら深さを返す（BFS の特性で、最初の葉が必ず最短経路）
+                        </li>
+                    </ol>
+                </div>
+
+                <pre class="line-numbers"><code class="language-python">from typing import Optional
+from collections import deque
+
+
+class Solution:
+    def minDepth(self, root: Optional[TreeNode]) -> int:
+        # ─────────────────────────────────────
+        # エッジケース: 空の木 → 深さ 0 を返す
+        # 根がなければ「葉までの道」自体が存在しない
+        # ─────────────────────────────────────
+        if root is None:
+            return 0
+
+        # ─────────────────────────────────────
+        # BFS キューを初期化する
+        # deque の popleft() は O(1) ← list より効率的
+        # タプル (ノード, 現在の深さ) でペアを管理する
+        # ─────────────────────────────────────
+        queue: deque = deque()
+        queue.append((root, 1))   # 根ノードは深さ 1 からスタート
+
+        while queue:
+            # popleft() = FIFO（先入れ先出し）→ 浅い順に処理
+            node, depth = queue.popleft()
+
+            # ─────────────────────────────────
+            # 葉ノード判定: 左も右も子がない = 葉
+            # BFS は浅い順なので、最初の葉 = 最小深さ
+            # ─────────────────────────────────
+            if node.left is None and node.right is None:
+                return depth      # 最小深さ確定！
+
+            # 子ノードは存在する場合のみキューに追加
+            if node.left is not None:
+                queue.append((node.left,  depth + 1))
+            if node.right is not None:
+                queue.append((node.right, depth + 1))
+
+        return 0  # 有効な木なら通常ここに到達しない</code></pre>
+
+                <div class="mt-4 p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        ▶ 入力例 [3,9,20,null,null,15,7] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-7 overflow-x-auto whitespace-pre"
+                    >
+初期状態: queue = [(node=3, depth=1)]
+
+反復 1: pop → (node=3, depth=1)
+   左の子: 9 あり, 右の子: 20 あり → 葉ではない
+   → queue に (node=9, depth=2) と (node=20, depth=2) を追加
+   → queue = [(node=9, depth=2), (node=20, depth=2)]
+
+反復 2: pop → (node=9, depth=2)
+   左の子: None, 右の子: None → 🌿 葉ノード発見！
+   → return 2   ✅ 答え: 2（探索終了）
+
+※ node=20 はキューに残ったままですが、葉を見つけた時点で即 return
+   するためこれ以上処理は行われません。</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ DIAGRAM ═══════════════════════════════════════════ -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-semibold text-sm mb-3">
+                        🗺️ フローチャートの読み方
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700">
+                        <div class="flex items-center gap-2">
+                            <svg width="34" height="22">
+                                <ellipse
+                                    cx="17"
+                                    cy="11"
+                                    rx="16"
+                                    ry="10"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="34" height="22">
+                                <rect
+                                    x="1"
+                                    y="3"
+                                    width="32"
+                                    height="16"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="34" height="22">
+                                <polygon
+                                    points="17,2 33,11 17,20 1,11"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 flex-wrap gap-y-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500"></span
+                            ><span class="mr-2">緑＝はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-400"></span
+                            ><span>赤＝いいえ</span>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-5 overflow-x-auto">
+                    <!--
+        viewBox設計:
+          幅: 560px, 中央 x=280
+          主フロー rect: x=70, w=380 (右端 x=450)
+          ひし形 half-w=120: 左端x=160, 右端x=400
+          サイドボックス: x=405, w=110 (右端x=515)
+          サイドライン x=460 (サイドボックス中心)
+          ループ矢印: 左端 x=38
+          終了楕円: cy=895
+          viewBox高さ: 920
+      -->
+                    <svg
+                        viewBox="0 0 560 940"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Minimum Depth of Binary Tree BFS flowchart"
+                    >
+                        <defs>
+                            <marker
+                                id="fc-arrow"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#64748b" />
+                            </marker>
+                            <marker
+                                id="fc-arrowGreen"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#059669" />
+                            </marker>
+                            <marker
+                                id="fc-arrowRed"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#ef4444" />
+                            </marker>
+                            <marker
+                                id="fc-arrowPurple"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#a855f7" />
+                            </marker>
+                        </defs>
+
+                        <!-- ── Node 1: 開始 ── cy=50, ry=26, bottom=76 -->
+                        <ellipse
+                            cx="280"
+                            cy="50"
+                            rx="72"
+                            ry="26"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="54"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="15"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            開始
+                        </text>
+
+                        <!-- arrow 76→103 -->
+                        <line
+                            x1="280"
+                            y1="76"
+                            x2="280"
+                            y2="103"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 2: root is None? Diamond ── center(280,148), ±120 wide, ±48 tall -->
+                        <!-- points: top(280,100), right(400,148), bottom(280,196), left(160,148) -->
+                        <polygon
+                            points="280,100 400,148 280,196 160,148"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="143"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            root is None ?
+                        </text>
+                        <text
+                            x="280"
+                            y="160"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            （木が空かどうか）
+                        </text>
+
+                        <!-- "はい" right → side box A -->
+                        <text x="405" y="137" font-size="11" fill="#059669" font-weight="500">
+                            はい
+                        </text>
+                        <line
+                            x1="400"
+                            y1="148"
+                            x2="405"
+                            y2="148"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- Side Box A: "return 0" rect x=405, y=128, w=110, h=40 -->
+                        <rect
+                            x="405"
+                            y="128"
+                            width="110"
+                            height="40"
+                            rx="6"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="460"
+                            y="144"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            0 を返す
+                        </text>
+                        <text
+                            x="460"
+                            y="159"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="10"
+                            fill="#065f46"
+                        >
+                            return 0
+                        </text>
+
+                        <!-- [FIX] Box A → 右スパイン接続: 右端(515,148)→スパイン(545,148) -->
+                        <line
+                            x1="515"
+                            y1="148"
+                            x2="545"
+                            y2="148"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- "いいえ" down → Node 3 -->
+                        <text x="294" y="215" font-size="11" fill="#ef4444" font-weight="500">
+                            いいえ
+                        </text>
+                        <line
+                            x1="280"
+                            y1="196"
+                            x2="280"
+                            y2="235"
+                            stroke="#ef4444"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- ── Node 3: BFSキュー初期化 ── rect y=235, h=56, bottom=291 -->
+                        <rect
+                            x="70"
+                            y="235"
+                            width="380"
+                            height="56"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="258"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            BFS キューを初期化
+                        </text>
+                        <text
+                            x="280"
+                            y="276"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            queue = deque([(root, 1)])
+                        </text>
+
+                        <!-- arrow 291→318 -->
+                        <line
+                            x1="280"
+                            y1="291"
+                            x2="280"
+                            y2="318"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 4: ノード取出し ── rect y=318, h=56, center-y=346, bottom=374 -->
+                        <rect
+                            x="70"
+                            y="318"
+                            width="380"
+                            height="56"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="341"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            キューからノードを取り出す
+                        </text>
+                        <text
+                            x="280"
+                            y="359"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            node, depth = queue.popleft()
+                        </text>
+
+                        <!-- arrow 374→402 -->
+                        <line
+                            x1="280"
+                            y1="374"
+                            x2="280"
+                            y2="402"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 5: 葉ノード? Diamond ── center(280,452), ±120 wide, ±50 tall -->
+                        <polygon
+                            points="280,402 400,452 280,502 160,452"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="446"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            葉ノード?
+                        </text>
+                        <text
+                            x="280"
+                            y="464"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            left==None and right==None
+                        </text>
+
+                        <!-- "はい" right → Side Box B -->
+                        <text x="405" y="442" font-size="11" fill="#059669" font-weight="500">
+                            はい
+                        </text>
+                        <line
+                            x1="400"
+                            y1="452"
+                            x2="405"
+                            y2="452"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- Side Box B: "return depth" x=405, y=432, w=110, h=40 -->
+                        <rect
+                            x="405"
+                            y="432"
+                            width="110"
+                            height="40"
+                            rx="6"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="460"
+                            y="448"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            depth を返す
+                        </text>
+                        <text
+                            x="460"
+                            y="463"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="10"
+                            fill="#065f46"
+                        >
+                            return depth
+                        </text>
+
+                        <!-- [FIX] Box B → 右スパイン接続: 右端(515,452)→スパイン(545,452) -->
+                        <line
+                            x1="515"
+                            y1="452"
+                            x2="545"
+                            y2="452"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- [FIX] 右スパイン: x=545 の単一縦線 — Box A出口(545,148)から終了レベル(545,895)まで -->
+                        <!-- Box A exit と Box B exit の両方がここに合流し、終了ノードへ向かう。衝突なし。 -->
+                        <line
+                            x1="545"
+                            y1="148"
+                            x2="545"
+                            y2="895"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- [FIX] スパイン → 終了 右端へ水平矢印: (545,895)→(353,895) -->
+                        <!-- 終了楕円 cx=280 rx=72 → 右端 x=352。矢印は左向きに収束する。 -->
+                        <line
+                            x1="545"
+                            y1="895"
+                            x2="353"
+                            y2="895"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+
+                        <!-- "いいえ" down → Node 6 -->
+                        <text x="294" y="521" font-size="11" fill="#ef4444" font-weight="500">
+                            いいえ
+                        </text>
+                        <line
+                            x1="280"
+                            y1="502"
+                            x2="280"
+                            y2="540"
+                            stroke="#ef4444"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- ── Node 6: 子をキューに追加 ── rect y=540, h=56, bottom=596 -->
+                        <rect
+                            x="70"
+                            y="540"
+                            width="380"
+                            height="56"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="563"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            子ノードをキューに追加
+                        </text>
+                        <text
+                            x="280"
+                            y="581"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            queue.append((child, depth + 1))
+                        </text>
+
+                        <!-- ── ループ矢印: Node 6下端 → 左 → 上 → Node 4左端 ── -->
+                        <line
+                            x1="280"
+                            y1="596"
+                            x2="280"
+                            y2="626"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="280"
+                            y1="626"
+                            x2="38"
+                            y2="626"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="38"
+                            y1="626"
+                            x2="38"
+                            y2="346"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="38"
+                            y1="346"
+                            x2="70"
+                            y2="346"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowPurple)"
+                        />
+                        <text
+                            x="22"
+                            y="490"
+                            font-size="11"
+                            fill="#a855f7"
+                            text-anchor="middle"
+                            font-weight="500"
+                        >
+                            ル
+                        </text>
+                        <text
+                            x="22"
+                            y="504"
+                            font-size="11"
+                            fill="#a855f7"
+                            text-anchor="middle"
+                            font-weight="500"
+                        >
+                            ー
+                        </text>
+                        <text
+                            x="22"
+                            y="518"
+                            font-size="11"
+                            fill="#a855f7"
+                            text-anchor="middle"
+                            font-weight="500"
+                        >
+                            プ
+                        </text>
+
+                        <!-- ── Node 7: 終了 ── cy=895, ry=26, bottom=921 → viewBox高さ940で収容 -->
+                        <ellipse
+                            cx="280"
+                            cy="895"
+                            rx="72"
+                            ry="26"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="899"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="15"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            終了
+                        </text>
+                    </svg>
+                </div>
+
+                <div class="mt-5 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-semibold text-sm mb-2">
+                        🔎 入力例 [3,9,20,null,null,15,7] でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→ root = TreeNode(3) なので None ではない → 「いいえ」の経路へ
+                        </li>
+                        <li>「BFS キュー初期化」→ queue = [(node=3, depth=1)] にセット</li>
+                        <li>「キューから取出し」→ node=3, depth=1 を popleft で取り出す</li>
+                        <li>
+                            「葉ノード?」→ node=3 の left=9, right=20 があるので「いいえ」→
+                            子をキューに追加
+                        </li>
+                        <li>
+                            「子をキューに追加」→ queue = [(node=9, depth=2), (node=20, depth=2)]
+                            になりループ
+                        </li>
+                        <li>「キューから取出し」→ node=9, depth=2 を取り出す</li>
+                        <li>
+                            「葉ノード?」→ node=9 の left=None, right=None → 「はい」→ depth=2
+                            を返す
+                        </li>
+                        <li>「終了」→ 答え 2 を返して処理完了</li>
+                    </ol>
+                </div>
+
+                <p class="mt-5 text-slate-700 leading-8 text-sm">
+                    <strong class="text-base text-teal-800">フローの要点：</strong><br />
+                    BFS
+                    はキューを使って「浅いノードから順番に」処理します。ループ（紫の矢印）は次のノードを処理するためにキューへ戻ることを表しています。右側の緑の線（サイドライン）は「条件を満たしたので早期リターン」する経路です。<code
+                        class="bg-slate-100 px-1 rounded text-xs font-mono"
+                        >root is None</code
+                    >
+                    のときは 0 を、葉ノードを見つけたときはそのときの
+                    <code class="bg-slate-100 px-1 rounded text-xs font-mono">depth</code>
+                    を即座に返します。
+                </p>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ COMPLEXITY ═══════════════════════════════════════════ -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <div class="mb-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-semibold text-sm mb-3">
+                        📖 Big-O 記法の読み方（入力サイズ n が大きくなると処理時間がどう変わるか）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-2 text-xs">
+                        <div class="text-center p-3 rounded-lg bg-emerald-100 text-emerald-800">
+                            <div class="font-bold font-mono text-base mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-sky-100 text-sky-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-amber-100 text-amber-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n log n)</div>
+                            <div class="leading-5">
+                                n より少し多い<br /><span class="text-amber-600"
+                                    >例：マージソート</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-red-100 text-red-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-red-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto mb-4">
+                    <table class="w-full border-collapse text-sm">
+                        <thead>
+                            <tr class="bg-teal-50">
+                                <th
+                                    class="text-left p-3 border border-slate-200 text-teal-800 font-semibold"
+                                >
+                                    種別
+                                </th>
+                                <th
+                                    class="text-center p-3 border border-slate-200 text-teal-800 font-semibold"
+                                >
+                                    記法
+                                </th>
+                                <th
+                                    class="text-left p-3 border border-slate-200 text-teal-800 font-semibold"
+                                >
+                                    変数の意味
+                                </th>
+                                <th
+                                    class="text-left p-3 border border-slate-200 text-teal-800 font-semibold"
+                                >
+                                    ケース
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="hover:bg-slate-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    時間計算量
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <code
+                                        class="bg-emerald-100 text-emerald-800 px-2 py-0.5 rounded font-mono text-sm"
+                                        >O(n)</code
+                                    >
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600">
+                                    n = 木のノード総数
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600">
+                                    最悪ケース（全ノード訪問）
+                                </td>
+                            </tr>
+                            <tr class="hover:bg-slate-50 bg-slate-25">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    空間計算量
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <code
+                                        class="bg-sky-100 text-sky-800 px-2 py-0.5 rounded font-mono text-sm"
+                                        >O(w)</code
+                                    >
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600">
+                                    w = 木の最大幅（1段のノード最大数）
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600">
+                                    完全二分木では O(n/2) ≈ O(n)
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <div class="p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        🔍 なぜこの計算量になるのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        <strong>時間 O(n)：</strong
+                        >最悪のケースでは、葉が最後の1個で木の最深部にある状況です（例2のような一方向に伸びる木）。この場合、全
+                        n ノードをキューから1回ずつ取り出して処理するため、処理回数は n
+                        に比例します。ただし最良のケースは根ノード自体が葉（n=1）のときで、即座に
+                        O(1) で返ります。<br /><br /><strong>空間 O(w)：</strong
+                        >キューには「同じ深さのノード」が同時に蓄積されます。最もノードが密集する段（=
+                        木の最大幅 w）のとき、キューのサイズが最大になります。完全二分木の最下段では
+                        w ≈ n/2 となり、事実上 O(n) と等価です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ GLOSSARY ═══════════════════════════════════════════ -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたら参照してください。
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> BFS（幅優先探索）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Breadth-First Search
+                            の略。木やグラフを「根に近い順」「浅い階層から順番に」探索するアルゴリズムです。「うずまきのように外側から内側に向かって広がる」イメージに例えられます。キュー（待ち行列）を使って実装し、最短経路の発見に特に適しています。対義語は
+                            DFS（深さ優先探索）。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> deque（デク）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            double-ended queue（両端キュー）の略。Python の
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >collections.deque</code
+                            >
+                            が提供します。先頭と末尾の両端から O(1)
+                            の定数時間で要素の追加・取り出しができます。通常の
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">list</code> の
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">pop(0)</code>
+                            は O(n) のコストがかかるため、BFS には deque の使用が必須です。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            葉ノード（リーフノード）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            左の子も右の子も持たないノードのことです。木の末端に位置します。「葉」という名前は、木の葉っぱが枝の末端にあることに由来します。判定条件は
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >node.left is None and node.right is None</code
+                            >
+                            です。注意点：左右どちらか一方の子しか持たないノードは葉ではありません。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> キュー（待ち行列）/
+                            FIFO
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            FIFO（First In, First Out =
+                            先入れ先出し）の原則に従うデータ構造です。コンビニのレジ待ちの列と同じで、先に並んだ人が先に処理されます。BFS
+                            では「浅いノードを先に処理する」ために必須です。<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >append()</code
+                            >
+                            で末尾に追加し、<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >popleft()</code
+                            >
+                            で先頭から取り出します。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            根ノード（ルートノード）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木の最上位に位置する唯一のノードです。親ノードを持ちません。木の探索はここから開始します。深さの数え方では、根ノードの深さを
+                            1 として数えます（問題によっては 0 から数えることもあります）。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> 時間計算量 / 空間計算量
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <strong>時間計算量</strong>：入力サイズ n
+                            が増えたときに、処理ステップ数がどのくらい増えるかの指標です。O(n) は「n
+                            が2倍になると処理も約2倍」を意味します。<br />
+                            <strong>空間計算量</strong
+                            >：アルゴリズムが使用するメモリ（RAM）の量の指標です。O(w)
+                            はキューに同時に蓄積されるノード数（= 木の最大幅
+                            w）に比例することを示しています。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            二分木（バイナリーツリー）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            各ノードが最大2つの子（左の子・右の子）を持つ木構造のデータ構造です。「二分」とは「2つに分かれる」という意味で、各ノードで枝が最大2本に分岐します。LeetCode
+                            では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >TreeNode</code
+                            >
+                            クラスが使われ、<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >val</code
+                            >（値）・<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >left</code
+                            >（左の子）・<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >right</code
+                            >（右の子）の3つの属性を持ちます。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <!-- Footer -->
+            <footer class="text-center text-slate-400 text-xs py-6">
+                LeetCode 111 — Minimum Depth of Binary Tree | BFS 解説ページ
+            </footer>
+        </div>
+
+        <!-- Prism JS -->
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-python.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.js"></script>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/copy-to-clipboard/prism-copy-to-clipboard.min.js"></script>
+
+        <!-- ═══════════════════════════════════════════ REACT COMPONENT ═══════════════════════════════════════════ -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            /* ── ツリー可視化 SVG ─────────────────────────────────────────────────── */
+            function TreeSVG({ highlightNodes = [], highlightEdges = [], dimNodes = [] }) {
+                const nodes = {
+                    3: { cx: 135, cy: 36 },
+                    9: { cx: 68, cy: 96 },
+                    20: { cx: 200, cy: 96 },
+                    15: { cx: 165, cy: 156 },
+                    7: { cx: 235, cy: 156 },
+                };
+                const edges = [
+                    { from: 3, to: 9 },
+                    { from: 3, to: 20 },
+                    { from: 20, to: 15 },
+                    { from: 20, to: 7 },
+                ];
+
+                const nodeColor = (val) => {
+                    if (highlightNodes.includes(val))
+                        return { fill: '#d1fae5', stroke: '#059669', textFill: '#065f46' };
+                    if (dimNodes.includes(val))
+                        return { fill: '#f1f5f9', stroke: '#cbd5e1', textFill: '#94a3b8' };
+                    return { fill: '#e0f2fe', stroke: '#0284c7', textFill: '#1e3a5f' };
+                };
+
+                const edgeColor = (from, to) =>
+                    highlightEdges.some((e) => e[0] === from && e[1] === to)
+                        ? '#059669'
+                        : '#94a3b8';
+
+                return (
+                    <svg viewBox="0 0 280 185" style={{ width: '100%', maxWidth: 280 }}>
+                        {edges.map((e) => (
+                            <line
+                                key={`${e.from}-${e.to}`}
+                                x1={nodes[e.from].cx}
+                                y1={nodes[e.from].cy}
+                                x2={nodes[e.to].cx}
+                                y2={nodes[e.to].cy}
+                                stroke={edgeColor(e.from, e.to)}
+                                strokeWidth={
+                                    highlightEdges.some((ed) => ed[0] === e.from && ed[1] === e.to)
+                                        ? 2.5
+                                        : 1.5
+                                }
+                            />
+                        ))}
+                        {Object.entries(nodes).map(([val, pos]) => {
+                            const c = nodeColor(Number(val));
+                            return (
+                                <g key={val}>
+                                    <circle
+                                        cx={pos.cx}
+                                        cy={pos.cy}
+                                        r={22}
+                                        fill={c.fill}
+                                        stroke={c.stroke}
+                                        strokeWidth="2"
+                                    />
+                                    <text
+                                        x={pos.cx}
+                                        y={pos.cy}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="14"
+                                        fontWeight="600"
+                                        fill={c.textFill}
+                                    >
+                                        {val}
+                                    </text>
+                                </g>
+                            );
+                        })}
+                    </svg>
+                );
+            }
+
+            /* ── キュー可視化 ────────────────────────────────────────────────────── */
+            function QueueViz({ items, poppingIndex = -1 }) {
+                if (items.length === 0) {
+                    return (
+                        <div className="mt-2 flex items-center gap-2">
+                            <span className="text-slate-400 text-xs font-mono">queue = []</span>
+                            <span className="text-slate-400 text-xs">（空）</span>
+                        </div>
+                    );
+                }
+                return (
+                    <div className="mt-2">
+                        <div className="text-slate-500 text-xs mb-1">queue（先頭 → 末尾）</div>
+                        <div className="flex flex-wrap gap-2">
+                            {items.map((item, i) => (
+                                <div
+                                    key={i}
+                                    className={[
+                                        'px-3 py-1.5 rounded-lg border-2 text-xs font-mono transition',
+                                        i === poppingIndex
+                                            ? 'bg-amber-100 border-amber-400 text-amber-800'
+                                            : 'bg-sky-50 border-sky-300 text-sky-800',
+                                    ].join(' ')}
+                                >
+                                    (node={item[0]}, depth={item[1]})
+                                </div>
+                            ))}
+                        </div>
+                    </div>
+                );
+            }
+
+            /* ── 変数ステータスパネル ─────────────────────────────────────────────── */
+            function VarPanel({ vars }) {
+                return (
+                    <div className="mt-3 p-3 rounded-xl bg-slate-50 border border-slate-200 font-mono text-xs">
+                        <div className="text-slate-500 mb-2 font-sans text-xs font-semibold">
+                            🔍 現在の変数の状態
+                        </div>
+                        {vars.map(([name, value, color]) => (
+                            <div key={name} className={`${color} leading-6`}>
+                                <span className="text-slate-500">{name}</span> ={' '}
+                                <span className="font-semibold">{value}</span>
+                            </div>
+                        ))}
+                    </div>
+                );
+            }
+
+            /* ── ステップごとのビジュアル ─────────────────────────────────────────── */
+            function StepVisualization({ visual }) {
+                const panels = {
+                    edge_case: (
+                        <div>
+                            <div className="grid grid-cols-2 gap-3 mt-3">
+                                <div className="p-3 rounded-xl bg-red-50 border border-red-200 text-center">
+                                    <div className="text-xs text-red-600 font-semibold mb-1">
+                                        root = None の場合
+                                    </div>
+                                    <div className="font-mono text-sm text-red-700">
+                                        root = null
+                                    </div>
+                                    <div className="mt-2 text-xs text-red-500">→ return 0</div>
+                                </div>
+                                <div className="p-3 rounded-xl bg-emerald-50 border border-emerald-200 text-center">
+                                    <div className="text-xs text-emerald-600 font-semibold mb-1">
+                                        root が存在する場合
+                                    </div>
+                                    <TreeSVG highlightNodes={[3]} dimNodes={[9, 20, 15, 7]} />
+                                    <div className="mt-1 text-xs text-emerald-600">
+                                        → BFS へ進む
+                                    </div>
+                                </div>
+                            </div>
+                            <VarPanel
+                                vars={[
+                                    [
+                                        'root',
+                                        'TreeNode(3)  ← None でないため処理続行',
+                                        'text-emerald-700',
+                                    ],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    queue_init: (
+                        <div>
+                            <TreeSVG highlightNodes={[3]} highlightEdges={[]} />
+                            <QueueViz items={[[3, 1]]} />
+                            <VarPanel
+                                vars={[
+                                    ['queue', 'deque([(node=3, depth=1)])', 'text-sky-700'],
+                                    [
+                                        '',
+                                        '根ノードに深さ 1 を紐付けてキューに入れた',
+                                        'text-slate-500',
+                                    ],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    dequeue: (
+                        <div>
+                            <TreeSVG
+                                highlightNodes={[3]}
+                                highlightEdges={[
+                                    [3, 9],
+                                    [3, 20],
+                                ]}
+                            />
+                            <QueueViz items={[[3, 1]]} poppingIndex={0} />
+                            <div className="mt-2 text-xs text-amber-700 font-semibold">
+                                ↓ popleft() で (node=3, depth=1) を取り出す
+                            </div>
+                            <QueueViz
+                                items={[
+                                    [9, 2],
+                                    [20, 2],
+                                ]}
+                            />
+                            <VarPanel
+                                vars={[
+                                    ['node', 'TreeNode(3)', 'text-amber-700'],
+                                    ['depth', '1', 'text-amber-700'],
+                                    ['', 'node=3 の子 9, 20 をキューへ追加', 'text-slate-500'],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    leaf_check: (
+                        <div>
+                            <TreeSVG
+                                highlightNodes={[9]}
+                                highlightEdges={[[3, 9]]}
+                                dimNodes={[20, 15, 7]}
+                            />
+                            <QueueViz
+                                items={[
+                                    [9, 2],
+                                    [20, 2],
+                                ]}
+                                poppingIndex={0}
+                            />
+                            <div className="mt-2 p-2 rounded-lg bg-emerald-50 border border-emerald-300 text-xs text-emerald-800 font-semibold">
+                                ✅ node=9: left=None, right=None → 葉ノード発見！
+                            </div>
+                            <VarPanel
+                                vars={[
+                                    ['node', 'TreeNode(9)', 'text-emerald-700'],
+                                    ['depth', '2', 'text-emerald-700'],
+                                    ['node.left', 'None', 'text-slate-500'],
+                                    ['node.right', 'None', 'text-slate-500'],
+                                    ['判定', '葉ノード → return depth', 'text-emerald-700'],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    enqueue_children: (
+                        <div>
+                            <TreeSVG
+                                highlightNodes={[3, 9, 20]}
+                                highlightEdges={[
+                                    [3, 9],
+                                    [3, 20],
+                                ]}
+                            />
+                            <div className="mt-2 text-xs text-slate-600 leading-5">
+                                node=3 は葉でない（left=9, right=20
+                                が存在）ため、子ノードをキューに追加します。
+                            </div>
+                            <QueueViz
+                                items={[
+                                    [9, 2],
+                                    [20, 2],
+                                ]}
+                            />
+                            <VarPanel
+                                vars={[
+                                    ['node', 'TreeNode(3)', 'text-slate-600'],
+                                    ['depth', '1', 'text-slate-600'],
+                                    [
+                                        '追加',
+                                        '(node=9, depth=2), (node=20, depth=2)',
+                                        'text-sky-700',
+                                    ],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    result: (
+                        <div>
+                            <TreeSVG
+                                highlightNodes={[3, 9]}
+                                highlightEdges={[[3, 9]]}
+                                dimNodes={[20, 15, 7]}
+                            />
+                            <div className="mt-3 p-3 rounded-xl bg-emerald-100 border-2 border-emerald-400 text-center">
+                                <div className="text-emerald-800 font-bold text-lg">答え: 2</div>
+                                <div className="text-emerald-600 text-xs mt-1">
+                                    根(3) → 葉(9) の経路が最短。ノード数 = 2。
+                                </div>
+                            </div>
+                            <VarPanel
+                                vars={[
+                                    ['node', 'TreeNode(9)', 'text-emerald-700'],
+                                    ['depth', '2', 'text-emerald-700'],
+                                    ['return', '2  ← 最小深さ確定！', 'text-emerald-700'],
+                                ]}
+                            />
+                        </div>
+                    ),
+                };
+                return <div>{panels[visual] || null}</div>;
+            }
+
+            /* ── ステップデータ ───────────────────────────────────────────────────── */
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空の木をチェックする',
+                    desc:
+                        'まず最初に、入力として渡された root が None（空の木）かどうかを確認します。' +
+                        'なぜこれが必要かというと、「葉ノードまでの経路」という概念は木が存在することを前提としており、空の木では深さは定義できないからです。' +
+                        '例：root = None → キューに何も入れられないため、0 を返して即座に終了します。',
+                    visual: 'edge_case',
+                },
+                {
+                    step: 2,
+                    title: 'BFS キューを初期化する',
+                    desc:
+                        'BFS（幅優先探索）を始めるために、deque（両端キュー）に根ノードと深さ1のペアを入れます。' +
+                        '深さを各ノードと一緒にタプルで管理することで、後からノードが何段目にあるかを外部変数なしで追跡できます。' +
+                        '例：root = TreeNode(3) → queue = deque([(TreeNode(3), 1)]) となります。',
+                    visual: 'queue_init',
+                },
+                {
+                    step: 3,
+                    title: 'キューからノードを取り出す',
+                    desc:
+                        'キューの先頭から (node, depth) のペアを popleft() で取り出します。' +
+                        'popleft() は O(1) の定数時間で動作し、常に「最も浅い階層のノード」が取り出される点がポイントです。これが BFS の特徴です。' +
+                        '例：queue=[(3,1),(9,2),(20,2)] → popleft() → node=3, depth=1。残りは [(9,2),(20,2)]。',
+                    visual: 'dequeue',
+                },
+                {
+                    step: 4,
+                    title: '葉ノードかどうかを判定する',
+                    desc:
+                        '取り出したノードが葉（左の子も右の子も持たないノード）かどうかを確認します。' +
+                        'BFS は浅い順に処理するため、最初に葉と判定されたノードが必ず最も浅い葉、つまり最小深さを持ちます。ここで即座に return できます。' +
+                        '例：node=9 → node.left=None, node.right=None → 葉ノード！ → return depth=2。',
+                    visual: 'leaf_check',
+                },
+                {
+                    step: 5,
+                    title: '子ノードをキューに追加する',
+                    desc:
+                        '葉でなかった場合は、存在する子ノードをキューに追加して探索を続けます。' +
+                        'None の子をキューに追加すると後でエラーの原因になるため、追加前に必ず存在チェックをします。' +
+                        '例：node=3 → left=9 あり → (9, 2) を追加; right=20 あり → (20, 2) を追加。',
+                    visual: 'enqueue_children',
+                },
+                {
+                    step: 6,
+                    title: '最小深さを確定して返す',
+                    desc:
+                        'BFS の性質により、キューを処理した順番は必ず「浅い→深い」の順番です。そのため、最初に葉ノードを発見した時点の depth が最小深さになります。' +
+                        'この「最初に葉を見つけたら即 return する早期終了」がこのアルゴリズムの最大の効率化のポイントです。' +
+                        '例：node=9, depth=2 で葉判定 → return 2。答えは 2。',
+                    visual: 'result',
+                },
+            ];
+
+            /* ── メイン React コンポーネント ──────────────────────────────────────── */
+            function StepsApp() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+                const currentStepData = stepsData[activeStep - 1];
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 1800);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8 mt-2">
+                        {/* ── ステップ一覧 ── */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-xl font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((s) => {
+                                    const isActive = activeStep === s.step;
+                                    return (
+                                        <button
+                                            key={s.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-[0.9rem] rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)]'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(s.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {s.step}: {s.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs mt-0.5 line-clamp-2 leading-5">
+                                                {s.desc.substring(0, 55)}…
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* ── アクティブステップ詳細 ── */}
+                        <div>
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                    ← 前のステップ（Step {activeStep - 1}）では{' '}
+                                    <strong>{stepsData[activeStep - 2].title}</strong> を行いました
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)]">
+                                <h3 className="mt-0 text-teal-800 text-base font-bold">
+                                    Step {currentStepData.step}: {currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2 whitespace-pre-wrap">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <div className="mt-4 p-4 rounded-xl border border-slate-200 bg-white">
+                                <div className="text-teal-800 text-xs font-semibold mb-2">
+                                    入力例 [3,9,20,null,null,15,7] での様子
+                                </div>
+                                <StepVisualization visual={currentStepData.visual} />
+                            </div>
+
+                            {/* コントロール */}
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#10b981,#059669)] text-sm"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-slate-700 transition shadow hover:-translate-y-0.5 bg-white border-2 border-slate-200 text-sm"
+                                    onClick={() => {
+                                        setActiveStep(1);
+                                        setIsPlaying(false);
+                                    }}
+                                >
+                                    ↺ Reset
+                                </button>
+                            </div>
+
+                            {activeStep === stepsData.length && (
+                                <div className="mt-4 p-3 rounded-xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('steps-root')).render(<StepsApp />);
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html b/public/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html
new file mode 100644
index 0000000..15eaae8
--- /dev/null
+++ b/public/Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html	
@@ -0,0 +1,1776 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 111 - Minimum Depth of Binary Tree | BFS解説</title>
+        <script src="/vendor/react/react.development.js"></script>
+        <script src="/vendor/react-dom/react-dom.development.js"></script>
+        <script src="/vendor/babel/babel.min.js"></script>
+        <script src="/vendor/tailwindcss/script.js"></script>
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/themes/prism-tomorrow.css"
+        />
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.css"
+        />
+        <link
+            rel="stylesheet"
+            href="/vendor/prismjs/plugins/toolbar/prism-toolbar.css"
+        />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Inter', sans-serif;
+                background: linear-gradient(135deg, #f0fdf4 0%, #e0f2fe 100%);
+                min-height: 100vh;
+            }
+            code,
+            pre {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            pre[class*='language-'] {
+                border-radius: 0.75rem;
+                font-size: 0.82rem;
+            }
+            .code-toolbar > .toolbar .toolbar-item a,
+            .code-toolbar > .toolbar .toolbar-item button,
+            .code-toolbar > .toolbar .toolbar-item span {
+                background: #10b981 !important;
+                color: white !important;
+                border-radius: 6px !important;
+                padding: 3px 10px !important;
+                font-size: 12px !important;
+                border: none !important;
+                cursor: pointer !important;
+                box-shadow: none !important;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+        </style>
+    </head>
+    <body class="p-4 md:p-8">
+        <div class="max-w-4xl mx-auto">
+            <!-- ═══════════════════════════════════════════ HEADER ═══════════════════════════════════════════ -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.12)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex items-center gap-3 mb-2 flex-wrap">
+                    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >LeetCode 111</span
+                    >
+                    <span class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >Easy</span
+                    >
+                    <span class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >BFS</span
+                    >
+                </div>
+                <h1 class="text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Minimum Depth of Binary Tree
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    BFS（幅優先探索）による O(n) 実装
+                </p>
+                <p
+                    class="mt-3 text-base text-teal-800 bg-white/60 rounded-xl px-4 py-2 inline-block"
+                >
+                    💡
+                    一言で言うと：「根ノードから最も近い葉ノードまでの最短経路のノード数を求める問題」
+                </p>
+                <nav class="flex flex-wrap gap-3 mt-6">
+                    <a
+                        href="#overview"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-lg border-2 border-slate-200 bg-white transition hover:shadow-[0_6px_16px_rgba(15,118,110,0.20)] hover:-translate-y-0.5 hover:bg-[linear-gradient(180deg,#e8fff6,#c8f1e1)] hover:border-teal-600 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ═══════════════════════════════════════════ OVERVIEW ═══════════════════════════════════════════ -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="mb-5 p-4 rounded-xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-semibold text-base">
+                        💡
+                        この問題を一言で言うと：「根ノードから最も近い葉ノードまでの最短経路のノード数を返す問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2">
+                        「最小深さ」とは、木の根（一番上）から出発して、最初に到達できる葉（子を持たないノード）までのノード数のことです。深さは根を1として数えます。葉ノードとは、左の子も右の子もどちらも存在しないノードのことです。
+                    </p>
+                </div>
+
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-semibold text-sm mb-2">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-600 text-sm space-y-2 list-disc list-inside">
+                        <li>
+                            <strong>「片側だけに子があるノード」が罠になる：</strong
+                            >左の子がない＝葉、ではありません。たとえば右の子だけを持つノードは葉ではなく、右へ続く経路がある「中間ノード」です。例2（[2,null,3,null,4,null,5,null,6]）がその典型で、最小深さはなんと
+                            5 になります。
+                        </li>
+                        <li>
+                            <strong>DFS（深さ優先）では最短を保証できない：</strong>DFS
+                            は「葉に到達するまで一方向に潜り続ける」性質があるため、偶然最初に見つかった葉が最短とは限りません。BFS
+                            なら浅いノードから順番に調べるので、最初に見つかった葉が必ず最短です。
+                        </li>
+                    </ul>
+                </div>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-6">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono">O(n)</div>
+                        <div class="text-xs mt-1">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono">O(w)</div>
+                        <div class="text-xs mt-1">空間計算量 (w=最大幅)</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono">BFS</div>
+                        <div class="text-xs mt-1">アルゴリズム</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">deque</div>
+                        <div class="text-xs mt-1">使用データ構造</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+                    <div class="p-4 rounded-xl bg-slate-50 border border-slate-200">
+                        <p class="font-semibold text-teal-800 text-sm mb-3">例1: 通常の二分木</p>
+                        <pre class="text-xs font-mono text-slate-700 leading-6 mb-0">
+入力: root = [3,9,20,null,null,15,7]
+
+      3
+     / \
+    9  20
+       / \
+      15   7
+
+出力: 2</pre
+                        >
+                        <p class="text-slate-500 text-xs mt-2 pt-2 border-t border-slate-200">
+                            根(3)→左の子(9)
+                            の経路が長さ2で最短。ノード9は左も右も子がない「葉」のため、深さ2が答えになります。
+                        </p>
+                    </div>
+                    <div class="p-4 rounded-xl bg-slate-50 border border-slate-200">
+                        <p class="font-semibold text-teal-800 text-sm mb-3">
+                            例2: 一方向にだけ伸びる木
+                        </p>
+                        <pre class="text-xs font-mono text-slate-700 leading-6 mb-0">
+入力: root = [2,null,3,null,4,null,5,null,6]
+
+2
+ \
+  3
+   \
+    4
+     \
+      5
+       \
+        6   ← 唯一の葉
+
+出力: 5</pre
+                        >
+                        <p class="text-slate-500 text-xs mt-2 pt-2 border-t border-slate-200">
+                            右方向にのみ子があり、唯一の葉はノード6。葉までの距離が5なのでその深さが答えです。
+                        </p>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ STEPS (React root) ═══════════════════════════════════════════ -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ CODE ═══════════════════════════════════════════ -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-4 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-1 list-decimal list-inside">
+                        <li>エッジケース処理：root が None（空の木）なら即座に 0 を返す</li>
+                        <li>BFS キューを初期化：deque に (根ノード, 深さ=1) のペアを入れる</li>
+                        <li>キューが空になるまで繰り返す：浅い順にノードを一つずつ処理する</li>
+                        <li>
+                            葉ノードに到達したら深さを返す（BFS の特性で、最初の葉が必ず最短経路）
+                        </li>
+                    </ol>
+                </div>
+
+                <pre class="line-numbers"><code class="language-python">from typing import Optional
+from collections import deque
+
+
+class Solution:
+    def minDepth(self, root: Optional[TreeNode]) -> int:
+        # ─────────────────────────────────────
+        # エッジケース: 空の木 → 深さ 0 を返す
+        # 根がなければ「葉までの道」自体が存在しない
+        # ─────────────────────────────────────
+        if root is None:
+            return 0
+
+        # ─────────────────────────────────────
+        # BFS キューを初期化する
+        # deque の popleft() は O(1) ← list より効率的
+        # タプル (ノード, 現在の深さ) でペアを管理する
+        # ─────────────────────────────────────
+        queue: deque = deque()
+        queue.append((root, 1))   # 根ノードは深さ 1 からスタート
+
+        while queue:
+            # popleft() = FIFO（先入れ先出し）→ 浅い順に処理
+            node, depth = queue.popleft()
+
+            # ─────────────────────────────────
+            # 葉ノード判定: 左も右も子がない = 葉
+            # BFS は浅い順なので、最初の葉 = 最小深さ
+            # ─────────────────────────────────
+            if node.left is None and node.right is None:
+                return depth      # 最小深さ確定！
+
+            # 子ノードは存在する場合のみキューに追加
+            if node.left is not None:
+                queue.append((node.left,  depth + 1))
+            if node.right is not None:
+                queue.append((node.right, depth + 1))
+
+        return 0  # 有効な木なら通常ここに到達しない</code></pre>
+
+                <div class="mt-4 p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        ▶ 入力例 [3,9,20,null,null,15,7] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-7 overflow-x-auto whitespace-pre"
+                    >
+初期状態: queue = [(node=3, depth=1)]
+
+反復 1: pop → (node=3, depth=1)
+   左の子: 9 あり, 右の子: 20 あり → 葉ではない
+   → queue に (node=9, depth=2) と (node=20, depth=2) を追加
+   → queue = [(node=9, depth=2), (node=20, depth=2)]
+
+反復 2: pop → (node=9, depth=2)
+   左の子: None, 右の子: None → 🌿 葉ノード発見！
+   → return 2   ✅ 答え: 2（探索終了）
+
+※ node=20 はキューに残ったままですが、葉を見つけた時点で即 return
+   するためこれ以上処理は行われません。</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ DIAGRAM ═══════════════════════════════════════════ -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <div class="mb-5 p-4 rounded-xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-semibold text-sm mb-3">
+                        🗺️ フローチャートの読み方
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700">
+                        <div class="flex items-center gap-2">
+                            <svg width="34" height="22">
+                                <ellipse
+                                    cx="17"
+                                    cy="11"
+                                    rx="16"
+                                    ry="10"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="34" height="22">
+                                <rect
+                                    x="1"
+                                    y="3"
+                                    width="32"
+                                    height="16"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="34" height="22">
+                                <polygon
+                                    points="17,2 33,11 17,20 1,11"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 flex-wrap gap-y-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500"></span
+                            ><span class="mr-2">緑＝はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-400"></span
+                            ><span>赤＝いいえ</span>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-5 overflow-x-auto">
+                    <!--
+        viewBox設計:
+          幅: 560px, 中央 x=280
+          主フロー rect: x=70, w=380 (右端 x=450)
+          ひし形 half-w=120: 左端x=160, 右端x=400
+          サイドボックス: x=405, w=110 (右端x=515)
+          サイドライン x=460 (サイドボックス中心)
+          ループ矢印: 左端 x=38
+          終了楕円: cy=895
+          viewBox高さ: 920
+      -->
+                    <svg
+                        viewBox="0 0 560 940"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Minimum Depth of Binary Tree BFS flowchart"
+                    >
+                        <defs>
+                            <marker
+                                id="fc-arrow"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#64748b" />
+                            </marker>
+                            <marker
+                                id="fc-arrowGreen"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#059669" />
+                            </marker>
+                            <marker
+                                id="fc-arrowRed"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#ef4444" />
+                            </marker>
+                            <marker
+                                id="fc-arrowPurple"
+                                markerWidth="10"
+                                markerHeight="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                markerUnits="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#a855f7" />
+                            </marker>
+                        </defs>
+
+                        <!-- ── Node 1: 開始 ── cy=50, ry=26, bottom=76 -->
+                        <ellipse
+                            cx="280"
+                            cy="50"
+                            rx="72"
+                            ry="26"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="54"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="15"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            開始
+                        </text>
+
+                        <!-- arrow 76→103 -->
+                        <line
+                            x1="280"
+                            y1="76"
+                            x2="280"
+                            y2="103"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 2: root is None? Diamond ── center(280,148), ±120 wide, ±48 tall -->
+                        <!-- points: top(280,100), right(400,148), bottom(280,196), left(160,148) -->
+                        <polygon
+                            points="280,100 400,148 280,196 160,148"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="143"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            root is None ?
+                        </text>
+                        <text
+                            x="280"
+                            y="160"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            （木が空かどうか）
+                        </text>
+
+                        <!-- "はい" right → side box A -->
+                        <text x="405" y="137" font-size="11" fill="#059669" font-weight="500">
+                            はい
+                        </text>
+                        <line
+                            x1="400"
+                            y1="148"
+                            x2="405"
+                            y2="148"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- Side Box A: "return 0" rect x=405, y=128, w=110, h=40 -->
+                        <rect
+                            x="405"
+                            y="128"
+                            width="110"
+                            height="40"
+                            rx="6"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="460"
+                            y="144"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            0 を返す
+                        </text>
+                        <text
+                            x="460"
+                            y="159"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="10"
+                            fill="#065f46"
+                        >
+                            return 0
+                        </text>
+
+                        <!-- [FIX] Box A → 右スパイン接続: 右端(515,148)→スパイン(545,148) -->
+                        <line
+                            x1="515"
+                            y1="148"
+                            x2="545"
+                            y2="148"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- "いいえ" down → Node 3 -->
+                        <text x="294" y="215" font-size="11" fill="#ef4444" font-weight="500">
+                            いいえ
+                        </text>
+                        <line
+                            x1="280"
+                            y1="196"
+                            x2="280"
+                            y2="235"
+                            stroke="#ef4444"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- ── Node 3: BFSキュー初期化 ── rect y=235, h=56, bottom=291 -->
+                        <rect
+                            x="70"
+                            y="235"
+                            width="380"
+                            height="56"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="258"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            BFS キューを初期化
+                        </text>
+                        <text
+                            x="280"
+                            y="276"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            queue = deque([(root, 1)])
+                        </text>
+
+                        <!-- arrow 291→318 -->
+                        <line
+                            x1="280"
+                            y1="291"
+                            x2="280"
+                            y2="318"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 4: ノード取出し ── rect y=318, h=56, center-y=346, bottom=374 -->
+                        <rect
+                            x="70"
+                            y="318"
+                            width="380"
+                            height="56"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="341"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            キューからノードを取り出す
+                        </text>
+                        <text
+                            x="280"
+                            y="359"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            node, depth = queue.popleft()
+                        </text>
+
+                        <!-- arrow 374→402 -->
+                        <line
+                            x1="280"
+                            y1="374"
+                            x2="280"
+                            y2="402"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ── Node 5: 葉ノード? Diamond ── center(280,452), ±120 wide, ±50 tall -->
+                        <polygon
+                            points="280,402 400,452 280,502 160,452"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="446"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#78350f"
+                        >
+                            葉ノード?
+                        </text>
+                        <text
+                            x="280"
+                            y="464"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#92400e"
+                        >
+                            left==None and right==None
+                        </text>
+
+                        <!-- "はい" right → Side Box B -->
+                        <text x="405" y="442" font-size="11" fill="#059669" font-weight="500">
+                            はい
+                        </text>
+                        <line
+                            x1="400"
+                            y1="452"
+                            x2="405"
+                            y2="452"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- Side Box B: "return depth" x=405, y=432, w=110, h=40 -->
+                        <rect
+                            x="405"
+                            y="432"
+                            width="110"
+                            height="40"
+                            rx="6"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="460"
+                            y="448"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            depth を返す
+                        </text>
+                        <text
+                            x="460"
+                            y="463"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="10"
+                            fill="#065f46"
+                        >
+                            return depth
+                        </text>
+
+                        <!-- [FIX] Box B → 右スパイン接続: 右端(515,452)→スパイン(545,452) -->
+                        <line
+                            x1="515"
+                            y1="452"
+                            x2="545"
+                            y2="452"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- [FIX] 右スパイン: x=545 の単一縦線 — Box A出口(545,148)から終了レベル(545,895)まで -->
+                        <!-- Box A exit と Box B exit の両方がここに合流し、終了ノードへ向かう。衝突なし。 -->
+                        <line
+                            x1="545"
+                            y1="148"
+                            x2="545"
+                            y2="895"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+
+                        <!-- [FIX] スパイン → 終了 右端へ水平矢印: (545,895)→(353,895) -->
+                        <!-- 終了楕円 cx=280 rx=72 → 右端 x=352。矢印は左向きに収束する。 -->
+                        <line
+                            x1="545"
+                            y1="895"
+                            x2="353"
+                            y2="895"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+
+                        <!-- "いいえ" down → Node 6 -->
+                        <text x="294" y="521" font-size="11" fill="#ef4444" font-weight="500">
+                            いいえ
+                        </text>
+                        <line
+                            x1="280"
+                            y1="502"
+                            x2="280"
+                            y2="540"
+                            stroke="#ef4444"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- ── Node 6: 子をキューに追加 ── rect y=540, h=56, bottom=596 -->
+                        <rect
+                            x="70"
+                            y="540"
+                            width="380"
+                            height="56"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="563"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="600"
+                            fill="#1e3a5f"
+                        >
+                            子ノードをキューに追加
+                        </text>
+                        <text
+                            x="280"
+                            y="581"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1e40af"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            queue.append((child, depth + 1))
+                        </text>
+
+                        <!-- ── ループ矢印: Node 6下端 → 左 → 上 → Node 4左端 ── -->
+                        <line
+                            x1="280"
+                            y1="596"
+                            x2="280"
+                            y2="626"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="280"
+                            y1="626"
+                            x2="38"
+                            y2="626"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="38"
+                            y1="626"
+                            x2="38"
+                            y2="346"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                        />
+                        <line
+                            x1="38"
+                            y1="346"
+                            x2="70"
+                            y2="346"
+                            stroke="#a855f7"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowPurple)"
+                        />
+                        <text
+                            x="22"
+                            y="490"
+                            font-size="11"
+                            fill="#a855f7"
+                            text-anchor="middle"
+                            font-weight="500"
+                        >
+                            ル
+                        </text>
+                        <text
+                            x="22"
+                            y="504"
+                            font-size="11"
+                            fill="#a855f7"
+                            text-anchor="middle"
+                            font-weight="500"
+                        >
+                            ー
+                        </text>
+                        <text
+                            x="22"
+                            y="518"
+                            font-size="11"
+                            fill="#a855f7"
+                            text-anchor="middle"
+                            font-weight="500"
+                        >
+                            プ
+                        </text>
+
+                        <!-- ── Node 7: 終了 ── cy=895, ry=26, bottom=921 → viewBox高さ940で収容 -->
+                        <ellipse
+                            cx="280"
+                            cy="895"
+                            rx="72"
+                            ry="26"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="899"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="15"
+                            font-weight="600"
+                            fill="#065f46"
+                        >
+                            終了
+                        </text>
+                    </svg>
+                </div>
+
+                <div class="mt-5 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-semibold text-sm mb-2">
+                        🔎 入力例 [3,9,20,null,null,15,7] でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→ root = TreeNode(3) なので None ではない → 「いいえ」の経路へ
+                        </li>
+                        <li>「BFS キュー初期化」→ queue = [(node=3, depth=1)] にセット</li>
+                        <li>「キューから取出し」→ node=3, depth=1 を popleft で取り出す</li>
+                        <li>
+                            「葉ノード?」→ node=3 の left=9, right=20 があるので「いいえ」→
+                            子をキューに追加
+                        </li>
+                        <li>
+                            「子をキューに追加」→ queue = [(node=9, depth=2), (node=20, depth=2)]
+                            になりループ
+                        </li>
+                        <li>「キューから取出し」→ node=9, depth=2 を取り出す</li>
+                        <li>
+                            「葉ノード?」→ node=9 の left=None, right=None → 「はい」→ depth=2
+                            を返す
+                        </li>
+                        <li>「終了」→ 答え 2 を返して処理完了</li>
+                    </ol>
+                </div>
+
+                <p class="mt-5 text-slate-700 leading-8 text-sm">
+                    <strong class="text-base text-teal-800">フローの要点：</strong><br />
+                    BFS
+                    はキューを使って「浅いノードから順番に」処理します。ループ（紫の矢印）は次のノードを処理するためにキューへ戻ることを表しています。右側の緑の線（サイドライン）は「条件を満たしたので早期リターン」する経路です。<code
+                        class="bg-slate-100 px-1 rounded text-xs font-mono"
+                        >root is None</code
+                    >
+                    のときは 0 を、葉ノードを見つけたときはそのときの
+                    <code class="bg-slate-100 px-1 rounded text-xs font-mono">depth</code>
+                    を即座に返します。
+                </p>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ COMPLEXITY ═══════════════════════════════════════════ -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <div class="mb-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-semibold text-sm mb-3">
+                        📖 Big-O 記法の読み方（入力サイズ n が大きくなると処理時間がどう変わるか）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-2 text-xs">
+                        <div class="text-center p-3 rounded-lg bg-emerald-100 text-emerald-800">
+                            <div class="font-bold font-mono text-base mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-sky-100 text-sky-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-amber-100 text-amber-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n log n)</div>
+                            <div class="leading-5">
+                                n より少し多い<br /><span class="text-amber-600"
+                                    >例：マージソート</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-red-100 text-red-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-red-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto mb-4">
+                    <table class="w-full border-collapse text-sm">
+                        <thead>
+                            <tr class="bg-teal-50">
+                                <th
+                                    class="text-left p-3 border border-slate-200 text-teal-800 font-semibold"
+                                >
+                                    種別
+                                </th>
+                                <th
+                                    class="text-center p-3 border border-slate-200 text-teal-800 font-semibold"
+                                >
+                                    記法
+                                </th>
+                                <th
+                                    class="text-left p-3 border border-slate-200 text-teal-800 font-semibold"
+                                >
+                                    変数の意味
+                                </th>
+                                <th
+                                    class="text-left p-3 border border-slate-200 text-teal-800 font-semibold"
+                                >
+                                    ケース
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="hover:bg-slate-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    時間計算量
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <code
+                                        class="bg-emerald-100 text-emerald-800 px-2 py-0.5 rounded font-mono text-sm"
+                                        >O(n)</code
+                                    >
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600">
+                                    n = 木のノード総数
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600">
+                                    最悪ケース（全ノード訪問）
+                                </td>
+                            </tr>
+                            <tr class="hover:bg-slate-50 bg-slate-25">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    空間計算量
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <code
+                                        class="bg-sky-100 text-sky-800 px-2 py-0.5 rounded font-mono text-sm"
+                                        >O(w)</code
+                                    >
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600">
+                                    w = 木の最大幅（1段のノード最大数）
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600">
+                                    完全二分木では O(n/2) ≈ O(n)
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <div class="p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-semibold text-sm mb-2">
+                        🔍 なぜこの計算量になるのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        <strong>時間 O(n)：</strong
+                        >最悪のケースでは、葉が最後の1個で木の最深部にある状況です（例2のような一方向に伸びる木）。この場合、全
+                        n ノードをキューから1回ずつ取り出して処理するため、処理回数は n
+                        に比例します。ただし最良のケースは根ノード自体が葉（n=1）のときで、即座に
+                        O(1) で返ります。<br /><br /><strong>空間 O(w)：</strong
+                        >キューには「同じ深さのノード」が同時に蓄積されます。最もノードが密集する段（=
+                        木の最大幅 w）のとき、キューのサイズが最大になります。完全二分木の最下段では
+                        w ≈ n/2 となり、事実上 O(n) と等価です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════ GLOSSARY ═══════════════════════════════════════════ -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたら参照してください。
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> BFS（幅優先探索）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Breadth-First Search
+                            の略。木やグラフを「根に近い順」「浅い階層から順番に」探索するアルゴリズムです。「うずまきのように外側から内側に向かって広がる」イメージに例えられます。キュー（待ち行列）を使って実装し、最短経路の発見に特に適しています。対義語は
+                            DFS（深さ優先探索）。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> deque（デク）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            double-ended queue（両端キュー）の略。Python の
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >collections.deque</code
+                            >
+                            が提供します。先頭と末尾の両端から O(1)
+                            の定数時間で要素の追加・取り出しができます。通常の
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">list</code> の
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">pop(0)</code>
+                            は O(n) のコストがかかるため、BFS には deque の使用が必須です。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            葉ノード（リーフノード）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            左の子も右の子も持たないノードのことです。木の末端に位置します。「葉」という名前は、木の葉っぱが枝の末端にあることに由来します。判定条件は
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >node.left is None and node.right is None</code
+                            >
+                            です。注意点：左右どちらか一方の子しか持たないノードは葉ではありません。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> キュー（待ち行列）/
+                            FIFO
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            FIFO（First In, First Out =
+                            先入れ先出し）の原則に従うデータ構造です。コンビニのレジ待ちの列と同じで、先に並んだ人が先に処理されます。BFS
+                            では「浅いノードを先に処理する」ために必須です。<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >append()</code
+                            >
+                            で末尾に追加し、<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >popleft()</code
+                            >
+                            で先頭から取り出します。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            根ノード（ルートノード）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木の最上位に位置する唯一のノードです。親ノードを持ちません。木の探索はここから開始します。深さの数え方では、根ノードの深さを
+                            1 として数えます（問題によっては 0 から数えることもあります）。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span> 時間計算量 / 空間計算量
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <strong>時間計算量</strong>：入力サイズ n
+                            が増えたときに、処理ステップ数がどのくらい増えるかの指標です。O(n) は「n
+                            が2倍になると処理も約2倍」を意味します。<br />
+                            <strong>空間計算量</strong
+                            >：アルゴリズムが使用するメモリ（RAM）の量の指標です。O(w)
+                            はキューに同時に蓄積されるノード数（= 木の最大幅
+                            w）に比例することを示しています。
+                        </div>
+                    </details>
+
+                    <details class="rounded-xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-semibold text-teal-800 cursor-pointer px-5 py-3 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="text-emerald-500 text-xs">▶</span>
+                            二分木（バイナリーツリー）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            各ノードが最大2つの子（左の子・右の子）を持つ木構造のデータ構造です。「二分」とは「2つに分かれる」という意味で、各ノードで枝が最大2本に分岐します。LeetCode
+                            では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >TreeNode</code
+                            >
+                            クラスが使われ、<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >val</code
+                            >（値）・<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >left</code
+                            >（左の子）・<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >right</code
+                            >（右の子）の3つの属性を持ちます。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <!-- Footer -->
+            <footer class="text-center text-slate-400 text-xs py-6">
+                LeetCode 111 — Minimum Depth of Binary Tree | BFS 解説ページ
+            </footer>
+        </div>
+
+        <!-- Prism JS -->
+        <script src="/vendor/prismjs/prism.js"></script>
+        <script src="/vendor/prismjs/components/prism-python.min.js"></script>
+        <script src="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.js"></script>
+        <script src="/vendor/prismjs/plugins/toolbar/prism-toolbar.js"></script>
+        <script src="/vendor/prismjs/plugins/copy-to-clipboard/prism-copy-to-clipboard.js"></script>
+
+        <!-- ═══════════════════════════════════════════ REACT COMPONENT ═══════════════════════════════════════════ -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            /* ── ツリー可視化 SVG ─────────────────────────────────────────────────── */
+            function TreeSVG({ highlightNodes = [], highlightEdges = [], dimNodes = [] }) {
+                const nodes = {
+                    3: { cx: 135, cy: 36 },
+                    9: { cx: 68, cy: 96 },
+                    20: { cx: 200, cy: 96 },
+                    15: { cx: 165, cy: 156 },
+                    7: { cx: 235, cy: 156 },
+                };
+                const edges = [
+                    { from: 3, to: 9 },
+                    { from: 3, to: 20 },
+                    { from: 20, to: 15 },
+                    { from: 20, to: 7 },
+                ];
+
+                const nodeColor = (val) => {
+                    if (highlightNodes.includes(val))
+                        return { fill: '#d1fae5', stroke: '#059669', textFill: '#065f46' };
+                    if (dimNodes.includes(val))
+                        return { fill: '#f1f5f9', stroke: '#cbd5e1', textFill: '#94a3b8' };
+                    return { fill: '#e0f2fe', stroke: '#0284c7', textFill: '#1e3a5f' };
+                };
+
+                const edgeColor = (from, to) =>
+                    highlightEdges.some((e) => e[0] === from && e[1] === to)
+                        ? '#059669'
+                        : '#94a3b8';
+
+                return (
+                    <svg viewBox="0 0 280 185" style={{ width: '100%', maxWidth: 280 }}>
+                        {edges.map((e) => (
+                            <line
+                                key={`${e.from}-${e.to}`}
+                                x1={nodes[e.from].cx}
+                                y1={nodes[e.from].cy}
+                                x2={nodes[e.to].cx}
+                                y2={nodes[e.to].cy}
+                                stroke={edgeColor(e.from, e.to)}
+                                strokeWidth={
+                                    highlightEdges.some((ed) => ed[0] === e.from && ed[1] === e.to)
+                                        ? 2.5
+                                        : 1.5
+                                }
+                            />
+                        ))}
+                        {Object.entries(nodes).map(([val, pos]) => {
+                            const c = nodeColor(Number(val));
+                            return (
+                                <g key={val}>
+                                    <circle
+                                        cx={pos.cx}
+                                        cy={pos.cy}
+                                        r={22}
+                                        fill={c.fill}
+                                        stroke={c.stroke}
+                                        strokeWidth="2"
+                                    />
+                                    <text
+                                        x={pos.cx}
+                                        y={pos.cy}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="14"
+                                        fontWeight="600"
+                                        fill={c.textFill}
+                                    >
+                                        {val}
+                                    </text>
+                                </g>
+                            );
+                        })}
+                    </svg>
+                );
+            }
+
+            /* ── キュー可視化 ────────────────────────────────────────────────────── */
+            function QueueViz({ items, poppingIndex = -1 }) {
+                if (items.length === 0) {
+                    return (
+                        <div className="mt-2 flex items-center gap-2">
+                            <span className="text-slate-400 text-xs font-mono">queue = []</span>
+                            <span className="text-slate-400 text-xs">（空）</span>
+                        </div>
+                    );
+                }
+                return (
+                    <div className="mt-2">
+                        <div className="text-slate-500 text-xs mb-1">queue（先頭 → 末尾）</div>
+                        <div className="flex flex-wrap gap-2">
+                            {items.map((item, i) => (
+                                <div
+                                    key={i}
+                                    className={[
+                                        'px-3 py-1.5 rounded-lg border-2 text-xs font-mono transition',
+                                        i === poppingIndex
+                                            ? 'bg-amber-100 border-amber-400 text-amber-800'
+                                            : 'bg-sky-50 border-sky-300 text-sky-800',
+                                    ].join(' ')}
+                                >
+                                    (node={item[0]}, depth={item[1]})
+                                </div>
+                            ))}
+                        </div>
+                    </div>
+                );
+            }
+
+            /* ── 変数ステータスパネル ─────────────────────────────────────────────── */
+            function VarPanel({ vars }) {
+                return (
+                    <div className="mt-3 p-3 rounded-xl bg-slate-50 border border-slate-200 font-mono text-xs">
+                        <div className="text-slate-500 mb-2 font-sans text-xs font-semibold">
+                            🔍 現在の変数の状態
+                        </div>
+                        {vars.map(([name, value, color]) => (
+                            <div key={name} className={`${color} leading-6`}>
+                                <span className="text-slate-500">{name}</span> ={' '}
+                                <span className="font-semibold">{value}</span>
+                            </div>
+                        ))}
+                    </div>
+                );
+            }
+
+            /* ── ステップごとのビジュアル ─────────────────────────────────────────── */
+            function StepVisualization({ visual }) {
+                const panels = {
+                    edge_case: (
+                        <div>
+                            <div className="grid grid-cols-2 gap-3 mt-3">
+                                <div className="p-3 rounded-xl bg-red-50 border border-red-200 text-center">
+                                    <div className="text-xs text-red-600 font-semibold mb-1">
+                                        root = None の場合
+                                    </div>
+                                    <div className="font-mono text-sm text-red-700">
+                                        root = null
+                                    </div>
+                                    <div className="mt-2 text-xs text-red-500">→ return 0</div>
+                                </div>
+                                <div className="p-3 rounded-xl bg-emerald-50 border border-emerald-200 text-center">
+                                    <div className="text-xs text-emerald-600 font-semibold mb-1">
+                                        root が存在する場合
+                                    </div>
+                                    <TreeSVG highlightNodes={[3]} dimNodes={[9, 20, 15, 7]} />
+                                    <div className="mt-1 text-xs text-emerald-600">
+                                        → BFS へ進む
+                                    </div>
+                                </div>
+                            </div>
+                            <VarPanel
+                                vars={[
+                                    [
+                                        'root',
+                                        'TreeNode(3)  ← None でないため処理続行',
+                                        'text-emerald-700',
+                                    ],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    queue_init: (
+                        <div>
+                            <TreeSVG highlightNodes={[3]} highlightEdges={[]} />
+                            <QueueViz items={[[3, 1]]} />
+                            <VarPanel
+                                vars={[
+                                    ['queue', 'deque([(node=3, depth=1)])', 'text-sky-700'],
+                                    [
+                                        '',
+                                        '根ノードに深さ 1 を紐付けてキューに入れた',
+                                        'text-slate-500',
+                                    ],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    dequeue: (
+                        <div>
+                            <TreeSVG
+                                highlightNodes={[3]}
+                                highlightEdges={[
+                                    [3, 9],
+                                    [3, 20],
+                                ]}
+                            />
+                            <QueueViz items={[[3, 1]]} poppingIndex={0} />
+                            <div className="mt-2 text-xs text-amber-700 font-semibold">
+                                ↓ popleft() で (node=3, depth=1) を取り出す
+                            </div>
+                            <QueueViz
+                                items={[
+                                    [9, 2],
+                                    [20, 2],
+                                ]}
+                            />
+                            <VarPanel
+                                vars={[
+                                    ['node', 'TreeNode(3)', 'text-amber-700'],
+                                    ['depth', '1', 'text-amber-700'],
+                                    ['', 'node=3 の子 9, 20 をキューへ追加', 'text-slate-500'],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    leaf_check: (
+                        <div>
+                            <TreeSVG
+                                highlightNodes={[9]}
+                                highlightEdges={[[3, 9]]}
+                                dimNodes={[20, 15, 7]}
+                            />
+                            <QueueViz
+                                items={[
+                                    [9, 2],
+                                    [20, 2],
+                                ]}
+                                poppingIndex={0}
+                            />
+                            <div className="mt-2 p-2 rounded-lg bg-emerald-50 border border-emerald-300 text-xs text-emerald-800 font-semibold">
+                                ✅ node=9: left=None, right=None → 葉ノード発見！
+                            </div>
+                            <VarPanel
+                                vars={[
+                                    ['node', 'TreeNode(9)', 'text-emerald-700'],
+                                    ['depth', '2', 'text-emerald-700'],
+                                    ['node.left', 'None', 'text-slate-500'],
+                                    ['node.right', 'None', 'text-slate-500'],
+                                    ['判定', '葉ノード → return depth', 'text-emerald-700'],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    enqueue_children: (
+                        <div>
+                            <TreeSVG
+                                highlightNodes={[3, 9, 20]}
+                                highlightEdges={[
+                                    [3, 9],
+                                    [3, 20],
+                                ]}
+                            />
+                            <div className="mt-2 text-xs text-slate-600 leading-5">
+                                node=3 は葉でない（left=9, right=20
+                                が存在）ため、子ノードをキューに追加します。
+                            </div>
+                            <QueueViz
+                                items={[
+                                    [9, 2],
+                                    [20, 2],
+                                ]}
+                            />
+                            <VarPanel
+                                vars={[
+                                    ['node', 'TreeNode(3)', 'text-slate-600'],
+                                    ['depth', '1', 'text-slate-600'],
+                                    [
+                                        '追加',
+                                        '(node=9, depth=2), (node=20, depth=2)',
+                                        'text-sky-700',
+                                    ],
+                                ]}
+                            />
+                        </div>
+                    ),
+                    result: (
+                        <div>
+                            <TreeSVG
+                                highlightNodes={[3, 9]}
+                                highlightEdges={[[3, 9]]}
+                                dimNodes={[20, 15, 7]}
+                            />
+                            <div className="mt-3 p-3 rounded-xl bg-emerald-100 border-2 border-emerald-400 text-center">
+                                <div className="text-emerald-800 font-bold text-lg">答え: 2</div>
+                                <div className="text-emerald-600 text-xs mt-1">
+                                    根(3) → 葉(9) の経路が最短。ノード数 = 2。
+                                </div>
+                            </div>
+                            <VarPanel
+                                vars={[
+                                    ['node', 'TreeNode(9)', 'text-emerald-700'],
+                                    ['depth', '2', 'text-emerald-700'],
+                                    ['return', '2  ← 最小深さ確定！', 'text-emerald-700'],
+                                ]}
+                            />
+                        </div>
+                    ),
+                };
+                return <div>{panels[visual] || null}</div>;
+            }
+
+            /* ── ステップデータ ───────────────────────────────────────────────────── */
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空の木をチェックする',
+                    desc:
+                        'まず最初に、入力として渡された root が None（空の木）かどうかを確認します。' +
+                        'なぜこれが必要かというと、「葉ノードまでの経路」という概念は木が存在することを前提としており、空の木では深さは定義できないからです。' +
+                        '例：root = None → キューに何も入れられないため、0 を返して即座に終了します。',
+                    visual: 'edge_case',
+                },
+                {
+                    step: 2,
+                    title: 'BFS キューを初期化する',
+                    desc:
+                        'BFS（幅優先探索）を始めるために、deque（両端キュー）に根ノードと深さ1のペアを入れます。' +
+                        '深さを各ノードと一緒にタプルで管理することで、後からノードが何段目にあるかを外部変数なしで追跡できます。' +
+                        '例：root = TreeNode(3) → queue = deque([(TreeNode(3), 1)]) となります。',
+                    visual: 'queue_init',
+                },
+                {
+                    step: 3,
+                    title: 'キューからノードを取り出す',
+                    desc:
+                        'キューの先頭から (node, depth) のペアを popleft() で取り出します。' +
+                        'popleft() は O(1) の定数時間で動作し、常に「最も浅い階層のノード」が取り出される点がポイントです。これが BFS の特徴です。' +
+                        '例：queue=[(3,1),(9,2),(20,2)] → popleft() → node=3, depth=1。残りは [(9,2),(20,2)]。',
+                    visual: 'dequeue',
+                },
+                {
+                    step: 4,
+                    title: '葉ノードかどうかを判定する',
+                    desc:
+                        '取り出したノードが葉（左の子も右の子も持たないノード）かどうかを確認します。' +
+                        'BFS は浅い順に処理するため、最初に葉と判定されたノードが必ず最も浅い葉、つまり最小深さを持ちます。ここで即座に return できます。' +
+                        '例：node=9 → node.left=None, node.right=None → 葉ノード！ → return depth=2。',
+                    visual: 'leaf_check',
+                },
+                {
+                    step: 5,
+                    title: '子ノードをキューに追加する',
+                    desc:
+                        '葉でなかった場合は、存在する子ノードをキューに追加して探索を続けます。' +
+                        'None の子をキューに追加すると後でエラーの原因になるため、追加前に必ず存在チェックをします。' +
+                        '例：node=3 → left=9 あり → (9, 2) を追加; right=20 あり → (20, 2) を追加。',
+                    visual: 'enqueue_children',
+                },
+                {
+                    step: 6,
+                    title: '最小深さを確定して返す',
+                    desc:
+                        'BFS の性質により、キューを処理した順番は必ず「浅い→深い」の順番です。そのため、最初に葉ノードを発見した時点の depth が最小深さになります。' +
+                        'この「最初に葉を見つけたら即 return する早期終了」がこのアルゴリズムの最大の効率化のポイントです。' +
+                        '例：node=9, depth=2 で葉判定 → return 2。答えは 2。',
+                    visual: 'result',
+                },
+            ];
+
+            /* ── メイン React コンポーネント ──────────────────────────────────────── */
+            function StepsApp() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+                const currentStepData = stepsData[activeStep - 1];
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 1800);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8 mt-2">
+                        {/* ── ステップ一覧 ── */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-xl font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((s) => {
+                                    const isActive = activeStep === s.step;
+                                    return (
+                                        <button
+                                            key={s.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-[0.9rem] rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)]'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(s.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {s.step}: {s.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs mt-0.5 line-clamp-2 leading-5">
+                                                {s.desc.substring(0, 55)}…
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* ── アクティブステップ詳細 ── */}
+                        <div>
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                    ← 前のステップ（Step {activeStep - 1}）では{' '}
+                                    <strong>{stepsData[activeStep - 2].title}</strong> を行いました
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)]">
+                                <h3 className="mt-0 text-teal-800 text-base font-bold">
+                                    Step {currentStepData.step}: {currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2 whitespace-pre-wrap">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <div className="mt-4 p-4 rounded-xl border border-slate-200 bg-white">
+                                <div className="text-teal-800 text-xs font-semibold mb-2">
+                                    入力例 [3,9,20,null,null,15,7] での様子
+                                </div>
+                                <StepVisualization visual={currentStepData.visual} />
+                            </div>
+
+                            {/* コントロール */}
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#10b981,#059669)] text-sm"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 bg-[linear-gradient(135deg,#0ea5e9,#0284c7)] text-sm"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-semibold text-slate-700 transition shadow hover:-translate-y-0.5 bg-white border-2 border-slate-200 text-sm"
+                                    onClick={() => {
+                                        setActiveStep(1);
+                                        setIsPlaying(false);
+                                    }}
+                                >
+                                    ↺ Reset
+                                </button>
+                            </div>
+
+                            {activeStep === stepsData.length && (
+                                <div className="mt-4 p-3 rounded-xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('steps-root')).render(<StepsApp />);
+        </script>
+    </body>
+</html>
diff --git a/public/index.html b/public/index.html
index 866c8b1..72c9849 100644
--- a/public/index.html
+++ b/public/index.html
@@ -416,7 +416,7 @@ <h1 class="site-title">
             🧪 Algorithm Study
             <span class="title-accent">Index</span>
         </h1>
-        <p class="site-subtitle">175 interactive lessons across 6 domains</p>
+        <p class="site-subtitle">176 interactive lessons across 6 domains</p>
     </header>
 
     <div class="search-container">
@@ -431,9 +431,9 @@ <h1 class="site-title">
 
     <div class="tabs" id="categoryTabs">
         <button class="tab-button active" data-category="all" data-tab-target="All">
-            <span class="tab-icon">🌍</span> All <span class="tab-count">175</span>
+            <span class="tab-icon">🌍</span> All <span class="tab-count">176</span>
         </button>
-        <button type="button" class="tab-button" data-category="algorithm" data-tab-target="Algorithm"><span class="tab-icon">🧩</span> Algorithm <span class="tab-count">97</span></button>
+        <button type="button" class="tab-button" data-category="algorithm" data-tab-target="Algorithm"><span class="tab-icon">🧩</span> Algorithm <span class="tab-count">98</span></button>
 <button type="button" class="tab-button" data-category="concurrency" data-tab-target="Concurrency"><span class="tab-icon">⚡</span> Concurrency <span class="tab-count">6</span></button>
 <button type="button" class="tab-button" data-category="datastructures" data-tab-target="DataStructures"><span class="tab-icon">🏗️</span> DataStructures <span class="tab-count">36</span></button>
 <button type="button" class="tab-button" data-category="javascript" data-tab-target="JavaScript"><span class="tab-icon">📜</span> JavaScript <span class="tab-count">14</span></button>
@@ -474,6 +474,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/106.%20Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/claude%20sonnet%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 106 · Construct Binary Tree from Inorder and Postorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/108.%20Convert%20Sorted%20Array%20to%20Binary%20Search%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 108 - 昇順配列を高さ平衡BSTに変換</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/110.%20Balanced%20Binary%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 110 · Balanced Binary Tree</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/111.%20Minimum%20Depth%20of%20Binary%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 111 - Minimum Depth of Binary Tree | BFS解説</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/ExpandAroundCenter/leetcode/5.%20Longest%20Palindromic%20Substring/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 5: Longest Palindromic Substring - 中心展開法</span></span><span class="file-path">Algorithm/ExpandAroundCenter/leetcode/5. Longest Palindromic Substring/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/66.%20Plus%20One/Claude%20Sonnet%204.5/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 66: Plus One - 右から左への繰り上がり処理</span></span><span class="file-path">Algorithm/Other/leetcode/66. Plus One/Claude Sonnet 4.5/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/TwoPointers/leetcode/67.%20Add%20Binary/Claude/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 67: Add Binary - 二進数加算</span></span><span class="file-path">Algorithm/TwoPointers/leetcode/67. Add Binary/Claude/README_react.html</span></a></li>
@@ -656,6 +657,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/106.%20Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/claude%20sonnet%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 106 · Construct Binary Tree from Inorder and Postorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/108.%20Convert%20Sorted%20Array%20to%20Binary%20Search%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 108 - 昇順配列を高さ平衡BSTに変換</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/110.%20Balanced%20Binary%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 110 · Balanced Binary Tree</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/111.%20Minimum%20Depth%20of%20Binary%20Tree/claude%20sonnet%204.6%20adaptive/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 111 - Minimum Depth of Binary Tree | BFS解説</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/111. Minimum Depth of Binary Tree/claude sonnet 4.6 adaptive/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/ExpandAroundCenter/leetcode/5.%20Longest%20Palindromic%20Substring/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 5: Longest Palindromic Substring - 中心展開法</span></span><span class="file-path">Algorithm/ExpandAroundCenter/leetcode/5. Longest Palindromic Substring/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/66.%20Plus%20One/Claude%20Sonnet%204.5/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 66: Plus One - 右から左への繰り上がり処理</span></span><span class="file-path">Algorithm/Other/leetcode/66. Plus One/Claude Sonnet 4.5/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/TwoPointers/leetcode/67.%20Add%20Binary/Claude/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 67: Add Binary - 二進数加算</span></span><span class="file-path">Algorithm/TwoPointers/leetcode/67. Add Binary/Claude/README_react.html</span></a></li>
@@ -833,7 +835,7 @@ <h1 class="site-title">
 
     <footer>
         <span class="footer-icon">🧪</span>
-        Generated on 2026-05-08
+        Generated on 2026-05-10
     </footer>
 
     <script>