diff --git a/.htmlhintrc b/.htmlhintrc
new file mode 100644
index 0000000..9abfd8e
--- /dev/null
+++ b/.htmlhintrc
@@ -0,0 +1,3 @@
+{
+  "spec-char-escape": false
+}
\ No newline at end of file
diff --git a/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Python.md b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Python.md
new file mode 100644
index 0000000..16f6c43
--- /dev/null
+++ b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Python.md	
@@ -0,0 +1,372 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Python
+> 適用ルールセット: 共通5ルール + Python固有ルール
+> 参照ファイル: references/common.md + references/python.md
+
+---
+
+# LeetCode 108. Convert Sorted Array to Binary Search Tree（Python版）
+
+---
+
+## 1. 問題分析結果
+
+> 💡 **初学者向け補足**
+> この問題は一言で言うと、**「昇順ソート済みリストを、左右の高さが均等な二分探索木に作り替える問題」**です。
+>
+> **Pythonで解く際のCPython特有の注意点：**
+> Pythonのデフォルトの再帰上限（＝関数が自分を呼べる回数の限界）は **1000回** です。本問の制約 `nums.length ≤ 10⁴` では木の高さが最大 `log₂(10000) ≈ 14` 程度なので上限に達することはありませんが、業務コードでは `sys.setrecursionlimit()` の設定を意識する必要があります。また、Pythonのリストスライス（`nums[lo:hi]`）はコピーを生成するため、大きなリストに対して繰り返し使うと O(n) のメモリが追加で必要になります。これを避けるため、**インデックスを引数で渡す設計**を採用します。
+
+---
+
+### 競技プログラミング視点
+
+- **制約分析**: `n ≤ 10⁴` → 再帰深度は最大14程度 → 再帰上限に余裕あり・O(n) で十分
+- **最速手法**: スライスコピーを避け、`lo/hi` インデックスで範囲を管理
+- **メモリ最小化**: リストコピーなし・各ノードは `TreeNode` 1個のみ生成
+- **CPython最適化**: 組み込みの整数演算（`//` による切り捨て除算）はCレベルで高速
+
+---
+
+### 業務開発視点
+
+- **型安全設計**: `Optional[TreeNode]` で「ノードがない状態（None）」を型レベルで明示。pylance でも警告なし
+- **エラーハンドリング**: 空リストは再帰のベースケース（`None`返却）で自然に処理されるが、業務版では事前バリデーションを追加
+- **可読性**: ヘルパー関数を分離してメインメソッドをシンプルに保つ
+
+---
+
+### Python特有分析
+
+- **データ構造**: `List[int]` をそのまま参照渡し（インデックスで範囲管理）→ `deque` 不要・`heapq` 不要
+- **標準ライブラリ活用度**: 今回は `typing` モジュール（型ヒント）のみ。アルゴリズムがシンプルなため標準コレクションは不要
+- **CPython最適化度**: `//`（床除算＝小数点以下切り捨ての割り算）はCレベルの整数演算で最速
+
+> 📖 **このセクションで登場した用語**
+>
+> - **CPython**: 最も広く使われるPythonの実装。C言語で書かれており、組み込み演算は高速
+> - **再帰上限**: Pythonが関数の入れ子呼び出しを許容する回数の上限。デフォルト1000。`sys.setrecursionlimit()` で変更可能
+> - **リストスライス**: `nums[a:b]` のように一部を切り出す操作。新しいリストを生成するためコピーコストがかかる
+> - **インプレース操作**: 新しいオブジェクトを作らず既存データをそのまま参照する操作。メモリ効率が良い
+
+---
+
+## 2. 採用アルゴリズムと根拠
+
+> 💡 **初学者向け補足**
+> 同じ問題でも解き方は複数あります。それぞれの「速さ」「メモリ」「Pythonらしさ」を比べて最適なものを選びます。**Python固有の観点**として「スライスコピーが発生するか（メモリ追加コスト）」「C実装の組み込み関数を使えるか」も判断基準になります。
+
+| アプローチ                      | 時間計算量 | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用 | CPython最適化         | 備考                   |
+| ------------------------------- | ---------- | ---------- | ---------------- | ------ | ------------------ | --------------------- | ---------------------- |
+| **A: インデックス再帰**（推奨） | O(n)       | O(log n)   | 低               | ★★★    | typing のみ        | ✅ `//` 整数演算      | スライスコピーなし     |
+| B: スライス再帰                 | O(n log n) | O(n log n) | 低               | ★★★    | typing のみ        | ⚠️ スライスコピーあり | 実装は簡単だがメモリ増 |
+| C: スタック反復                 | O(n)       | O(n)       | 高               | ★★☆    | collections.deque  | ⚠️ Pure Python ループ | 実装複雑・利点薄い     |
+
+**選択理由：** アプローチAを選択。Bはコードがシンプルになりますがスライスコピーが O(n log n) のメモリを追加消費します。CはAと同じ計算量ですがコードが複雑になり可読性が下がるため採用しません。
+
+**Python最適化戦略：** 中央インデックスの計算に `(lo + hi) // 2`（床除算）を使用。`//` はCPythonで整数レベルに最適化された演算子です。
+
+> 📖 **このセクションで登場した用語**
+>
+> - **床除算 `//`**: 小数点以下を切り捨てる割り算。`7 // 2 = 3`。CPythonで整数同士の場合C言語レベルで処理される
+> - **O(n log n) のメモリ**: スライスを再帰のたびにコピーすると、各階層でコピーが発生し合計 n log n のメモリが使われる
+> - **トレードオフ**: 何かを得ると何かを失う関係。今回は「コードのシンプルさ（スライス版）」 vs 「メモリ効率（インデックス版）」
+
+---
+
+## 3. 実装パターン
+
+> 💡 **コードの骨格（先に構造を把握するために）**
+>
+> 1. `sortedArrayToBST`（公開メソッド）: 入力を受け取り、ヘルパーを呼ぶ
+> 2. `_build`（内部ヘルパー）: `lo`/`hi` インデックスで区間を管理し再帰的にノードを構築
+> 3. **ベースケース**: `lo > hi` なら `None` を返す（再帰の終了条件）
+> 4. **再帰ケース**: 中央インデックスでノード生成 → 左半分・右半分で再帰 → 左右の子に接続して返す
+
+---
+
+### 【業務開発版を使う場面】
+
+チームで長期間メンテナンスするプロダクションコードに向きます。型注釈・バリデーション・docstring が充実しており、後から読んだ人でも意図が分かりやすい構造になっています。pylance による静的型チェックも通る設計です。
+
+```python
+# Runtime 4 ms
+# Beats 14.12%
+# Memory 20.23 MB
+# Beats 69.32%
+
+from typing import Optional
+
+# LeetCode が提供する TreeNode クラス（定義済みとして扱う）
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+
+class Solution:
+    """
+    昇順ソート済みリストを高さ平衡なBSTに変換するクラス（業務開発版）
+
+    設計方針:
+    - スライスコピーを避けるため lo/hi インデックスで範囲管理
+    - 型ヒントを全箇所に付けて pylance 対応
+    - バリデーションをメインメソッドで行い、ヘルパーは純粋なアルゴリズムに集中
+    """
+
+    def sortedArrayToBST(self, nums: list[int]) -> Optional["TreeNode"]:
+        """
+        昇順ソート済みリストを高さ平衡なBSTのルートノードに変換する。
+
+        Args:
+            nums: 昇順ソートされた整数リスト（重複なし）。
+                  制約: 1 <= len(nums) <= 10^4、-10^4 <= nums[i] <= 10^4
+
+        Returns:
+            BSTのルートノード。
+
+        Raises:
+            TypeError: nums がリスト型でない場合
+            ValueError: nums が空リストの場合
+
+        Complexity:
+            Time:  O(n) — 全要素を1回ずつ処理
+            Space: O(log n) — 再帰スタックの深さ = 木の高さ
+        """
+        # 型チェック: Python は動的型付けのため、誤った型が渡される可能性がある。
+        # isinstance() で実行時に型を確認し、早期にエラーを発生させる。
+        if not isinstance(nums, list):
+            raise TypeError(f"Expected list, got {type(nums).__name__}")
+
+        # 空リストチェック: 問題制約では len >= 1 だが、
+        # 業務コードでは想定外の入力にも対応するため確認する。
+        if not nums:
+            raise ValueError("Input list must not be empty")
+
+        # ヘルパー関数に全体の範囲（インデックス 0 〜 len-1）を渡して再帰開始
+        return self._build(nums, 0, len(nums) - 1)
+
+    def _build(
+        self,
+        nums: list[int],
+        lo: int,
+        hi: int,
+    ) -> Optional["TreeNode"]:
+        """
+        インデックス [lo, hi] の範囲でBSTを再帰構築する内部ヘルパー。
+
+        Args:
+            nums: 元の昇順ソート済みリスト（変更しない）
+            lo:   処理対象区間の左端インデックス（この位置を含む）
+            hi:   処理対象区間の右端インデックス（この位置を含む）
+
+        Returns:
+            構築されたサブツリーのルートノード、または None（区間が空のとき）
+        """
+        # ベースケース（再帰の終了条件）:
+        # lo > hi になった時点で有効な要素が存在しない区間なので None を返す。
+        # これがないと無限再帰（スタックオーバーフロー）が発生する。
+        # Python の None は「ノードが存在しない」= 他言語の null に相当する。
+        # Optional[TreeNode] という型ヒントで「None になり得る」ことを明示している。
+        if lo > hi:
+            return None
+
+        # 中央インデックスを計算する。
+        # `(lo + hi) // 2` の `//` は床除算（小数点以下切り捨ての割り算）。
+        # Python の `//` は CPython レベルでC言語の整数演算に最適化されており、
+        # `int(（lo + hi) / 2)` より高速で、浮動小数点数の誤差も生じない。
+        # 例: lo=0, hi=4 → (0+4)//2 = 2（インデックス2が中央）
+        mid: int = (lo + hi) // 2
+
+        # 中央の値でノードを作成する。
+        # このノードが現在の区間の「根（ルート）」になる。
+        # TreeNode のコンストラクタ（＝オブジェクトを作る関数）は
+        # left と right が未指定の場合、デフォルトで None になる。
+        node = TreeNode(nums[mid])
+
+        # 左部分木を再帰的に構築する。
+        # [lo, mid-1] の範囲（= 中央より左の要素すべて）で同じ処理を繰り返す。
+        # mid 自体は現在のノードとして使用済みのため含まない（mid-1 まで）。
+        node.left = self._build(nums, lo, mid - 1)
+
+        # 右部分木を再帰的に構築する。
+        # [mid+1, hi] の範囲（= 中央より右の要素すべて）で同じ処理を繰り返す。
+        node.right = self._build(nums, mid + 1, hi)
+
+        # 左右の子ノードが接続された完成ノードを返す。
+        # 呼び出し元では、これが node.left または node.right に代入される。
+        return node
+```
+
+---
+
+### 【競技プログラミング版を使う場面】
+
+LeetCode などの制限時間内に正解を出すことが目的のコードに向きます。型チェック・バリデーション・docstring を省略し、最小限の記述で同等の性能を実現します。
+
+```python
+# Runtime 1 ms
+# Beats 65.37%
+# Memory 20.19 MB
+# Beats 93.11%
+
+from typing import Optional
+
+class Solution:
+    def sortedArrayToBST(self, nums: list[int]) -> Optional["TreeNode"]:
+        # 内部ヘルパーをネスト関数（= 関数の中に定義した関数）として定義する。
+        # `self` の参照が不要になり、メソッド呼び出しのオーバーヘッドを削減できる。
+        # また `nums` をクロージャ（= 外側の変数をキャプチャする仕組み）で参照するため、
+        # 引数として毎回渡す必要がなくなり、コードが短くなる。
+        def build(lo: int, hi: int) -> Optional["TreeNode"]:
+            # lo > hi のとき区間が空 → None を返して再帰終了
+            if lo > hi:
+                return None
+            # 中央インデックスを床除算で計算
+            mid = (lo + hi) // 2
+            # 中央値でノードを作り、左右を再帰で構築して返す
+            # Python では代入と return を1行で書ける（可読性は業務版より下がる）
+            node = TreeNode(nums[mid])
+            node.left, node.right = build(lo, mid - 1), build(mid + 1, hi)
+            return node
+
+        # 全体範囲（0 〜 末尾インデックス）で再帰開始
+        return build(0, len(nums) - 1)
+```
+
+---
+
+### 動作トレース（入力: `nums = [-10, -3, 0, 5, 9]`）
+
+```
+nums = [-10, -3, 0, 5, 9]
+インデックス:  0    1  2  3  4
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+_build(nums, 0, 4)  → 全体区間
+  lo=0, hi=4 → lo <= hi → 続行
+  mid = (0+4) // 2 = 2
+  node = TreeNode(nums[2]) = TreeNode(0)  ← 根ノード確定！
+  node.left  = _build(nums, 0, 1)  ← 左半分 [-10, -3]
+  node.right = _build(nums, 3, 4)  ← 右半分 [5, 9]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  _build(nums, 0, 1)  → [-10, -3] の区間
+    mid = (0+1) // 2 = 0
+    node = TreeNode(nums[0]) = TreeNode(-10)
+    node.left  = _build(nums, 0, -1) → lo(0) > hi(-1) → None
+    node.right = _build(nums, 1, 1)  → [-3] の区間
+
+      _build(nums, 1, 1)  → [-3] だけ
+        mid = (1+1) // 2 = 1
+        node = TreeNode(nums[1]) = TreeNode(-3)
+        node.left  = _build(nums, 1, 0) → None
+        node.right = _build(nums, 2, 1) → None
+        return TreeNode(-3, None, None)  ← 葉ノード
+
+    return TreeNode(-10, left=None, right=TreeNode(-3))
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  _build(nums, 3, 4)  → [5, 9] の区間
+    mid = (3+4) // 2 = 3
+    node = TreeNode(nums[3]) = TreeNode(5)
+    node.left  = _build(nums, 3, 2) → None
+    node.right = _build(nums, 4, 4)  → [9] の区間
+
+      _build(nums, 4, 4)  → [9] だけ
+        mid = (4+4) // 2 = 4
+        node = TreeNode(nums[4]) = TreeNode(9)
+        node.left = node.right = None
+        return TreeNode(9)  ← 葉ノード
+
+    return TreeNode(5, left=None, right=TreeNode(9))
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+完成したBST（根 = 0）:
+
+         0
+        / \
+      -10   5
+        \    \
+        -3    9
+
+高さ確認:
+  左部分木: 0 → -10 → -3  高さ=2
+  右部分木: 0 →  5  →  9  高さ=2
+  差 = 0  ✅ 高さ平衡！
+```
+
+---
+
+## 4. 検証（エッジケース確認）
+
+> 💡 エッジケースとは「入力が空・要素1つ・最大値・すべて負の数」など、通常とは異なる境界的な入力のことです。アルゴリズムが"ふつうの入力"だけでなく"極端な入力"でも正しく動くかを確かめることが重要です。理由は、境界条件でのバグは本番環境で発生しやすく、事前に確認しておくことでデバッグコストを削減できるからです。
+
+```python
+# ━━━ エッジケース一覧と期待される動作 ━━━
+
+# ケース1: 要素1つ → ルートのみのBST
+# _build(0, 0): mid=0, left=_build(0,-1)=None, right=_build(1,0)=None
+# 結果: TreeNode(1, None, None)
+nums1: list[int] = [1]
+
+# ケース2: 要素2つ → 右の子が1つのBST（LeetCodeの例）
+# _build(0, 1): mid=0, node=TreeNode(1)
+#   left  = _build(0, -1) = None
+#   right = _build(1, 1)  = TreeNode(3)
+# 結果: TreeNode(1, None, TreeNode(3))
+# ※ mid=0 を選ぶため [1, null, 3] 形式になる（[3, 1] も正解として受理される）
+nums2: list[int] = [1, 3]
+
+# ケース3: すべて負の数 → 値の正負は高さ平衡に影響しない
+# 中央インデックスの計算は値に依存しないため同じアルゴリズムで正しく動く
+nums3: list[int] = [-10, -3, -1]
+
+# ケース4: 最大制約サイズ n=10^4 → 再帰深度は log2(10000) ≈ 14
+# Pythonのデフォルト再帰上限(1000)に対して14は余裕があるため安全
+# 業務版ではこの確認をコメントとして残しておくとよい
+import math
+max_depth: int = math.ceil(math.log2(10_000))  # → 14
+# assert max_depth < 1000  # デフォルト再帰上限未満であることの確認
+
+# ケース5: 業務版のバリデーション確認
+# try:
+#     Solution().sortedArrayToBST([])        # → ValueError
+#     Solution().sortedArrayToBST("[-1, 0]") # → TypeError
+# except (ValueError, TypeError) as e:
+#     print(f"バリデーション正常動作: {e}")
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **エッジケース**: 空リスト・要素1つ・最大サイズ入力など、境界的な条件のこと
+> - **`math.log2()`**: 2を底とする対数計算。木の高さ計算に使う。例: `log2(10000) ≈ 13.3`
+> - **`math.ceil()`**: 小数点以下を切り上げる関数。例: `ceil(13.3) = 14`
+> - **再帰深度**: 関数が自分を呼んだ回数の積み重ね。木の高さがそのまま再帰深度になる
+> - **ネスト関数（クロージャ）**: 関数の中に定義した関数。外側の変数（`nums`）をキャプチャして参照できる
+
+---
+
+## 業務版 vs 競技版 まとめ
+
+```
+【業務開発版を選ぶ場面】
+─────────────────────────────────────────────
+✅ チームでレビューされるプロダクションコード
+✅ 後から別の開発者が読んで意図を理解する必要がある
+✅ pylance / mypy による静的型チェックが必須の環境
+✅ 不正な入力が来たときに分かりやすいエラーメッセージが必要
+
+【競技プログラミング版を選ぶ場面】
+─────────────────────────────────────────────
+✅ LeetCode・AtCoder など制限時間内に正解を出すことが目的
+✅ 自分だけが読む使い捨てコード
+✅ コードの短さ・記述量の少なさを優先したい
+✅ バリデーションは問題の制約が保証してくれている場面
+
+【両バージョン共通の設計原則】
+─────────────────────────────────────────────
+- スライスコピー（nums[lo:hi]）を避け、インデックス渡しでメモリを節約
+- 中央インデックスに `//`（床除算）を使いC言語レベルの整数演算で高速化
+- Optional[TreeNode] の型ヒントで pylance のエラーを防ぐ
+```
diff --git a/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Rust.md b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Rust.md
new file mode 100644
index 0000000..68302c0
--- /dev/null
+++ b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Rust.md	
@@ -0,0 +1,363 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Rust
+> 適用ルールセット: 共通5ルール + Rust固有4ルール
+> 参照ファイル: references/common.md + references/rust.md
+
+---
+
+# LeetCode 108. Convert Sorted Array to Binary Search Tree（Rust版）
+
+---
+
+## 1. 問題の分析
+
+> 💡 **初学者向け補足**
+> この問題は一言で言うと、**「昇順ソート済みスライスを、左右の高さが均等な二分探索木に変換する問題」**です。
+>
+> **Rustで解く際に特に気をつけるべき点：**
+> LeetCodeのRust定義では木のノードが `Option<Rc<RefCell<TreeNode>>>` という複合型で表現されています。この型はRustの「所有権（＝誰がその値を管理するか）」ルールに従いながら、親子関係という複数の参照が必要な木構造を安全に扱うための工夫です。この型の意味を理解することが、Rust版実装の最大のポイントになります。
+
+---
+
+### 🔵 競技プログラミング視点での分析
+
+- **実行速度最優先**: 配列の左端・右端インデックスを引数で渡すことで `Vec::split_at()` などのコピーを作らず O(n) を実現できる
+- **メモリ最小化**: 各ノードは `Rc<RefCell<TreeNode>>`（共有所有権と内部可変性）経由でヒープに確保 (`let node = Rc::new(RefCell::new(TreeNode::new(...)))`)。LeetCodeの型定義に `Rc` が使われているためその分のオーバーヘッドは避けられないが、スライスのコピーは一切行わない設計にする
+
+---
+
+### 🟢 業務開発視点での分析
+
+- **型安全性**: `Option<Rc<RefCell<TreeNode>>>` が「ノードが存在しない（null相当）」を型レベルで表現している。`None` を返し忘れたときはコンパイルエラーになる
+- **エラーハンドリング**: 入力の `Vec<i32>` は LeetCode の仕様で直接渡ってくるため、業務コードで書くような `Result` によるバリデーションはシグネチャ上省略しているが、内部ロジックは安全なスライス参照で設計する
+
+---
+
+### 🟠 Rust特有の考慮点
+
+**`Option<Rc<RefCell<TreeNode>>>` の各層の意味：**
+
+これはロシア人形（マトリョーシカ）のように型が入れ子になっています。外側から順に読みます：
+
+```
+Option<        ← 「ノードが存在しない可能性がある」= null安全
+  Rc<          ← 「複数の場所から参照カウントで所有できる」= 親子で共有可能
+    RefCell<   ← 「実行時に借用チェックを行い、内部の値を書き換えられる」= 内部可変性
+      TreeNode ← 実際のノード本体（val, left, right を持つ）
+    >
+  >
+>
+```
+
+JavaやPythonでは「オブジェクトへのポインタ」を自由に複数箇所で持てますが、Rustでは所有権ルールにより「1つの値の所有者は1人だけ」という制約があります。木構造では同じノードを親が参照するケースが生まれるため、`Rc`（参照カウント＝所有者の人数を数えて0になったら解放する仕組み）を使って複数所有を実現しています。
+
+> 📖 **このセクションで登場した用語**
+>
+> - **所有権**: 値を"誰が管理するか"をコンパイル時に決めるRust独自の仕組み。JavaのGCがない代わりにメモリ安全を保証する
+> - **`Rc<T>`（Reference Counted）**: 参照カウント型スマートポインタ。同じ値を複数の変数で「共同所有」できる。カウントが0になると自動解放される
+> - **`RefCell<T>`**: コンパイル時ではなく実行時に借用チェックを行う型。`&mut` がなくても内部の値を書き換えられる「内部可変性（Interior Mutability）」を提供する
+> - **`Option<T>`**: 値があるか（`Some(値)`）ないか（`None`）を型で表現する。Javaの `null` と違い、取り出す前に空か確認することをコンパイラが強制する
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+> 💡 **初学者向け補足**
+> 同じ問題でも解き方は複数あります。Rustでは「所有権の移動が発生するか」「ヒープへのアロケーション（＝メモリ確保操作）が何回起きるか」も重要な判断基準になります。
+
+| アプローチ                         | 時間計算量 | 空間計算量 | Rust実装コスト | 安全性 | 可読性 | 備考                                     |
+| ---------------------------------- | ---------- | ---------- | -------------- | ------ | ------ | ---------------------------------------- |
+| **A: スライス参照 + 再帰**（推奨） | O(n)       | O(log n)   | 低             | 高     | 高     | コピーなし・アロケーションはノード分のみ |
+| B: 範囲インデックス + 再帰         | O(n)       | O(log n)   | 低             | 高     | 高     | Aと同等。インデックス計算が明示的        |
+| C: `VecDeque` で反復処理           | O(n)       | O(n)       | 高             | 高     | 低     | キューに区間を積む。実装複雑で利点薄い   |
+
+**Rust固有の観点：**
+
+- アプローチAは `&[i32]`（スライス参照）を再帰に渡す。`Vec<i32>` ごと渡すと所有権が移動（move）してしまうため、`&[i32]` で「借用（＝所有権を渡さずに値を参照すること）」するのがRustの慣習
+- ノード生成（`TreeNode::new()`）は必ずヒープアロケーションが発生するが、これは木構造の本質的なコストであり最小化できない
+
+> 📖 **このセクションで登場した用語**
+>
+> - **スライス `&[T]`**: 配列や`Vec`の一部への参照。所有権を移さずデータを渡せる読み取り専用のビュー
+> - **move（所有権の移動）**: 変数に値を代入・渡すと所有権が移り、元の変数は使えなくなること
+> - **アロケーション**: ヒープ上にメモリを確保する操作。`Rc::new()` や `Box::new()` で発生する
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+> 💡 **初学者向け補足**
+> 他の方法との対比で選択理由を説明します。
+
+- **選択したアプローチ**: **A：スライス参照 `&[i32]` を再帰的に二分割するアプローチ**
+
+**理由：**
+
+1. **Cを選ばない理由**: `VecDeque` で区間を管理する反復版は実装が複雑になり、再帰版と比べて空間計算量が O(n) に増える（キューに全区間情報を積むため）
+2. **BよりAを選ぶ理由**: インデックスで区間を管理するBも同等だが、`&[i32]` のスライス分割（`.split_at(mid)`）を使うとRustのスライス操作と自然に合致し、境界計算のミスをコンパイラが防いでくれる
+3. **所有権モデルとの親和性**: `&[i32]` の借用は再帰呼び出しをまたいでライフタイム（＝参照の有効期間）が自動的に推論されるため、明示的なライフタイムアノテーションが不要
+
+**Rust特有の最適化ポイント：**
+
+- `node.borrow_mut()` は `RefCell` の実行時借用チェックを経由するが、`left`・`right` への代入は1回のみで最小限にとどめる
+- `Rc::new(RefCell::new(...))` のアロケーションはノード数（n回）で固定。余分なコピーなし
+
+> 📖 **このセクションで登場した用語**
+>
+> - **ライフタイム `'a`**: 参照の有効期間をコンパイラに伝えるアノテーション。再帰関数では多くの場合コンパイラが自動推論してくれる
+> - **`borrow_mut()`**: `RefCell<T>` に対して実行時に「書き込み可能な借用」を取得するメソッド。複数箇所から同時に呼ぶとパニックするため注意が必要
+> - **ゼロコスト抽象化**: 便利な高レベルな書き方をしても、手書きの低レベルコードと同等の速さになるRustの特性
+
+---
+
+## 4. 実装コード
+
+> 💡 **コードの骨格（先に構造を把握するために）**
+>
+> 1. `sorted_array_to_bst`（公開関数）: `Vec<i32>` を受け取り、スライス参照に変換して内部ヘルパーを呼ぶ
+> 2. `build`（内部ヘルパー関数）: `&[i32]` を受け取り、再帰的に木を構築する
+> 3. **ベースケース**: スライスが空なら `None` を返す（再帰の終了条件）
+> 4. **再帰ケース**: 中央要素でノード生成 → 左半分・右半分で再帰 → `left`/`right` に接続して返す
+
+---
+
+### leetcodeでの回答フォーマット
+
+```rust
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 2.74 MB
+// Beats 40.00%
+use std::rc::Rc;
+use std::cell::RefCell;
+
+impl Solution {
+    /// ソート済み配列を高さ平衡なBSTに変換する（公開エントリーポイント）
+    ///
+    /// LeetCodeのシグネチャに合わせて `Vec<i32>` を受け取るが、
+    /// 内部では所有権を移動させずにスライス参照 `&[i32]` に変換して処理する。
+    /// これにより再帰呼び出しで余分なコピーが発生しない。
+    ///
+    /// # Complexity
+    /// - Time:  O(n) — 全要素を1回ずつ処理
+    /// - Space: O(log n) — 再帰スタックの深さ = 木の高さ
+    pub fn sorted_array_to_bst(nums: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
+        // Vec<i32> → &[i32] への変換。
+        // &nums[..] は「numsの全要素へのスライス参照」を意味する。
+        // Vecの所有権はこの関数が保持したまま、参照だけをhelperに渡す。
+        // JavaやPythonでは配列をそのまま渡せるが、Rustでは
+        // 「所有権を渡すか」「借用するか」を明示的に選ぶ必要がある。
+        Self::build(&nums[..])
+    }
+
+    /// 内部再帰ヘルパー: スライスの中央を根にしてBSTを構築する
+    ///
+    /// # Arguments
+    /// * `nums` - 処理対象の昇順ソート済みスライス（借用・イミュータブル）
+    ///
+    /// # Returns
+    /// - `Some(Rc<RefCell<TreeNode>>)` — 1要素以上あるとき
+    /// - `None`                         — スライスが空のとき（葉の先端 or 空入力）
+    fn build(nums: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
+        // ベースケース（再帰の終了条件）:
+        // スライスが空（要素数0）なら、子ノードが存在しないことを表す None を返す。
+        // これがないと空スライスへの mid アクセスで実行時パニックが発生する。
+        // Rustの `Option<T>` は「値がない状態」を型で安全に表現でき、
+        // Javaのような NullPointerException が起きない。
+        if nums.is_empty() {
+            return None;
+        }
+
+        // 中央インデックスを計算する。
+        // `>> 1` は右ビットシフト（= 2で割って切り捨て）。
+        // `nums.len() / 2` と同じ結果だが、整数演算として最適化されやすい。
+        // usize（符号なし整数）同士の演算なのでオーバーフローの心配はない。
+        let mid = nums.len() >> 1;
+
+        // 中央の値でノードを作成し、Rc<RefCell<...>> で包む。
+        //
+        // なぜこの複雑な型が必要か？
+        //   - `TreeNode` をそのまま left/right に置くと、
+        //     木の構造上「親→子」への参照が必要になるが、
+        //     Rustの所有権ルールでは1つの値を複数箇所から所有できない。
+        //   - `Rc<T>`: 参照カウント型ポインタ。複数の変数が同じヒープ上の値を
+        //     「共同所有」できる。本の図書館カードのようなもの——
+        //     何人でも同じ本を参照でき、全員が返した（カウント=0）時点で本が廃棄される。
+        //   - `RefCell<T>`: コンパイル時ではなく実行時に借用チェックを行う型。
+        //     `Rc` は「共有参照（&T）」しか渡せないが、`RefCell` を組み合わせると
+        //     内部の値を書き換えられる「内部可変性」が得られる。
+        let node = Rc::new(RefCell::new(TreeNode::new(nums[mid])));
+
+        // 左部分木を再帰構築する。
+        // `&nums[..mid]` は「インデックス 0 から mid-1 までのスライス参照」。
+        // midより左の要素すべてが対象（midは現在のノードとして使用済みのため含まない）。
+        // スライスの分割は O(1) — ポインタと長さを変えるだけでコピーなし。
+        node.borrow_mut().left = Self::build(&nums[..mid]);
+
+        // 右部分木を再帰構築する。
+        // `&nums[mid + 1..]` は「インデックス mid+1 から末尾までのスライス参照」。
+        // midより右の要素すべてが対象。
+        node.borrow_mut().right = Self::build(&nums[mid + 1..]);
+
+        // 左右の子が接続されたノードを Some でラップして返す。
+        // 呼び出し元では、これが親ノードの .left または .right に代入される。
+        Some(node)
+    }
+}
+```
+
+---
+
+### 動作トレース（入力: `nums = [-10, -3, 0, 5, 9]`）
+
+```
+nums = [-10, -3, 0, 5, 9]  (Vec<i32>)
+スライス変換: &[-10, -3, 0, 5, 9]  (len=5)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+build(&[-10, -3, 0, 5, 9])  len=5
+  is_empty() → false → 続行
+  mid = 5 >> 1 = 2
+  node = TreeNode(nums[2]) = TreeNode(val=0)
+  node.left  = build(&[-10, -3])  ← 左半分
+  node.right = build(&[5, 9])     ← 右半分
+  return Some(TreeNode(0, left=?, right=?))
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  build(&[-10, -3])  len=2
+    is_empty() → false
+    mid = 2 >> 1 = 1  ← インデックス1 = nums[1] = -3... ではなく
+                          スライスの[1]なので値は -3
+    ※ スライス &[-10, -3] のインデックス:
+       [0] = -10
+       [1] = -3
+    mid = 1
+    node = TreeNode(val=-3)    ← このスライスの中央は -3！
+    node.left  = build(&[-10]) ← スライス &[-10, -3][..1] = &[-10]
+    node.right = build(&[])    ← スライス &[-10, -3][2..] = &[] (空)
+
+      build(&[-10])  len=1
+        mid = 1 >> 1 = 0
+        node = TreeNode(val=-10)
+        node.left  = build(&[]) → None
+        node.right = build(&[]) → None
+        return Some(TreeNode(-10, None, None))  ← 葉ノード
+
+      build(&[])  → is_empty()=true → return None
+
+    node.left  = Some(TreeNode(-10))
+    node.right = None
+    return Some(TreeNode(-3, left=TreeNode(-10), right=None))
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  build(&[5, 9])  len=2
+    mid = 2 >> 1 = 1
+    ※ スライス &[5, 9] のインデックス:
+       [0] = 5
+       [1] = 9
+    node = TreeNode(val=9)      ← このスライスの中央は 9
+    node.left  = build(&[5])    ← スライス &[5, 9][..1] = &[5]
+    node.right = build(&[])     → None
+
+      build(&[5])  len=1
+        mid = 0
+        node = TreeNode(val=5)
+        node.left = node.right = None
+        return Some(TreeNode(5))  ← 葉ノード
+
+    node.left  = Some(TreeNode(5))
+    node.right = None
+    return Some(TreeNode(9, left=TreeNode(5), right=None))
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+完成したBST（根 = 0）:
+
+        0
+       / \
+     -3    9
+     /    /
+  -10    5
+
+高さ確認:
+  左部分木: 0 → -3 → -10  高さ=2
+  右部分木: 0 → 9  → 5    高さ=2
+  差 = 0  ✅ 高さ平衡！
+```
+
+---
+
+### `borrow_mut()` の動きを図で理解する
+
+> `RefCell` の借用チェックは実行時（コードが動いている最中）に行われます。以下の図で動作を確認しましょう。
+
+```
+node.borrow_mut().left = Self::build(&nums[..mid]);
+─────────────────────────────────────────────────
+Step 1: node.borrow_mut()
+        → RefCell の内部カウンタを確認
+        → 現在 borrow_mut が他から呼ばれていなければ OK（排他ロック取得）
+        → `RefMut<TreeNode>` （書き込み可能な参照）を返す
+
+Step 2: .left = ...
+        → TreeNode の left フィールドに代入
+
+Step 3: RefMut がスコープ（= {}ブロック）を抜けると自動でドロップ
+        → 排他ロックが解放され、次の borrow_mut() が呼べる状態に戻る
+
+⚠️ 同じ RefCell に対して borrow_mut() を同時に2回呼ぶとパニック
+   （今回は left と right を別々の文で書いているので安全）
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`&[i32]`（スライス参照）**: 連続したメモリ上の `i32` の列への借用。ポインタ+長さの2ワードで表現され、`Vec` のコピーなしにデータを参照できる
+> - **`Rc::new()`**: ヒープ上に値を確保し、参照カウンタを1にして `Rc<T>` を返す。JavaやPythonの「newオブジェクト」に近いが、GCがない代わりに参照カウントで管理する
+> - **`borrow_mut()`**: `RefCell<T>` から「書き込み可能な参照 `RefMut<T>`」を実行時に取得する。Javaの `synchronized` ブロックに似た排他制御を実行時に行う
+> - **`RefMut<T>`**: `borrow_mut()` が返す型。スコープを抜けると自動的に借用が解放される（Rustの`Drop`トレイトによる自動解放）
+> - **ベースケース**: 再帰の終了条件。これがないと関数が永遠に自分を呼び続け、スタックオーバーフロー（= 呼び出し履歴がメモリ上限を超えること）が発生する
+> - **`usize`**: Rustの符号なし整数型。配列のインデックスやサイズを表すために使う。負の値を取れないのでインデックスが負になるバグを型レベルで防げる
+
+---
+
+## Rust固有の最適化観点まとめ
+
+### TypeScriptとRustの実装比較
+
+```
+【TypeScript版】
+- null を直接使えるため、ノードの「なさ」を TreeNode | null で表現
+- ガベージコレクタがメモリ管理を担当するため、参照のカウントを気にしない
+
+【Rust版】
+- null がないため Option<...> で「なさ」を型安全に表現
+- GCがないため、木構造の共有を Rc<RefCell<...>> で明示的に管理
+- コンパイル時に「解放後の参照」や「二重解放」が起きないことが保証される
+```
+
+### 所有権の視点から見たスライス分割
+
+```rust
+// ❌ Vec を再帰に渡すと所有権が移動してしまう（コンパイルエラー）
+fn bad_build(nums: Vec<i32>) -> Option<...> {
+    bad_build(nums[..mid].to_vec()) // to_vec() でコピーが必要になり O(n) 余分に使う
+}
+
+// ✅ スライス参照を渡すと所有権は移動せずコピーも発生しない
+fn build(nums: &[i32]) -> Option<...> {
+    Self::build(&nums[..mid])      // ポインタ+長さの変更だけ = O(1)
+}
+```
+
+| 観点                 | この実装での対応                                              |
+| -------------------- | ------------------------------------------------------------- |
+| 所有権の移動防止     | `Vec<i32>` を `&[i32]` に変換して再帰へ                       |
+| アロケーション最小化 | スライス分割はコピーなし O(1)・ノード生成のみアロケーション   |
+| null安全             | `Option<...>` で `None` を型安全に表現                        |
+| 内部可変性           | `RefCell::borrow_mut()` で left/right を1回ずつ安全に書き換え |
+
+> 📖 **最終用語集**
+>
+> - **内部可変性（Interior Mutability）**: `&T`（共有参照）越しに値を変更できる仕組み。`RefCell<T>` がその代表例。通常のRustの借用規則を「コンパイル時」ではなく「実行時」に検証することで実現する
+> - **ドロップ（Drop）**: 値がスコープを抜けたとき自動的にメモリを解放するRustの仕組み。Javaのファイナライザに似ているが、タイミングが確定的（スコープ終了時）
+> - **`&nums[..mid]`（スライスの分割）**: `nums` の先頭から `mid`（含まない）までの参照。ポインタの位置と長さを変えるだけで実現するため O(1) の操作
+> - **Pure function（純粋関数）**: 同じ引数を与えると必ず同じ結果を返し、外部の状態を変えない関数。`build()` は入力スライスを読むだけで外部を変更しないためこれに該当する
diff --git a/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Typescript.md b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Typescript.md
new file mode 100644
index 0000000..70a410a
--- /dev/null
+++ b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/Convert_Sorted_Array_to_Binary_Search_Tree_Typescript.md	
@@ -0,0 +1,348 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: TypeScript
+> 適用ルールセット: 共通5ルール + TS固有5ルール
+> 参照ファイル: references/common.md + references/typescript.md
+
+---
+
+# LeetCode 108. Convert Sorted Array to Binary Search Tree
+
+---
+
+## 1. 問題の分析
+
+> 💡 **初学者向け補足**
+> この問題は一言で言うと、**「ソート済み配列を、左右の高さが均等な二分探索木に変換する問題」**です。
+> 配列はすでに小さい順に並んでいるため、「どこを根（ルート）にすれば木が均等に分かれるか」を見つけるのがカギです。
+
+---
+
+### 🔵 競技プログラミング視点での分析
+
+**核心的な観察：**
+ソート済み配列の「真ん中の要素」を根（ルート）にすれば、左半分と右半分が自然に左右の子木になります。これを再帰的に繰り返すと、必ず高さ平衡なBSTが得られます。
+
+```
+nums = [-10, -3, 0, 5, 9]
+          0    1  2  3  4  ← インデックス
+
+真ん中のインデックス = (0+4) / 2 = 2
+真ん中の値 = nums[2] = 0  ← これが根になる！
+
+左部分配列: [-10, -3] → 同じ手順で再帰
+右部分配列: [5, 9]    → 同じ手順で再帰
+```
+
+- **実行速度最優先**: 各要素を1回だけ処理する → O(n)
+- **メモリ最小化**: 再帰の深さは O(log n)（木の高さ分のスタックだけ使用）
+
+---
+
+### 🟢 業務開発視点での分析
+
+- **型安全性**: `TreeNode | null`という直和型（＝「TreeNodeかnullのどちらか」という型）で、nullポインタ参照を型レベルで防ぐ
+- **保守性**: 再帰関数は引数に`lo`（左端）と`hi`（右端）インデックスを渡すことで、配列のコピーを作らず参照を使い回す設計にできる
+- **エラーハンドリング**: 空配列の場合は`null`を返すことでLeetCodeの仕様に準拠
+
+---
+
+### 🟠 TypeScript特有の考慮点
+
+TypeScript（＝JavaScriptに型を追加した言語）特有の点として：
+
+- **`readonly`修飾子**（JavaScriptには存在しない）：入力配列を誤って書き換えるバグをコンパイル時（＝コードを実行する前の変換ステップ）に防げる
+- **`TreeNode | null`の union型（＝複数の型をOR条件で合わせた型）**：nullを返す可能性を型定義に明示することで、呼び出し側が`null`チェックを忘れるとコンパイルエラーになる
+- **再帰の型推論**：TypeScriptのコンパイラが戻り値の型を自動推論してくれるが、明示的な`: TreeNode | null`注釈を付けることでドキュメントとしても機能する
+
+> 📖 **このセクションで登場した用語**
+>
+> - **BST（Binary Search Tree＝二分探索木）**: 各ノードの左の子は必ず小さく、右の子は必ず大きいという規則を持つ木構造
+> - **高さ平衡（Height-Balanced）**: 左右の部分木の高さの差が常に1以下であること。平衡が取れていないと検索が遅くなる
+> - **再帰（Recursion）**: 関数が自分自身を呼び出すこと。大きな問題を同じ構造の小さな問題に分割して解くときに使う
+> - **union型**: `A | B` のように「AかBのどちらか」という型。TypeScript固有の概念
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+> 💡 **初学者向け補足**
+> 同じ問題でも解き方は複数あります。それぞれの「速さ（時間計算量）」と「使うメモリ（空間計算量）」を比較して最適なものを選びます。問題の制約（配列長最大10⁴）を踏まえて評価します。
+
+| アプローチ                     | 時間計算量 | 空間計算量 | TS実装コスト | 型安全性 | 可読性 | 備考                   |
+| ------------------------------ | ---------- | ---------- | ------------ | -------- | ------ | ---------------------- |
+| **A: 二分分割 + 再帰**（推奨） | O(n)       | O(log n)   | 低           | 高       | 高     | 各要素1回だけ処理      |
+| B: 順番挿入（1つずつ挿入）     | O(n log n) | O(n)       | 中           | 中       | 中     | 平衡は保証されない     |
+| C: 反復（スタック使用）        | O(n)       | O(n)       | 高           | 中       | 低     | スタックに全区間を積む |
+
+**結論**: アプローチAが最速かつ最もシンプルです。スタックを自前で管理するCは実装が複雑な割にメリットがなく、Bは時間計算量が劣ります。
+
+> 💡 **Big-O記法の読み方**（初学者向け）
+>
+> - `O(n)`: 要素数nに比例した時間がかかる（n=10000なら約10000ステップ）
+> - `O(log n)`: nが2倍になっても処理は1ステップしか増えない（最も効率的）
+> - `O(n log n)`: ソートの典型的な計算量
+>   📖 **このセクションで登場した用語**
+> - **時間計算量**: 入力の大きさに対して、処理にかかる手間がどう増えるかの目安
+> - **空間計算量**: 処理中に使うメモリ量がどう増えるかの目安
+> - **O(log n)の空間**: 再帰呼び出しのスタック（＝関数の「戻り先」を覚えておくメモリ）が木の高さ分だけ積まれるため
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+> 💡 **初学者向け補足**
+> 他の方法と比較しながら「なぜ選んだか」を説明します。
+
+- **選択したアプローチ**: **A：二分分割 + 再帰（分割統治法）**
+
+**理由：**
+
+1. **計算量の優位性**: 配列を左右に分けるだけなので O(n) で全ノードを確定できる。Bの順番挿入より速い
+2. **なぜBを選ばないか**: 1つずつ挿入するとO(n log n)になり、かつ平衡保証のためにAVL木などの追加ロジックが必要になるため複雑すぎる
+3. **なぜCを選ばないか**: 再帰版（A）と同じO(n)だが、スタックを自前で管理するコードは可読性・保守性が下がる
+
+**TypeScript特有の最適化ポイント：**
+
+- **`readonly number[]`の型注釈**: 入力配列を誤って破壊的変更（元の配列を書き換えること）しないようコンパイラが保証してくれる（JavaScriptにはこの保証がない）
+- **`lo`/`hi`インデックス渡し**: `nums.slice()`で配列コピーを作る代わりにインデックスを渡すことで、O(n)の余分なメモリ確保を避けられる
+- **型推論の活用**: `mid`の型は自動的に`number`と推論されるため、明示的な`: number`注釈が不要
+
+> 📖 **このセクションで登場した用語**
+>
+> - **分割統治法（Divide and Conquer）**: 問題を小さな部分に分けて解き、その結果を組み合わせる手法。再帰と相性が良い
+> - **破壊的変更**: 元の配列・オブジェクトを直接書き換えること。バグの原因になりやすい
+
+---
+
+## 4. 実装コード
+
+> 💡 **コードの骨格（先に構造を把握するために）**
+>
+> 1. 再帰の**ベースケース**（＝再帰を止める条件）の確認：`lo > hi`なら`null`を返す
+> 2. **真ん中のインデックス**を計算する：`(lo + hi) >> 1`（ビットシフトで2で割る、理由は後述）
+> 3. 真ん中の値で**新しいTreeNodeを作る**
+> 4. **左の子**を`[lo, mid-1]`の範囲で再帰的に構築する
+> 5. **右の子**を`[mid+1, hi]`の範囲で再帰的に構築する
+> 6. 完成したノードを**返す**
+
+---
+
+### leetcodeでの回答フォーマット
+
+```typescript
+// Runtime 2 ms
+// Beats 67.7 %
+// Memory 58 65 MB
+// Beats 91.59 %
+/**
+ * 昇順ソート済み配列を高さ平衡なBSTに変換する
+ *
+ * アルゴリズム: 分割統治法（再帰的二分分割）
+ * - 配列の中央要素を根にする
+ * - 左半分を左部分木、右半分を右部分木として再帰的に構築する
+ *
+ * @param nums - 昇順にソートされた整数配列（破壊しないためreadonly推奨だが
+ *               LeetCode定義に合わせnumber[]のまま受け取る）
+ * @returns 高さ平衡なBSTの根ノード。空配列ならnull
+ * @complexity Time: O(n)  - 各要素を1回ずつ処理する
+ *             Space: O(log n) - 再帰呼び出しスタックの深さ = 木の高さ
+ */
+function sortedArrayToBST(nums: number[]): TreeNode | null {
+    /**
+     * 内部再帰関数
+     * 外に出すことで nums 配列をクロージャ（＝外側の変数を参照できる内部関数の仕組み）
+     * として参照し、配列コピーを避けてメモリを節約する
+     *
+     * @param lo - 処理対象区間の左端インデックス（inclusive＝この位置を含む）
+     * @param hi - 処理対象区間の右端インデックス（inclusive＝この位置を含む）
+     */
+    function helper(lo: number, hi: number): TreeNode | null {
+        // ベースケース（＝再帰を止める条件）:
+        // lo > hi のとき、有効な要素が存在しない区間なので null を返す。
+        // これがないと無限再帰（永遠に自分を呼び続けること）になってしまう。
+        if (lo > hi) return null;
+
+        // 中央インデックスの計算
+        // なぜ (lo + hi) >> 1 か？
+        //   >> 1 は右ビットシフト（＝2で割って小数点以下切り捨て）。
+        //   Math.floor((lo + hi) / 2) と同じ結果だが、ビット演算の方が高速。
+        //   また (lo + hi) が巨大になったとき整数オーバーフローを防ぐ書き方として
+        //   lo + ((hi - lo) >> 1) も使えるが、JS/TSはNumber型で安全なので
+        //   このシンプルな形で十分。
+        const mid: number = (lo + hi) >> 1;
+
+        // 中央の値で新しいノードを作成する。
+        // この値が「根（ルート）」または「親ノードの子」になる。
+        // 左の子・右の子はまだ未設定（コンストラクタのデフォルトでnullになる）。
+        const node = new TreeNode(nums[mid]);
+
+        // 左部分木を再帰的に構築する。
+        // [lo, mid-1] の範囲（＝中央より左の要素すべて）で同じ処理を繰り返す。
+        // mid 自体は今のノードとして使用済みなので mid-1 まで。
+        node.left = helper(lo, mid - 1);
+
+        // 右部分木を再帰的に構築する。
+        // [mid+1, hi] の範囲（＝中央より右の要素すべて）で同じ処理を繰り返す。
+        node.right = helper(mid + 1, hi);
+
+        // 左右の子が接続された完成ノードを返す。
+        // 呼び出し元では、これが node.left または node.right に代入される。
+        return node;
+    }
+
+    // 配列全体（インデックス 0 〜 nums.length-1）を対象に再帰開始
+    return helper(0, nums.length - 1);
+}
+```
+
+---
+
+### 動作トレース（入力: `nums = [-10, -3, 0, 5, 9]`）
+
+```
+nums の各インデックス:
+  idx:   0    1   2  3  4
+  val: [-10, -3,  0, 5, 9]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+呼び出し①: helper(0, 4)
+  mid = (0+4) >> 1 = 2
+  node = TreeNode(nums[2]) = TreeNode(0)  ← 根ノードが確定！
+  node.left  = helper(0, 1)  ← 左半分 [-10, -3] を処理
+  node.right = helper(3, 4)  ← 右半分 [5, 9] を処理
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  呼び出し②: helper(0, 1)  ← [-10, -3] の処理
+    mid = (0+1) >> 1 = 0
+    node = TreeNode(nums[0]) = TreeNode(-10)
+    node.left  = helper(0, -1) → lo(0) > hi(-1) → null を返す
+    node.right = helper(1, 1)  ← [-3] の処理
+
+      呼び出し③: helper(1, 1)  ← [-3] だけ
+        mid = (1+1) >> 1 = 1
+        node = TreeNode(nums[1]) = TreeNode(-3)
+        node.left  = helper(1, 0) → lo(1) > hi(0) → null
+        node.right = helper(2, 1) → lo(2) > hi(1) → null
+        return TreeNode(-3, null, null)  ← 葉ノード確定
+
+    ③の結果: TreeNode(-3)
+    return TreeNode(-10, null, TreeNode(-3))  ← ②確定
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  呼び出し④: helper(3, 4)  ← [5, 9] の処理
+    mid = (3+4) >> 1 = 3
+    node = TreeNode(nums[3]) = TreeNode(5)
+    node.left  = helper(3, 2) → lo(3) > hi(2) → null
+    node.right = helper(4, 4)  ← [9] の処理
+
+      呼び出し⑤: helper(4, 4)  ← [9] だけ
+        mid = (4+4) >> 1 = 4
+        node = TreeNode(nums[4]) = TreeNode(9)
+        node.left  = helper(4, 3) → null
+        node.right = helper(5, 4) → null
+        return TreeNode(9, null, null)  ← 葉ノード確定
+
+    ④の結果: TreeNode(5, null, TreeNode(9))
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+①の結果（完成したBST）:
+           0          ← 根
+          / \
+       -10    5
+         \     \
+         -3     9
+
+高さ確認:
+  左部分木の高さ = 2（-10 → -3）
+  右部分木の高さ = 2（5 → 9）
+  差 = 0  ✅ 高さ平衡！
+```
+
+---
+
+### 別解（iterative版 ＝ スタックで反復処理）
+
+> 💡 再帰が苦手な場合の参考として示します。LeetCodeでは上記の再帰版で十分ですが、再帰の呼び出しスタックを自前で管理したい場合はこちらが使えます。ただし実装が複雑になります。
+
+```typescript
+// Runtime 4 ms
+// Beats 21.73%
+// Memory 60.93 MB
+// Beats 5.84%
+// 【参考：反復版】スタックで再帰を模倣するアプローチ
+// 競技プログラミング文脈以外では可読性が下がるため通常は再帰版を推奨。
+function sortedArrayToBSTIterative(nums: number[]): TreeNode | null {
+    if (nums.length === 0) return null;
+
+    // ダミーの根ノードを作り、そこを起点にスタックで管理する
+    // [ノード, 担当するlo, 担当するhi] をセットで管理する
+    const root = new TreeNode(0); // 仮の値。後で正しい値で上書きする
+    const stack: Array<[TreeNode, number, number]> = [[root, 0, nums.length - 1]];
+
+    while (stack.length > 0) {
+        // スタックから1つ取り出す（後入れ先出し＝LIFO）
+        const [node, lo, hi] = stack.pop()!; // ! はnon-null assertionで「必ず値がある」と保証
+
+        // 中央インデックスと値をセット
+        const mid = (lo + hi) >> 1;
+        node.val = nums[mid];
+
+        // 左の子が存在する範囲なら、新ノードを作ってスタックに積む
+        if (lo < mid) {
+            node.left = new TreeNode(0);
+            stack.push([node.left, lo, mid - 1]);
+        }
+
+        // 右の子が存在する範囲なら、新ノードを作ってスタックに積む
+        if (mid < hi) {
+            node.right = new TreeNode(0);
+            stack.push([node.right, mid + 1, hi]);
+        }
+    }
+
+    return root;
+}
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **ベースケース**: 再帰を止める条件。これがないと無限ループになる。「料理レシピで『材料がなければ終了』に相当」
+> - **クロージャ**: 外側の変数（ここでは`nums`）を参照できる内部関数。コピーせず元のデータを使い回せる
+> - **ビットシフト（`>> 1`）**: 数値を2進数で右に1ビットずらす操作。結果は2で割って切り捨てた値と同じ
+> - **non-null assertion（`!`）**: TypeScript固有の記号。`null`や`undefined`でないとコンパイラに明示的に伝える。使いすぎは型安全性を下げるので注意
+> - **LIFO（Last In First Out）**: 最後に入れたものが最初に出てくるデータ構造。スタックの特性
+> - **readonly**: TypeScript固有の修飾子。JavaScriptには存在しない。変数への再代入をコンパイル時に禁止することで意図せぬ書き換えバグを防ぐ
+
+---
+
+## TypeScript固有の最適化観点まとめ
+
+### 型安全性の活用
+
+```typescript
+// 【NG例】JavaScriptの書き方: 何でも通ってしまう
+function bad(nums) {
+    // 型なし。誤ってnumsに文字列を渡してもエラーにならない
+    return null;
+}
+
+// 【OK例】TypeScriptの書き方: 型違反をコンパイル時に検出
+function good(nums: number[]): TreeNode | null {
+    // nums に文字列を渡そうとするとコンパイルエラーになる → 安全
+    return null;
+}
+```
+
+| 最適化ポイント                   | 効果                                         |
+| -------------------------------- | -------------------------------------------- |
+| `number[]` の型注釈              | 数値以外の入力をコンパイル時に拒否           |
+| `TreeNode \| null` の戻り値型    | 呼び出し元にnullチェックを強制できる         |
+| インデックスの `lo/hi` 渡し      | `slice()`による配列コピーが不要 → メモリ節約 |
+| 内部関数 `helper` をクロージャに | `nums` を引数で毎回渡さずに済む → コード簡潔 |
+
+> 📖 **最終用語集**
+>
+> - **コンパイル時**: TypeScriptコードをJavaScriptに変換する段階。ここでエラーを発見できると実行時バグを防げる
+> - **分割統治法**: 問題を半分に分けて解き、結果を合体させる手法。木構造の問題と非常に相性が良い
+> - **葉ノード（Leaf Node）**: 左右両方の子がnullのノード。木の末端
+> - **Pure function（純粋関数）**: 同じ入力に対して必ず同じ出力を返し、外部の状態を変えない関数。`helper`はこれに該当する
diff --git a/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README.md b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README.md
new file mode 100644
index 0000000..bd7c3fb
--- /dev/null
+++ b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README.md	
@@ -0,0 +1,716 @@
+# Convert Sorted Array to Binary Search Tree - 昇順配列を高さ平衡BSTに変換する
+
+> **LeetCode 108** · Python (CPython 3.11+) · 分割統治法 · Time O(n) / Space O(log n)
+
+---
+
+## 目次（Table of Contents）
+
+- [概要](#overview)
+- [アルゴリズム要点 TL;DR](#tldr)
+- [図解](#figures)
+- [正しさのスケッチ](#correctness)
+- [計算量](#complexity)
+- [Python 実装](#impl)
+- [CPython 最適化ポイント](#cpython)
+- [エッジケースと検証観点](#edgecases)
+- [FAQ](#faq)
+
+---
+
+<h2 id="overview">概要</h2>
+
+> 💡 **この問題は一言で言うと**、「昇順ソート済みリストを、左右の高さが均等な二分探索木（BST）のルートノードに変換する問題」です。
+
+### 問題の背景とポイント
+
+与えられたリスト `nums` はすでに昇順に並んでいます。これを **高さ平衡な BST（Height-Balanced Binary Search Tree）** に変換することが目標です。
+
+「高さ平衡（Height-Balanced）」とは、**どのノードについても左右の部分木の高さの差が 1 以下**であることを指します。平衡が崩れた BST は最悪の場合、検索に O(n) かかりますが、平衡が保たれていれば O(log n) で検索できます。
+
+**なぜ難しいのか？**
+「ソート済みリストから BST を作る」と聞くと、端から順に挿入すれば良いと思いがちです。しかし、端から挿入すると右に伸び続ける「竹のような木」になり、高さ平衡の条件を満たしません。**配列のどこを根にするかを賢く選ぶ**ことが核心です。
+
+**ポイント：** ソート済みリストの「真ん中の要素」を根にすれば、左半分と右半分の要素数がほぼ等しくなり、自然と高さ平衡が実現されます。これを再帰的に繰り返すのが本解法の戦略です。
+
+### 制約
+
+- `1 <= nums.length <= 10^4`
+- `-10^4 <= nums[i] <= 10^4`
+- `nums` は**厳密な昇順**にソートされている（重複なし）
+
+> 📖 **この章で登場した用語**
+>
+> - **BST（二分探索木）**: 各ノードの左の子は必ず小さく、右の子は必ず大きいという規則を持つ木構造。検索・挿入が効率的になる
+> - **高さ平衡**: 左右の部分木の高さの差が常に 1 以下であること。平衡が崩れると検索効率が下がる
+> - **根（ルート）**: 木構造の最上位のノード。すべてのノードはここから辿れる
+> - **制約**: 入力として与えられる値の範囲や条件。例：「リストの長さは 1 以上 10^4 以下」
+
+---
+
+<h2 id="tldr">アルゴリズム要点（TL;DR）</h2>
+
+> 💡 **TL;DR（Too Long; Didn't Read）** とは「要約だけ読みたい人向け」の意味です。ここではアルゴリズム全体の戦略を掴んでください。詳細は後の章で説明します。
+
+### 戦略の骨格
+
+1. **中央要素を根にする**
+   ソート済みリストの真ん中の値を根ノードにする。これにより左右の要素数がほぼ等しくなり、高さ平衡が保たれる。
+
+2. **インデックスで範囲管理（スライスコピー回避）**
+   `nums[lo:hi]` のようなスライスは新しいリストを生成してしまう（O(n) のメモリ追加コスト）。代わりに `lo`・`hi` という左右端のインデックスを引数で渡すことで、コピーなし O(1) の範囲移動を実現する。
+
+3. **再帰で左右を構築**
+   中央より左の範囲 `[lo, mid-1]` と右の範囲 `[mid+1, hi]` に対して、同じ処理を再帰的に繰り返す。分割統治法（＝問題を小さな問題に分けて解き、結果を組み合わせる手法）の典型的な使い方。
+
+4. **ベースケースは「空区間」**
+   `lo > hi` のとき有効な要素がないため `None` を返す。これが再帰の終了条件。
+
+5. **計算量**
+    - 時間計算量：O(n) — 全ノードをちょうど 1 回ずつ処理する
+    - 空間計算量：O(log n) — 再帰スタックの深さ = 木の高さ（log₂n 段）
+
+> 📖 **この章で登場した用語**
+>
+> - **分割統治法**: 問題を小さな部分問題に分割し、それぞれを再帰で解いて結果を組み合わせる手法
+> - **スライスコピー**: `nums[lo:hi]` のようにリストの一部を取り出す操作。新しいリストを生成するためメモリコストが発生する
+> - **再帰**: 関数が自分自身を呼び出すこと。大きな問題を同じ構造の小さな問題に分割して解くときに使う
+> - **ベースケース（基底条件）**: 再帰を止める条件。これがないと無限ループになる
+
+---
+
+<h2 id="figures">図解</h2>
+
+> 💡 **Mermaid フローチャートの読み方：** ひし形 `{}` は「条件分岐（Yes/No の判定）」を表し、長方形 `[]` は「処理ステップ」を表します。矢印の向きがデータの流れる方向です。上から下へ読み進めてください。
+
+---
+
+### フローチャート
+
+この図は `build(lo, hi)` 関数がどのように動作するかの処理の流れを表しています。上から下へ読み進め、再帰がどのように木を組み立てていくかを追ってください。
+
+```mermaid
+flowchart TD
+  Start[Start build lo hi]
+  Start --> BaseCheck{lo &gt; hi}
+  BaseCheck -- Yes --> RetNone[Return None]
+  BaseCheck -- No --> CalcMid[mid = lo plus hi divided by 2]
+  CalcMid --> MakeNode[node = TreeNode nums at mid]
+  MakeNode --> RecLeft[node.left = build lo mid minus 1]
+  RecLeft --> RecRight[node.right = build mid plus 1 hi]
+  RecRight --> RetNode[Return node]
+```
+
+**各ノードの意味：**
+
+- `Start[Start build lo hi]`：`lo`（左端インデックス）と `hi`（右端インデックス）を受け取って関数を開始する
+- `BaseCheck{lo &gt; hi}`：区間が空かどうかを判定する条件分岐（ひし形）。空なら再帰終了
+- `RetNone[Return None]`：子ノードが存在しないことを `None` で表して返す
+- `CalcMid[mid = lo plus hi divided by 2]`：中央インデックスを計算する（床除算で切り捨て）
+- `MakeNode[node = TreeNode nums at mid]`：中央の値で新しいノードを生成する
+- `RecLeft[node.left = build lo mid minus 1]`：左半分の範囲で再帰呼び出し
+- `RecRight[node.right = build mid plus 1 hi]`：右半分の範囲で再帰呼び出し
+- `RetNode[Return node]`：左右の子が接続されたノードを返す
+
+---
+
+### データフロー図
+
+この図は `nums = [-10, -3, 0, 5, 9]` が渡されたとき、どのように木構造に変換されるかのデータの流れを表しています。左から右へ読み進めてください。
+
+```mermaid
+graph LR
+  subgraph Input
+    A[nums -10 -3 0 5 9]
+  end
+  subgraph Step1
+    A --> B[mid=2 root=0]
+  end
+  subgraph Step2_Left
+    B --> C[lo=0 hi=1 mid=0 node=-10]
+    C --> D[lo=1 hi=1 mid=1 node=-3]
+    C --> E[lo=0 hi=-1 None]
+  end
+  subgraph Step2_Right
+    B --> F[lo=3 hi=4 mid=3 node=5]
+    F --> G[lo=4 hi=4 mid=4 node=9]
+    F --> H[lo=3 hi=2 None]
+  end
+  subgraph Output
+    B --> Z[BST root=0]
+  end
+```
+
+**主要な流れの説明：**
+
+- `Input → Step1`：入力リスト全体（インデックス 0〜4）の中央 `mid=2` を選び、根ノード `0` を作る
+- `Step1 → Step2_Left`：左半分 `[lo=0, hi=1]` を再帰処理。中央は `mid=0` → ノード `-10` が親、ノード `-3` がその右の子
+- `Step1 → Step2_Right`：右半分 `[lo=3, hi=4]` を再帰処理。中央は `mid=3` → ノード `5` が親、ノード `9` がその右の子
+- `None` の箱：`lo > hi` になった空区間で再帰終了
+
+---
+
+### 代表例でのトレース
+
+`nums = [-10, -3, 0, 5, 9]` を入力として、上記フローチャートの各ノードを通過する様子をステップごとに示します。
+
+```
+初期呼び出し: build(lo=0, hi=4)
+─────────────────────────────────────────────────────
+Step 1:  BaseCheck → lo(0) <= hi(4) → No → 続行
+Step 2:  CalcMid   → mid = (0+4)//2 = 2
+Step 3:  MakeNode  → node = TreeNode(nums[2]) = TreeNode(0)  ← 根ノード確定！
+
+  ┌── 左の再帰: build(lo=0, hi=1)
+  │   Step 4:  mid = (0+1)//2 = 0
+  │   Step 5:  node = TreeNode(nums[0]) = TreeNode(-10)
+  │
+  │   ├── 左の再帰: build(lo=0, hi=-1)
+  │   │   Step 6:  BaseCheck → lo(0) > hi(-1) → Yes → return None
+  │   │
+  │   └── 右の再帰: build(lo=1, hi=1)
+  │       Step 7:  mid = (1+1)//2 = 1
+  │       Step 8:  node = TreeNode(nums[1]) = TreeNode(-3)
+  │       Step 9:  build(1,0) → None, build(2,1) → None
+  │       return TreeNode(-3, None, None)  ← 葉ノード
+  │
+  │   TreeNode(-10).right = TreeNode(-3)
+  │   return TreeNode(-10, left=None, right=TreeNode(-3))
+
+  └── 右の再帰: build(lo=3, hi=4)
+      Step 10: mid = (3+4)//2 = 3
+      Step 11: node = TreeNode(nums[3]) = TreeNode(5)
+      Step 12: build(3,2) → None
+      Step 13: build(lo=4, hi=4): mid=4 → TreeNode(9) → 葉ノード
+      return TreeNode(5, left=None, right=TreeNode(9))
+
+─────────────────────────────────────────────────────
+完成した BST:
+         0          ← 根
+        / \
+      -10    5
+        \     \
+        -3     9
+
+高さ確認:
+  左部分木の高さ = 2（0 → -10 → -3）
+  右部分木の高さ = 2（0 → 5  → 9）
+  差 = 0  ✅ 高さ平衡！
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **フローチャート**: 処理の手順を図形と矢印で表したもの。ひし形 = 条件分岐、長方形 = 処理ステップ
+> - **データフロー図**: データがどのように変換・移動するかを示す図
+> - **葉ノード**: 左右両方の子が `None` のノード。木の末端
+> - **床除算 `//`**: 小数点以下を切り捨てる割り算。`(0+4)//2 = 2`
+
+---
+
+<h2 id="correctness">正しさのスケッチ</h2>
+
+> 💡 この章では、「なぜこのアルゴリズムが常に正しい答えを返せるのか」の根拠を整理します。数学的な証明ではなく「なぜ正しいと言えるか」の直感的な説明です。
+
+---
+
+### ① 不変条件（Invariant）
+
+> **不変条件（＝アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件）** を確認します。
+
+`build(lo, hi)` を呼び出すたびに、以下の条件が常に成り立ちます：
+
+- `nums[lo..hi]` は**昇順ソート済み**である（元のリストを変更しないため、常にこの性質が保たれる）
+- 中央インデックス `mid = (lo+hi)//2` を選ぶことで、左側の要素数 `(mid-lo)` と右側の要素数 `(hi-mid)` の差は**常に 1 以下**になる
+
+具体例：`lo=0, hi=4` → `mid=2` → 左 2 個・右 2 個（差=0）
+具体例：`lo=0, hi=3` → `mid=1` → 左 1 個・右 2 個（差=1）
+
+この「差が常に 1 以下」という性質が、**高さ平衡を再帰の全ステップで保証**しています。
+
+---
+
+### ② 網羅性（Completeness）
+
+> **網羅性（＝すべてのケースをもれなく処理できているという保証）** を確認します。
+
+`nums` の各要素は、ちょうど 1 回だけ `nums[mid]` として選ばれてノードになります。選ばれた要素は左か右の再帰には渡されません（左は `[lo, mid-1]`、右は `[mid+1, hi]`）。よってすべての要素がもれなくノードになることが保証されます。
+
+---
+
+### ③ 基底条件（Base Case）
+
+> **基底条件（＝再帰の終了条件）** を確認します。
+
+`lo > hi` のとき、有効な要素が 1 つも存在しない空区間です。この場合 `None` を返すことで「子ノードが存在しない」ことを表現します。
+
+- 1 要素の区間（`lo == hi`）：`mid = lo`、左 `build(lo, lo-1)` → `lo > hi` で `None`、右も同様 → 葉ノード（＝子が両方 `None` のノード）が正しく作られる
+
+---
+
+### ④ 終了性（Termination）
+
+> **終了性（＝アルゴリズムが必ず有限ステップで終わるという保証）** を確認します。
+
+各再帰呼び出しで区間 `[lo, hi]` のサイズが必ず 1 以上減少します（中央の `mid` を除いた左右に分割するため）。区間サイズが 0 になると `lo > hi` の条件を満たして必ず返却されます。よってアルゴリズムは必ず終了します。
+
+> 📖 **この章で登場した用語**
+>
+> - **不変条件**: アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件
+> - **網羅性**: すべてのケースをもれなく処理できているという保証
+> - **基底条件**: 再帰の終了条件。これがないと無限ループになる
+> - **終了性**: アルゴリズムが必ず有限ステップで終わるという保証
+
+---
+
+<h2 id="complexity">計算量</h2>
+
+> 💡 計算量とは「入力が大きくなるにつれて、処理にかかる時間・メモリがどう増えるか」の目安です。
+
+| 記法         | 意味                                       | 直感的なイメージ           |
+| ------------ | ------------------------------------------ | -------------------------- |
+| `O(1)`       | 入力サイズによらず一定                     | 辞書で直接ページを開く     |
+| `O(log n)`   | 入力が 2 倍になっても 1 ステップ増えるだけ | 二分探索で毎回半分に絞る   |
+| `O(n)`       | 入力に比例して増加                         | リストを端から順に読む     |
+| `O(n log n)` | n よりやや速く増加                         | ソートの典型的な計算量     |
+| `O(n²)`      | 入力の 2 乗で増加                          | 全ペアを総当たりで確認する |
+
+---
+
+### 時間計算量：O(n)
+
+`nums` の各要素はちょうど 1 回だけ `TreeNode(nums[mid])` として処理されます。n 個の要素があれば n 回ノードが生成され、それ以外の処理（インデックス計算・代入）も O(1) です。よって全体で **O(n)** となります。
+
+---
+
+### 空間計算量：O(log n)
+
+スライスコピーを使わないため、アルゴリズムが使う追加メモリは**再帰スタック（＝関数の呼び出し履歴を記録するメモリ）**のみです。
+
+木の高さは `log₂(n)` 程度（高さ平衡なので）であり、再帰の深さも同様です。`n = 10,000` のとき最大深度は `log₂(10000) ≈ 14` 段です。
+
+---
+
+### スライス版との比較
+
+| 実装方式                     | 時間計算量 | 空間計算量 | 特徴                               |
+| ---------------------------- | ---------- | ---------- | ---------------------------------- |
+| **インデックス版（本実装）** | O(n)       | O(log n)   | スライスコピーなし・メモリ効率最良 |
+| スライス版 `nums[:mid]`      | O(n log n) | O(n log n) | 再帰ごとにコピーが発生・実装は簡単 |
+
+スライス版が O(n log n) になる理由：再帰の各階層でサイズ n/2, n/4, ... のコピーが発生し、合計すると `n + n/2 + n/4 + ... ≈ 2n` × `log n` 階層 = O(n log n) のメモリを使います。
+
+> 📖 **この章で登場した用語**
+>
+> - **時間計算量**: 入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**: 処理中に使うメモリ量がどう増えるかの目安
+> - **再帰スタック**: 関数が自分を呼び出すたびに「戻り先」情報が積み上がるメモリ領域
+> - **in-place**: 新しいメモリを確保せず元のデータを直接書き換える操作
+
+---
+
+<h2 id="impl">Python 実装</h2>
+
+> 💡 コードを読む前に全体の骨格を確認しましょう。
+
+**実装の骨格：**
+
+1. `sortedArrayToBST`（公開メソッド）：入力を受け取り、ヘルパー `_build` を全体範囲で呼び出す
+2. `_build`（内部ヘルパー）：`lo`/`hi` インデックスで現在の処理区間を管理する
+3. **ベースケース**：`lo > hi` なら `None` を返して再帰終了
+4. **中央計算**：`mid = (lo + hi) // 2` で床除算
+5. **ノード生成**：`TreeNode(nums[mid])` で中央値のノードを作る
+6. **左右再帰**：`[lo, mid-1]` と `[mid+1, hi]` でそれぞれ再帰して `node.left`/`node.right` に代入
+7. **返却**：完成したノードを返す
+
+---
+
+### 業務開発版（型安全・pylance 対応・コメント充実）
+
+```python
+from __future__ import annotations
+# ^ 型ヒントの前方参照（＝まだ定義されていない型名を文字列として扱う宣言）を有効にする。
+# TreeNode を Optional[TreeNode] のように自己参照する型注釈で使うために必要。
+
+from typing import TYPE_CHECKING, Optional
+
+# TYPE_CHECKING ブロックは pylance/mypy などの型チェッカーが読み込む時だけ実行される。
+# 実行時には無視されるため、LeetCode の実行環境に TreeNode が定義済みでも
+# 定義されていなくても、どちらでも安全に動く設計になっている。
+if TYPE_CHECKING:
+    pass
+
+
+class Solution:
+    """
+    LeetCode 108: Convert Sorted Array to Binary Search Tree
+    昇順ソート済みリストを高さ平衡な BST に変換するクラス（業務開発版）
+
+    設計方針:
+    - スライスコピーを避けるため lo/hi インデックスで範囲管理 → Space O(log n)
+    - 型ヒントを全箇所に付けて pylance 対応
+    - バリデーションをメインメソッドで行い、_build は純粋なアルゴリズムに集中
+    """
+
+    def sortedArrayToBST(self, nums: list[int]) -> Optional[TreeNode]:
+        """
+        昇順ソート済みリストを高さ平衡な BST のルートノードに変換する。
+
+        Args:
+            nums: 昇順ソートされた整数リスト（重複なし）
+
+        Returns:
+            BST のルートノード。
+
+        Raises:
+            TypeError:  nums がリスト型でない場合
+            ValueError: nums が空リストの場合
+
+        Complexity:
+            Time:  O(n)      — 全要素を 1 回ずつ処理
+            Space: O(log n)  — 再帰スタックの深さ = 木の高さ
+        """
+        # 型チェック: Python は動的型付けのため、呼び出し元が誤った型を渡す可能性がある。
+        # isinstance() で実行時に型を確認し、分かりやすいエラーを早期に発生させる。
+        if not isinstance(nums, list):
+            raise TypeError(f"Expected list, got {type(nums).__name__}")
+
+        # 空リストチェック: 問題制約では len >= 1 だが、
+        # 業務コードでは想定外の入力にも対応するために確認する。
+        if not nums:
+            raise ValueError("nums must not be empty")
+
+        # 全体範囲（インデックス 0 〜 末尾）でヘルパーを呼び出して再帰開始
+        return self._build(nums, 0, len(nums) - 1)
+
+    def _build(self, nums: list[int], lo: int, hi: int) -> Optional[TreeNode]:
+        """
+        インデックス [lo, hi] の範囲で BST を再帰構築する内部ヘルパー。
+
+        Args:
+            nums: 元の昇順ソート済みリスト（変更しない）
+            lo:   処理対象区間の左端インデックス（この位置を含む）
+            hi:   処理対象区間の右端インデックス（この位置を含む）
+
+        Returns:
+            構築されたサブツリーのルートノード、または None（区間が空のとき）
+        """
+        # ベースケース（再帰の終了条件）:
+        # lo > hi になった時点で有効な要素が存在しない空区間なので None を返す。
+        # None は「子ノードが存在しない」ことを表す。
+        # Optional[TreeNode] という型ヒントで「None になり得る」ことを明示している。
+        if lo > hi:
+            return None
+
+        # 中央インデックスを計算する。
+        # `//` は床除算（＝小数点以下を切り捨てる割り算）。
+        # `(lo + hi) / 2` だと float が返るが、`//` なら int が直接返るため
+        # インデックスとして安全に使える。pylance も int 型として認識する。
+        mid: int = (lo + hi) // 2
+
+        # 中央の値でノードを作成する。
+        # このノードが現在の区間の「根（ルート）」になる。
+        # TreeNode のコンストラクタはデフォルトで left=None, right=None を持つ。
+        node = TreeNode(nums[mid])
+
+        # 左部分木を再帰的に構築する。
+        # [lo, mid-1] の範囲（= 中央より左の要素すべて）で同じ処理を繰り返す。
+        # mid 自体は今のノードとして使用済みなので含まない（mid-1 まで）。
+        node.left = self._build(nums, lo, mid - 1)
+
+        # 右部分木を再帰的に構築する。
+        # [mid+1, hi] の範囲（= 中央より右の要素すべて）で同じ処理を繰り返す。
+        node.right = self._build(nums, mid + 1, hi)
+
+        # 左右の子が接続された完成ノードを返す。
+        # 呼び出し元では、これが node.left または node.right に代入される。
+        return node
+```
+
+---
+
+### 競技プログラミング版（簡潔・最小記述）
+
+```python
+from __future__ import annotations
+from typing import Optional
+
+
+class Solution:
+    def sortedArrayToBST(self, nums: list[int]) -> Optional[TreeNode]:
+        # ネスト関数（クロージャ）として定義。
+        # nums を引数で毎回渡さずに外側の変数を参照できるため記述が短くなる。
+        def build(lo: int, hi: int) -> Optional[TreeNode]:
+            # lo > hi のとき空区間 → None で再帰終了
+            if lo > hi:
+                return None
+            # 中央インデックス
+            mid = (lo + hi) // 2
+            # ノード生成と左右の再帰をまとめて記述
+            node = TreeNode(nums[mid])
+            node.left, node.right = build(lo, mid - 1), build(mid + 1, hi)
+            return node
+
+        return build(0, len(nums) - 1)
+```
+
+---
+
+### コードの動作トレース（`nums = [-10, -3, 0, 5, 9]`）
+
+```
+sortedArrayToBST([-10, -3, 0, 5, 9]) を呼び出す
+
+呼び出し: _build(nums, 0, 4)
+  → lo=0 <= hi=4 → 続行
+  → mid = (0+4)//2 = 2
+  → node = TreeNode(nums[2]) = TreeNode(0)   ← 根ノード確定
+  → node.left  = _build(nums, 0, 1)
+  → node.right = _build(nums, 3, 4)
+
+  _build(nums, 0, 1)  [左半分 -10, -3]
+    → mid = (0+1)//2 = 0
+    → node = TreeNode(nums[0]) = TreeNode(-10)
+    → node.left  = _build(nums, 0, -1) → lo(0)>hi(-1) → None
+    → node.right = _build(nums, 1, 1)
+      → mid=1, node=TreeNode(-3)
+      → left  = _build(1,0) → None
+      → right = _build(2,1) → None
+      → return TreeNode(-3)   ← 葉ノード
+    → return TreeNode(-10, left=None, right=TreeNode(-3))
+
+  _build(nums, 3, 4)  [右半分 5, 9]
+    → mid = (3+4)//2 = 3
+    → node = TreeNode(nums[3]) = TreeNode(5)
+    → node.left  = _build(3,2) → None
+    → node.right = _build(4,4)
+      → mid=4, node=TreeNode(9)
+      → left = right = None
+      → return TreeNode(9)   ← 葉ノード
+    → return TreeNode(5, left=None, right=TreeNode(9))
+
+最終結果:
+  TreeNode(0,
+    left  = TreeNode(-10, left=None, right=TreeNode(-3)),
+    right = TreeNode(5,   left=None, right=TreeNode(9))
+  )
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **`Optional[X]`**: `X` または `None` のどちらかであることを表す型ヒント。pylance はこの型を見て「None チェックが必要」と判断できる
+> - **`TYPE_CHECKING`**: 型チェッカーが読む時だけ `True` になる定数。実行時のインポートコストを避けるために使う
+> - **ネスト関数（クロージャ）**: 関数の中に定義した関数。外側の変数（`nums`）を引数なしで参照できる
+> - **`//`（床除算）**: 小数点以下を切り捨てる割り算演算子。`(0+4)//2 = 2` のように整数を返す
+> - **`from __future__ import annotations`**: 型ヒントを文字列として扱うようにする宣言。前方参照の問題を解決する
+
+---
+
+<h2 id="cpython">CPython 最適化ポイント</h2>
+
+> 💡 この章では「同じ処理でも Python の書き方によって速さが変わる理由」を説明します。最適化の前後のコードを比較して、なぜ速くなるかを確認してください。
+
+---
+
+### ポイント 1：スライスコピーを避ける
+
+スライス（`nums[lo:hi]`）は呼び出すたびに新しいリストをヒープ上に生成します。CPython では `list` のスライスは C 言語レベルの `memcpy` が走りますが、それでも O(n) のメモリ確保コストは避けられません。
+
+```python
+# ❌ 最適化前：再帰ごとにスライスコピーが発生（Space O(n log n)）
+def bad_build(nums: list[int]) -> Optional[TreeNode]:
+    if not nums:
+        return None
+    mid = len(nums) // 2
+    node = TreeNode(nums[mid])
+    node.left  = bad_build(nums[:mid])      # ← 新しいリストを毎回生成！
+    node.right = bad_build(nums[mid + 1:])  # ← 同上
+    return node
+
+# ✅ 最適化後：インデックスのみを渡してコピーなし（Space O(log n)）
+def build(lo: int, hi: int) -> Optional[TreeNode]:
+    if lo > hi:
+        return None
+    mid = (lo + hi) // 2
+    node = TreeNode(nums[mid])
+    node.left  = build(lo, mid - 1)  # ← ポインタとインデックスだけ変わる
+    node.right = build(mid + 1, hi)
+    return node
+# 理由：スライスは「ポインタ + 長さ」の情報だけ変えれば参照できるが、
+#       Python の list スライスは必ず新しい list オブジェクトを確保してしまう。
+#       インデックスを渡す設計なら int 2 個の受け渡しだけで済む。
+```
+
+---
+
+### ポイント 2：床除算 `//` を使う
+
+中央インデックスの計算には `//`（床除算）を使います。`int(...)` や `math.floor(...)` と比べて、`//` は CPython の整数型（`int`）同士に対してC言語レベルの最適化が適用され、型変換コストがありません。
+
+```python
+# ❌ 最適化前：float 経由で型変換コストが発生
+mid = int((lo + hi) / 2)   # / が float を返す → int() で変換
+
+# ✅ 最適化後：整数演算のみ・pylance も int 型として正しく認識
+mid: int = (lo + hi) // 2  # // は直接 int を返す
+```
+
+---
+
+### ポイント 3：再帰深度は問題ない（`sys.setrecursionlimit` 不要）
+
+CPython のデフォルト再帰上限は **1,000 回** です。本問の制約 `n ≤ 10^4` では木の高さが最大 `⌈log₂(10000)⌉ = 14` 段なので、再帰深度は最大 14 回程度です。`sys.setrecursionlimit()` の変更は不要です。
+
+```python
+import math
+# n = 10^4 のとき、高さ平衡な木の最大高さを確認する
+max_depth = math.ceil(math.log2(10_000))  # → 14
+# 14 << 1000（デフォルト上限）なので安全
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **ヒープ（heap）**: 動的にサイズが変わるデータを置くメモリ領域。スライスで新しいリストを作るとここに確保される
+> - **`memcpy`**: C 言語の関数。メモリをブロックごとコピーする高速操作。Python のスライスも内部でこれを使う
+> - **再帰上限（recursion limit）**: Python が関数の入れ子呼び出しを許容する回数の上限。デフォルト 1000
+> - **床除算 `//`**: 小数点以下を切り捨てる割り算演算子。整数同士で使うと型変換なしで高速に動く
+
+---
+
+<h2 id="edgecases">エッジケースと検証観点</h2>
+
+> 💡 エッジケースとは「空リスト・要素 1 つ・最大サイズ」など、通常とは異なる境界的な入力のことです。エッジケースを見落とすと、普通のテストは通るのに特定の入力でだけバグが発生することがあります。
+
+---
+
+| ケース                       | 入力例              | 期待される出力                             | なぜ問題になりうるか                                                         |
+| ---------------------------- | ------------------- | ------------------------------------------ | ---------------------------------------------------------------------------- |
+| **要素 1 つ**                | `[0]`               | `TreeNode(0)`                              | `build(0,0)` → `mid=0`、左右ともに空区間 → 葉ノードになるかの確認            |
+| **要素 2 つ**                | `[1, 3]`            | `TreeNode(1, None, TreeNode(3))`           | `mid=0` が選ばれ、左は空、右が 1 要素になる。`[3, 1]` も正解として受理される |
+| **すべて負の数**             | `[-9, -3, -1]`      | `TreeNode(-3, TreeNode(-9), TreeNode(-1))` | 値の正負はインデックス計算に影響しないため同じ動作になるはずの確認           |
+| **すべて同じ符号の大きな数** | `[10000]` など      | —                                          | 制約内の境界値での動作確認                                                   |
+| **最大サイズ n=10^4**        | 長さ 10000 のリスト | —                                          | 再帰深度 ≈ 14 → CPython の上限 1000 に余裕で収まる                           |
+| **空リスト（業務版のみ）**   | `[]`                | `ValueError` が発生する                    | 問題制約外だが業務コードでは想定外入力への対応が必要                         |
+
+---
+
+### 各エッジケースの詳細説明
+
+**① 要素 1 つ `[0]`**
+
+```
+build(lo=0, hi=0):
+  lo(0) <= hi(0) → 続行
+  mid = (0+0)//2 = 0
+  node = TreeNode(0)
+  left  = build(0, -1) → lo(0) > hi(-1) → None  ← ここが正しく動くかの確認
+  right = build(1,  0) → lo(1) > hi(0)  → None
+  return TreeNode(0, None, None)  ← 葉ノード ✅
+```
+
+**② 要素 2 つ `[1, 3]`**
+
+```
+build(lo=0, hi=1):
+  mid = (0+1)//2 = 0   ← 左端が根になる
+  node = TreeNode(1)
+  left  = build(0, -1) → None
+  right = build(1,  1) → TreeNode(3)
+  return TreeNode(1, None, TreeNode(3))
+
+※ LeetCode は [1, null, 3] と [3, 1] の両方を正解として受理する
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **エッジケース**: 空のリスト・要素 1 つ・最大サイズ入力など、境界的な条件のこと
+> - **境界値**: 制約の上限・下限にあたる値。例：長さ 1 や長さ 10^4 のリスト
+> - **葉ノード（leaf node）**: 子ノードを持たないノード（左右ともに None）。木の末端を形成する
+
+---
+
+<h2 id="faq">FAQ</h2>
+
+> 💡 ここでは初学者がつまずきやすいポイントを Q&A 形式で解説します。各回答は「結論 → 理由 → 補足（具体例）」の順で書いています。
+
+---
+
+**Q1. なぜ「真ん中」を根にすると高さ平衡になるのですか？**
+
+**結論：** 真ん中を選ぶと左右の要素数の差が最大 1 になるからです。
+
+**理由：** n 個の要素があり、`lo=0`, `hi=n-1` のとき、`mid = (lo + hi) // 2 = (n - 1) // 2` を選ぶと左に `mid` 個、右に `n - mid - 1` 個の要素が分配されます。実装は `(n - 1) // 2` を使うため、偶数 n のときは左側ではなく右側に要素が1つ多く入ります。この差は最大 1 です。これを再帰の全ステップで行うため、どの階層でも左右の高さの差が 1 を超えません。
+
+**補足（具体例）：**
+
+```
+n=5: left=2個, right=2個  → 差=0
+n=4: left=1個, right=2個  → 差=1
+n=3: left=1個, right=1個  → 差=0
+n=2: left=0個, right=1個  → 差=1
+n=1: left=0個, right=0個  → 差=0
+```
+
+すべてのケースで差が 1 以下です。
+
+---
+
+**Q2. スライス `nums[:mid]` を使わないのはなぜですか？**
+
+**結論：** スライスは毎回リストをコピーするため、不要なメモリを O(n log n) 使ってしまうからです。
+
+**理由：** Python のリストスライスは新しいリストオブジェクトを生成します。再帰の各階層でサイズ n/2, n/4, ... のコピーが発生し、全階層の合計は O(n log n) のメモリになります。インデックスを渡す設計では int 型 2 つ（lo, hi）だけを渡せばよく、コピーが一切発生しません。
+
+**補足：** スライス版は実装がシンプルで可読性が高いため、「コードの短さ・シンプルさを優先する競技プログラミング」では許容されることもあります。制限時間内に通れば問題ないからです。
+
+---
+
+**Q3. `lo > hi` のとき `None` を返す理由がよく分かりません。**
+
+**結論：** `lo > hi` は「有効な要素がない空の区間」を意味し、子ノードが存在しないことを `None` で表すからです。
+
+**理由：** 例えば 1 要素 `[5]` の区間 `[lo=0, hi=0]` を処理すると `mid=0` でノードを作り、その後 `build(0, -1)`（左）と `build(1, 0)`（右）が呼ばれます。`lo=0 > hi=-1` は「インデックス 0 から -1 まで」という空の区間なので、ノードを作る必要がなく `None` を返します。
+
+**補足：** `None` は Python の「値がない」を表すオブジェクトで、木のノードに「子がいない」を伝えるために使います。`TreeNode` の定義でも `left: Optional[TreeNode] = None` がデフォルトになっています。
+
+---
+
+**Q4. 業務開発版と競技プログラミング版の使い分けを教えてください。**
+
+**結論：** 長期メンテナンスするコードには業務版、即座に正解を提出することが目的のコードには競技版を使います。
+
+**理由：**
+
+| 観点                       | 業務開発版                         | 競技プログラミング版   |
+| -------------------------- | ---------------------------------- | ---------------------- |
+| 型チェック・バリデーション | あり（`isinstance`, `ValueError`） | なし（問題制約を信頼） |
+| pylance 対応               | 厳密な型注釈                       | 最低限の型注釈         |
+| コメント・docstring        | 充実                               | 最小限                 |
+| 関数の分離                 | `_build` を別メソッドに分離        | ネスト関数でシンプルに |
+
+**補足：** LeetCode の提出だけが目的なら競技版で十分です。しかし「このコードを半年後に自分が読む」「チームメンバーがレビューする」場面では業務版のコメント量と型注釈が重要になります。
+
+---
+
+**Q5. `Optional[TreeNode]` という型ヒントはなぜ必要ですか？**
+
+**結論：** `None` を返す可能性を型として明示することで、pylance が「None チェックを忘れている」というバグを実行前に検出できるからです。
+
+**理由：** Python は動的型付け言語なので型を書かなくても動きます。しかし `Optional[TreeNode]` と書いておくと、呼び出し側が `node.val` のように `None` チェックなしで属性アクセスしたとき pylance が警告を出してくれます。これはコンパイル言語（Java や C++）の `NullPointerException` の事前防止に相当します。
+
+**補足（型ヒントの読み方）：**
+
+```python
+Optional[TreeNode]  →  TreeNode または None のどちらか
+# Python 3.10 以降は以下のように書ける（同じ意味）
+TreeNode | None
+```
+
+---
+
+> 📖 **この章で登場した用語**
+>
+> - **FAQ（Frequently Asked Questions）**: よくある質問と回答のこと
+> - **動的型付け**: 実行時に型が決まる言語の特性。Python はこれに該当する
+> - **静的型チェック**: 実行前にコードを解析して型エラーを検出すること。pylance がこれを行う
+> - **`Optional[X]`**: `X` または `None` のどちらかであることを表す型ヒント。pylance が null 安全性を検証するために使う
+> - **トレードオフ**: 何かを得ると何かを失う関係。例：「コードのシンプルさを得ると型安全性が下がる」
diff --git a/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README_react.html b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README_react.html
new file mode 100644
index 0000000..d039a77
--- /dev/null
+++ b/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README_react.html	
@@ -0,0 +1,1680 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 108 - 昇順配列を高さ平衡BSTに変換</title>
+        <link
+            href="https://fonts.googleapis.com/css2?family=Noto+Sans+JP:wght@400;500;700&family=JetBrains+Mono:wght@400;500;700&family=Outfit:wght@700;800&display=swap"
+            rel="stylesheet"
+        />
+        <script src="https://cdn.tailwindcss.com"></script>
+        <link
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css"
+            rel="stylesheet"
+        />
+        <link
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/line-numbers/prism-line-numbers.min.css"
+            rel="stylesheet"
+        />
+        <link
+            href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/plugins/toolbar/prism-toolbar.min.css"
+            rel="stylesheet"
+        />
+        <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>
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .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;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            details[open] > summary .arrow {
+                transform: rotate(90deg);
+            }
+            .arrow {
+                display: inline-block;
+                transition: transform 0.2s;
+            }
+        </style>
+    </head>
+    <body class="bg-gradient-to-br from-emerald-50 via-white to-sky-50 min-h-screen p-4 md:p-8">
+        <div class="max-w-5xl mx-auto">
+            <!-- ===== HEADER ===== -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.15)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >LeetCode 108</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"
+                        >分割統治法</span
+                    >
+                </div>
+                <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Convert Sorted Array to Binary Search Tree
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    再帰 + インデックス渡し による O(n) / O(log n) 実装
+                </p>
+                <div
+                    class="mt-4 text-base text-teal-800 bg-white/70 rounded-xl px-4 py-3 inline-block"
+                >
+                    💡
+                    一言で言うと：「昇順ソート済みリストを、左右の高さが均等な二分探索木（BST）に変換する問題」
+                </div>
+                <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="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 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-700 text-sm mt-2 leading-7">
+                        昇順ソート済みリストを受け取り、<strong
+                            >左右の部分木の高さの差が常に 1 以下</strong
+                        >（＝高さ平衡）になる二分探索木（BST）のルートノードを返す問題です。「真ん中の要素を根にする」という発想が核心で、これを再帰的に繰り返すことで自然に平衡が実現されます。
+                    </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-1 list-disc list-inside leading-7">
+                        <li>
+                            端から順に
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >insert()</code
+                            >
+                            を繰り返すと、毎回右の子に追加されて「竹のような一本道の木」になり、高さが
+                            O(n) になる
+                        </li>
+                        <li>
+                            高さ平衡の条件を満たすには、<strong>どの値を根に選ぶか</strong>を戦略的に決める必要がある
+                        </li>
+                        <li>
+                            スライス
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >nums[:mid]</code
+                            >
+                            を使うと再帰ごとにリストコピーが発生し、空間計算量が O(n log n)
+                            に悪化する
+                        </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(log n)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono break-all leading-tight">
+                            分割統治法
+                        </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-sm font-mono">再帰</div>
+                        <div class="text-xs mt-1">実装方式</div>
+                    </div>
+                </div>
+
+                <div class="grid md:grid-cols-2 gap-4 mb-5">
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <p class="text-slate-600 font-semibold text-sm mb-2">入出力例 1</p>
+                        <p class="font-mono text-xs text-slate-500 mb-1">
+                            入力: nums = [-10, -3, 0, 5, 9]
+                        </p>
+                        <p class="font-mono text-xs text-slate-500 mb-2">
+                            出力: [0, -3, 9, -10, null, 5]
+                        </p>
+                        <p class="text-slate-600 text-xs leading-6">
+                            → 配列の中央
+                            <code class="bg-slate-100 px-1 rounded font-mono">0</code
+                            >（インデックス2）を根にすることで、左右に各2要素ずつ分配でき、高さ平衡が実現されます。
+                        </p>
+                    </div>
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <p class="text-slate-600 font-semibold text-sm mb-2">入出力例 2</p>
+                        <p class="font-mono text-xs text-slate-500 mb-1">入力: nums = [1, 3]</p>
+                        <p class="font-mono text-xs text-slate-500 mb-2">
+                            出力: [3, 1] または [1, null, 3]
+                        </p>
+                        <p class="text-slate-600 text-xs leading-6">
+                            → 2要素の場合、中央インデックス
+                            <code class="bg-slate-100 px-1 rounded font-mono"
+                                >mid = (0+1)//2 = 0</code
+                            >
+                            なので
+                            <code class="bg-slate-100 px-1 rounded font-mono">1</code>
+                            が根になります。どちらの形も正解として受理されます。
+                        </p>
+                    </div>
+                </div>
+
+                <div class="rounded-xl bg-slate-50 border border-slate-200 p-4">
+                    <p class="text-slate-600 font-semibold text-sm mb-2">📌 制約</p>
+                    <ul class="text-slate-500 text-sm space-y-1 list-disc list-inside font-mono">
+                        <li>1 &lt;= nums.length &lt;= 10<sup>4</sup></li>
+                        <li>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></li>
+                        <li>nums は厳密な昇順（重複なし）</li>
+                    </ul>
+                </div>
+            </section>
+
+            <!-- ===== STEPS (React mount point) ===== -->
+            <div id="steps-react" class="mb-8"></div>
+
+            <!-- ===== CODE ===== -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 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 leading-7">
+                        <li>
+                            ネスト関数
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >build(lo, hi)</code
+                            >
+                            を定義して nums を引数なしで参照できるようにする
+                        </li>
+                        <li>
+                            ベースケース：<code
+                                class="bg-white px-1 rounded font-mono text-xs border"
+                                >lo &gt; hi</code
+                            >
+                            なら
+                            <code class="bg-white px-1 rounded font-mono text-xs border">None</code>
+                            を返して再帰終了
+                        </li>
+                        <li>
+                            中央インデックス
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >mid = (lo + hi) // 2</code
+                            >
+                            を計算して根ノードを作成
+                        </li>
+                        <li>左半分・右半分を再帰的に構築して左右の子に接続し、ノードを返す</li>
+                    </ol>
+                </div>
+
+                <pre class="line-numbers"><code class="language-python">from typing import Optional
+
+# 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 sortedArrayToBST(self, nums: list[int]) -&gt; Optional["TreeNode"]:
+        def build(lo: int, hi: int) -&gt; Optional["TreeNode"]:
+            # ベースケース：lo &gt; hi のとき空区間 → None を返して再帰終了
+            # この条件がないと無限ループになり RuntimeError が発生する
+            if lo &gt; hi:
+                return None
+
+            # 中央インデックスを床除算（//）で計算する
+            # スライス nums[lo:hi] を使わないのは、新しいリストのコピーが発生して
+            # 空間計算量が O(n log n) に悪化するため。インデックスなら O(1)。
+            mid = (lo + hi) // 2
+
+            # 中央の値でノードを作成（このノードが現在の区間の「根」になる）
+            # nums[mid] を根にすることで左右の要素数の差が常に 1 以下に保たれる
+            node = TreeNode(nums[mid])
+
+            # 左半分 [lo, mid-1] で左部分木を再帰構築
+            # mid 自体は現在のノードとして使用済みのため含まない（mid-1 まで）
+            node.left = build(lo, mid - 1)
+
+            # 右半分 [mid+1, hi] で右部分木を再帰構築
+            node.right = build(mid + 1, hi)
+
+            # 左右の子ノードが接続された完成ノードを返す
+            return node
+
+        # 全体の範囲（インデックス 0 〜 最後のインデックス）で再帰を開始
+        return build(0, len(nums) - 1)
+</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">
+                        ▶ 入力例 nums = [-10, -3, 0, 5, 9] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-6 overflow-x-auto whitespace-pre"
+                    >
+build(0, 4):
+  mid = 2 → node = TreeNode(0)    ← 根ノード確定！
+  node.left  = build(0, 1)
+    mid = 0 → node = TreeNode(-10)
+    node.left  = build(0, -1) → lo(0) &gt; hi(-1) → None
+    node.right = build(1, 1)
+      mid = 1 → node = TreeNode(-3) ← 葉ノード
+      return TreeNode(-3)
+    return TreeNode(-10, left=None, right=TreeNode(-3))
+  node.right = build(3, 4)
+    mid = 3 → node = TreeNode(5)
+    node.left  = build(3, 2) → lo(3) &gt; hi(2)  → None
+    node.right = build(4, 4)
+      mid = 4 → node = TreeNode(9)  ← 葉ノード
+      return TreeNode(9)
+    return TreeNode(5, left=None, right=TreeNode(9))
+
+完成した BST:
+         0          ← 根（配列の中央）
+        / \
+      -10    5
+         \    \
+         -3    9
+
+高さ: 左=2, 右=2  差=0  ✅ 高さ平衡！</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ===== DIAGRAM ===== -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 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="28" height="18">
+                                <ellipse
+                                    cx="14"
+                                    cy="9"
+                                    rx="13"
+                                    ry="8"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <rect
+                                    x="1"
+                                    y="3"
+                                    width="26"
+                                    height="12"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <polygon
+                                    points="14,1 27,9 14,17 1,9"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <rect
+                                    x="1"
+                                    y="3"
+                                    width="26"
+                                    height="12"
+                                    rx="3"
+                                    fill="#fee2e2"
+                                    stroke="#dc2626"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>赤ボックス＝ 終端処理</span>
+                        </div>
+                    </div>
+                    <div class="flex gap-6 mt-3 text-xs text-slate-600">
+                        <span
+                            ><span
+                                class="inline-block w-6 h-0.5 bg-emerald-500 align-middle mr-1"
+                            ></span
+                            >緑矢印＝「いいえ」（処理続行）</span
+                        >
+                        <span
+                            ><span
+                                class="inline-block w-6 h-0.5 bg-red-400 align-middle mr-1"
+                            ></span
+                            >赤矢印＝「はい」（早期終了）</span
+                        >
+                        <span
+                            ><span
+                                class="inline-block w-6 h-0.5 bg-slate-400 align-middle mr-1"
+                            ></span
+                            >グレー矢印＝通常フロー</span
+                        >
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto">
+                    <svg
+                        viewBox="0 0 560 680"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Convert Sorted Array to BST flowchart"
+                    >
+                        <defs>
+                            <marker
+                                id="fc-arrow"
+                                marker-width="10"
+                                marker-height="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                marker-units="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#64748b" />
+                            </marker>
+                            <marker
+                                id="fc-arrowGreen"
+                                marker-width="10"
+                                marker-height="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                marker-units="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#059669" />
+                            </marker>
+                            <marker
+                                id="fc-arrowRed"
+                                marker-width="10"
+                                marker-height="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                marker-units="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#dc2626" />
+                            </marker>
+                        </defs>
+
+                        <!-- 1. Start -->
+                        <ellipse
+                            cx="280"
+                            cy="46"
+                            rx="180"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="46"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="14"
+                            font-weight="700"
+                            fill="#065f46"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            開始: build(lo, hi)
+                        </text>
+
+                        <!-- Arrow 1→2 -->
+                        <line
+                            x1="280"
+                            y1="74"
+                            x2="280"
+                            y2="107"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 2. Diamond: lo > hi? -->
+                        <polygon
+                            points="280,107 400,150 280,193 160,150"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="146"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="700"
+                            fill="#92400e"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            lo &gt; hi ?
+                        </text>
+                        <text
+                            x="280"
+                            y="164"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#b45309"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            （空区間の確認）
+                        </text>
+
+                        <!-- "Yes" label + arrow to Return None -->
+                        <text
+                            x="418"
+                            y="136"
+                            text-anchor="start"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            はい
+                        </text>
+                        <line
+                            x1="400"
+                            y1="150"
+                            x2="466"
+                            y2="150"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- Return None box -->
+                        <rect
+                            x="466"
+                            y="128"
+                            width="84"
+                            height="44"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="508"
+                            y="147"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="700"
+                            fill="#991b1b"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            None
+                        </text>
+                        <text
+                            x="508"
+                            y="163"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            を返す
+                        </text>
+
+                        <!-- "No" label + arrow down -->
+                        <text
+                            x="247"
+                            y="210"
+                            text-anchor="end"
+                            font-size="11"
+                            fill="#059669"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            いいえ
+                        </text>
+                        <line
+                            x1="280"
+                            y1="193"
+                            x2="280"
+                            y2="233"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+
+                        <!-- 3. Box: mid計算 + node作成 -->
+                        <rect
+                            x="60"
+                            y="233"
+                            width="440"
+                            height="68"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="256"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            fill="#1e40af"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            mid = (lo + hi) // 2
+                        </text>
+                        <text
+                            x="280"
+                            y="280"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            fill="#1e40af"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            node = TreeNode(nums[mid])
+                        </text>
+
+                        <!-- Arrow 3→4 -->
+                        <line
+                            x1="280"
+                            y1="301"
+                            x2="280"
+                            y2="335"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 4. Box: 左部分木 -->
+                        <rect
+                            x="60"
+                            y="335"
+                            width="440"
+                            height="52"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="361"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            fill="#1e40af"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            node.left = build(lo, mid - 1)
+                        </text>
+
+                        <!-- Arrow 4→5 -->
+                        <line
+                            x1="280"
+                            y1="387"
+                            x2="280"
+                            y2="421"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 5. Box: 右部分木 -->
+                        <rect
+                            x="60"
+                            y="421"
+                            width="440"
+                            height="52"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="447"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            fill="#1e40af"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            node.right = build(mid + 1, hi)
+                        </text>
+
+                        <!-- Arrow 5→6 -->
+                        <line
+                            x1="280"
+                            y1="473"
+                            x2="280"
+                            y2="507"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 6. Box: return node -->
+                        <rect
+                            x="60"
+                            y="507"
+                            width="440"
+                            height="46"
+                            rx="8"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="530"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="700"
+                            fill="#065f46"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            return node
+                        </text>
+
+                        <!-- Arrow 6→7 -->
+                        <line
+                            x1="280"
+                            y1="553"
+                            x2="280"
+                            y2="587"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 7. End -->
+                        <ellipse
+                            cx="280"
+                            cy="613"
+                            rx="180"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="613"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="14"
+                            font-weight="700"
+                            fill="#065f46"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            終了（サブツリーのルートを返した）
+                        </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">
+                        🔎 入力例 nums = [-10, -3, 0, 5, 9] でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >build(0, 4)</code
+                            >
+                            が呼ばれる
+                        </li>
+                        <li>「lo &gt; hi?」→ 0 ≤ 4 なので「いいえ」の経路へ</li>
+                        <li>
+                            「mid を計算」→
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >mid=2, node=TreeNode(0)</code
+                            >
+                        </li>
+                        <li>
+                            「左部分木」→
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >build(0,1)</code
+                            >
+                            で同じフローを再帰実行し
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >TreeNode(-10, right=TreeNode(-3))</code
+                            >
+                            を構築
+                        </li>
+                        <li>
+                            「右部分木」→
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >build(3,4)</code
+                            >
+                            で
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >TreeNode(5, right=TreeNode(9))</code
+                            >
+                            を構築
+                        </li>
+                        <li>
+                            「return node」→ 根
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >TreeNode(0)</code
+                            >
+                            を返して終了
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ===== COMPLEXITY ===== -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 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(log n)</div>
+                            <div class="leading-5">
+                                入力の対数に比例<br /><span class="text-sky-600">例：二分探索</span>
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-teal-100 text-teal-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-teal-600"
+                                    >例：リストを1回走査</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-5">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-gradient-to-r from-emerald-50 to-sky-50">
+                                <th
+                                    class="text-left p-3 border border-slate-200 text-slate-700 font-semibold"
+                                >
+                                    計算量の種類
+                                </th>
+                                <th
+                                    class="text-center p-3 border border-slate-200 text-slate-700 font-semibold"
+                                >
+                                    本実装（インデックス版）
+                                </th>
+                                <th
+                                    class="text-center p-3 border border-slate-200 text-slate-700 font-semibold"
+                                >
+                                    スライス版（比較）
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr>
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    時間計算量
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span
+                                        class="font-mono font-bold text-emerald-700 bg-emerald-50 px-2 py-0.5 rounded"
+                                        >O(n)</span
+                                    >
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span
+                                        class="font-mono font-bold text-amber-700 bg-amber-50 px-2 py-0.5 rounded"
+                                        >O(n log n)</span
+                                    >
+                                </td>
+                            </tr>
+                            <tr class="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">
+                                    <span
+                                        class="font-mono font-bold text-emerald-700 bg-emerald-50 px-2 py-0.5 rounded"
+                                        >O(log n)</span
+                                    >
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span
+                                        class="font-mono font-bold text-amber-700 bg-amber-50 px-2 py-0.5 rounded"
+                                        >O(n log n)</span
+                                    >
+                                </td>
+                            </tr>
+                            <tr>
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    スライスコピー
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center text-emerald-700 font-semibold"
+                                >
+                                    なし ✅
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center text-red-500 font-semibold"
+                                >
+                                    あり（毎回コピー）❌
+                                </td>
+                            </tr>
+                            <tr class="bg-slate-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    n=10,000 時の再帰深度
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span class="font-mono text-slate-700">≈ 14 段</span>
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span class="font-mono text-slate-700">≈ 14 段</span>
+                                </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>
+                    <div class="text-slate-700 text-sm leading-7 space-y-2">
+                        <p>
+                            <strong>時間計算量 O(n)：</strong
+                            ><code class="bg-white px-1 rounded font-mono text-xs border"
+                                >nums</code
+                            >
+                            の各要素はちょうど1回だけ
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >TreeNode(nums[mid])</code
+                            >
+                            として処理されます。n 個の要素なら n
+                            回のノード生成が起こり、それ以外の処理（インデックス計算・代入）も O(1)
+                            なので全体 O(n) です。
+                        </p>
+                        <p>
+                            <strong>空間計算量 O(log n)：</strong
+                            >スライスコピーを使わないため、追加メモリは<strong>再帰スタック</strong>（＝関数の呼び出し履歴を記録するメモリ）のみです。高さ平衡な木の高さは
+                            log₂(n) 程度なので、n=10,000 のとき再帰深度は最大 ⌈log₂(10000)⌉ = 14
+                            段程度。Python のデフォルト再帰上限（1000回）に対して余裕があります。
+                        </p>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ===== GLOSSARY ===== -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit 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="arrow text-emerald-500 text-xs">▶</span> O記法（Big-O
+                            記法）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            入力サイズ n
+                            が大きくなるにつれて処理時間・メモリがどう増えるかを表す記法。O(n) は「n
+                            に比例して増える」、O(log n) は「n
+                            が2倍になっても処理は1ステップ増えるだけ」を意味します。常数倍の差は無視して、最も支配的な項だけで表します。
+                        </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="arrow text-emerald-500 text-xs">▶</span> 二分探索木（BST）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Binary Search Tree
+                            の略。各ノードについて「左の子はすべて自分より小さく、右の子はすべて自分より大きい」という規則を持つ木構造です。この規則のおかげで、平衡が保たれていれば検索・挿入を
+                            O(log n) で行えます。
+                        </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="arrow 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
+                            以下であること。平衡が崩れた BST は最悪
+                            O(n)（一本道の竹のような形）になりますが、高さ平衡が保たれていれば O(log
+                            n) を維持できます。
+                        </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="arrow text-emerald-500 text-xs">▶</span> 再帰（recursion）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数が自分自身を呼び出すこと。「同じ構造の小さな問題に分割できる」場面で有効です。マトリョーシカ人形のように、外側のフィギュアを開くと同じ形の小さいフィギュアが入っているイメージです。必ず「終了条件（ベースケース）」が必要で、これがないと無限ループになります。
+                        </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="arrow 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"
+                                >lo &gt; hi</code
+                            >（有効な要素がない空区間）がベースケースで、<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >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="arrow 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"
+                        >
+                            大きな問題を「分割（Divide）」→
+                            小さな問題を「統治（Conquer）＝再帰で解く」→
+                            結果を「結合（Combine）」する手法。本問では「配列を左右に分割 →
+                            各部分で再帰 → 左右の子ノードとして接続」がこのパターンに当たります。
+                        </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="arrow 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"
+                        >
+                            小数点以下を切り捨てる割り算。Python では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">//</code>
+                            演算子で表します。例：<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >(0+4)//2 = 2</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >(0+3)//2 = 1</code
+                            >。<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >int((0+4)/2)</code
+                            >
+                            と同じ結果ですが、CPython では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">//</code> は
+                            C言語レベルの整数演算に最適化されており、型変換コストがありません。
+                        </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="arrow 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"
+                        >
+                            関数が自分を呼び出すたびに「どこに戻るか」の情報が積み上がるメモリ領域。本問では木の高さ（log
+                            n 程度）分だけ積み重なります。Python のデフォルト上限は 1000
+                            段で、n=10,000 のとき本問の深さは最大 14 段なので余裕があります。
+                        </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="arrow 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"
+                                >nums[lo:hi]</code
+                            >
+                            のようにリストの一部を取り出す操作。Python
+                            では新しいリストオブジェクトがヒープ（動的メモリ領域）に生成されます。再帰のたびに呼ぶと
+                            O(n log n) のメモリが使われるため、本実装ではインデックス
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">lo</code
+                            >/<code class="bg-slate-100 px-1 rounded font-mono text-xs">hi</code>
+                            を渡すことでこのコストを O(1) に抑えています。
+                        </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="arrow text-emerald-500 text-xs">▶</span> 葉ノード（leaf
+                            node）
+                        </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">None</code>
+                            のノード。木の末端を形成します。本問では1要素の区間（lo=hi）から作られるノードが葉ノードになります（左右の子がともに空区間として
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">None</code>
+                            を返す）。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center py-6 text-slate-400 text-sm">
+                LeetCode 108 解説ページ ｜ React 18 + Tailwind CSS + Prism.js
+            </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 Steps Component -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const EX_NUMS = [-10, -3, 0, 5, 9];
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '全体区間を設定して再帰を開始する',
+                    desc: 'build(lo=0, hi=4) を呼び出します。lo は配列の先頭インデックス、hi は末尾インデックスです。この2つのインデックスだけで処理対象の範囲を表し、配列のコピーは一切作りません。なぜインデックスを使うかというと、nums[lo:hi] のようなスライスは新しいリストを生成してしまいメモリが O(n log n) 増えるからです。例として nums=[-10,-3,0,5,9] では lo=0, hi=4 の全5要素が最初の処理対象です。',
+                    lo: 0,
+                    hi: 4,
+                    mid: null,
+                    treeHighlight: [],
+                },
+                {
+                    step: 2,
+                    title: 'ベースケースを確認する（lo > hi?）',
+                    desc: 'lo=0 と hi=4 を比べます。0 ≤ 4 なので条件は「偽（False）」→ ノードを作成する処理へ進みます。なぜこの確認が必要かというと、再帰が深くなると lo > hi になる空区間が現れ、そこで None を返して再帰を終了させる必要があるからです。例として build(0,-1) が呼ばれたとき lo(0) > hi(-1) が真になり None を返します。この空区間チェックがないと無限ループになります。',
+                    lo: 0,
+                    hi: 4,
+                    mid: null,
+                    treeHighlight: [],
+                },
+                {
+                    step: 3,
+                    title: '中央インデックスを計算する',
+                    desc: 'mid = (lo + hi) // 2 = (0 + 4) // 2 = 2 を計算します。// は床除算（小数点以下切り捨て）です。なぜ中央を選ぶかというと、配列の真ん中の要素を根にすると左側と右側の要素数の差が最大1になり、自然と高さ平衡が実現されるからです。例として [0,4] の中央は 2、nums[2] = 0 がこの区間の根の値になります。辞書の「真ん中のページ」から引き始める二分探索と同じ発想です。',
+                    lo: 0,
+                    hi: 4,
+                    mid: 2,
+                    treeHighlight: [0],
+                },
+                {
+                    step: 4,
+                    title: '根ノードを作成する',
+                    desc: 'node = TreeNode(nums[2]) = TreeNode(0) を作成します。これが現在の区間全体の根ノードです。なぜ中央の値 0 が根になるかというと、0 より小さい値（-10, -3）を左部分木に、0 より大きい値（5, 9）を右部分木に自然に分配できるからです。BST の規則（左は小さく・右は大きく）を自動的に満たしながら、左右の要素数を均等にできます。',
+                    lo: 0,
+                    hi: 4,
+                    mid: 2,
+                    treeHighlight: [0],
+                },
+                {
+                    step: 5,
+                    title: '左部分木を再帰構築する',
+                    desc: 'node.left = build(lo=0, hi=1) を呼び出します。区間 [0, 1]（= nums[-10, -3]）で同じ処理を再帰的に繰り返します。なぜ [lo, mid-1] = [0, 1] かというと、mid=2 より左のインデックス（0〜1）の要素が BST の左部分木の値になるべきだからです（すべて 0 より小さい）。この再帰呼び出しでは mid=0、nums[0]=-10 が根になり、右の子に -3 がつく構造が作られます。',
+                    lo: 0,
+                    hi: 1,
+                    mid: 0,
+                    treeHighlight: [-10],
+                },
+                {
+                    step: 6,
+                    title: '右部分木を再帰構築する',
+                    desc: 'node.right = build(lo=3, hi=4) を呼び出します。区間 [3, 4]（= nums[5, 9]）で同じ処理を繰り返します。なぜ [mid+1, hi] = [3, 4] かというと、mid=2 より右のインデックス（3〜4）の要素が BST の右部分木の値になるべきだからです（すべて 0 より大きい）。この再帰では mid=3、nums[3]=5 が根になり、右の子に 9 がつきます。最終的に根=0、左=-10(-3付き)、右=5(9付き) の高さ平衡 BST が完成します！',
+                    lo: 3,
+                    hi: 4,
+                    mid: 3,
+                    treeHighlight: [5],
+                },
+            ];
+
+            function ArrayViz({ nums, lo, hi, mid }) {
+                const bw = 50,
+                    bh = 50,
+                    gap = 7;
+                const svgW = nums.length * (bw + gap) - gap + 20;
+                return (
+                    <svg
+                        viewBox={`0 0 ${svgW} 82`}
+                        style={{
+                            width: '100%',
+                            maxWidth: svgW + 'px',
+                            display: 'block',
+                            margin: '0 auto',
+                        }}
+                    >
+                        {nums.map((val, i) => {
+                            const x = 10 + i * (bw + gap);
+                            const inRange = lo !== null && hi !== null ? i >= lo && i <= hi : true;
+                            const isMid = mid !== null && i === mid;
+                            const fill = isMid ? '#10b981' : inRange ? '#bfdbfe' : '#f1f5f9';
+                            const textFill = isMid ? '#fff' : inRange ? '#1e40af' : '#94a3b8';
+                            const stroke = isMid ? '#059669' : inRange ? '#3b82f6' : '#e2e8f0';
+                            const sw = isMid ? 2.5 : 1;
+                            return (
+                                <g key={i}>
+                                    <text
+                                        x={x + bw / 2}
+                                        y={13}
+                                        textAnchor="middle"
+                                        fontSize={10}
+                                        fill="#94a3b8"
+                                        fontFamily="monospace"
+                                    >
+                                        {i}
+                                    </text>
+                                    <rect
+                                        x={x}
+                                        y={18}
+                                        width={bw}
+                                        height={bh}
+                                        rx={7}
+                                        fill={fill}
+                                        stroke={stroke}
+                                        strokeWidth={sw}
+                                    />
+                                    <text
+                                        x={x + bw / 2}
+                                        y={43}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize={14}
+                                        fontWeight={isMid ? '700' : '500'}
+                                        fill={textFill}
+                                        fontFamily="'JetBrains Mono', monospace"
+                                    >
+                                        {val}
+                                    </text>
+                                    {isMid && (
+                                        <text
+                                            x={x + bw / 2}
+                                            y={77}
+                                            textAnchor="middle"
+                                            fontSize={9}
+                                            fill="#059669"
+                                            fontFamily="sans-serif"
+                                        >
+                                            mid
+                                        </text>
+                                    )}
+                                    {!isMid && inRange && lo !== null && (
+                                        <text
+                                            x={x + bw / 2}
+                                            y={77}
+                                            textAnchor="middle"
+                                            fontSize={9}
+                                            fill="#3b82f6"
+                                            fontFamily="sans-serif"
+                                        >
+                                            {i === lo ? 'lo' : i === hi ? 'hi' : ''}
+                                        </text>
+                                    )}
+                                </g>
+                            );
+                        })}
+                    </svg>
+                );
+            }
+
+            function MiniTree({ highlight }) {
+                const nodes = [
+                    { val: 0, cx: 150, cy: 36, parent: null },
+                    { val: -10, cx: 72, cy: 96, parent: 0 },
+                    { val: -3, cx: 108, cy: 156, parent: -10 },
+                    { val: 5, cx: 228, cy: 96, parent: 0 },
+                    { val: 9, cx: 264, cy: 156, parent: 5 },
+                ];
+                const edges = [
+                    { x1: 150, y1: 57, x2: 72, y2: 75 },
+                    { x1: 150, y1: 57, x2: 228, y2: 75 },
+                    { x1: 72, y1: 117, x2: 108, y2: 135 },
+                    { x1: 228, y1: 117, x2: 264, y2: 135 },
+                ];
+                return (
+                    <svg
+                        viewBox="0 0 300 190"
+                        style={{
+                            width: '100%',
+                            maxWidth: '300px',
+                            display: 'block',
+                            margin: '0 auto',
+                        }}
+                    >
+                        {edges.map((e, i) => (
+                            <line
+                                key={i}
+                                x1={e.x1}
+                                y1={e.y1}
+                                x2={e.x2}
+                                y2={e.y2}
+                                stroke="#cbd5e1"
+                                strokeWidth={1.5}
+                            />
+                        ))}
+                        {nodes.map((n) => {
+                            const hl = highlight && highlight.includes(n.val);
+                            const fill = hl ? '#10b981' : '#e0f2fe';
+                            const tfill = hl ? '#fff' : '#1e40af';
+                            const stroke = hl ? '#059669' : '#93c5fd';
+                            return (
+                                <g key={n.val}>
+                                    <circle
+                                        cx={n.cx}
+                                        cy={n.cy}
+                                        r={21}
+                                        fill={fill}
+                                        stroke={stroke}
+                                        strokeWidth={hl ? 2.5 : 1.5}
+                                    />
+                                    <text
+                                        x={n.cx}
+                                        y={n.cy}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize={13}
+                                        fontWeight="500"
+                                        fill={tfill}
+                                        fontFamily="'JetBrains Mono', monospace"
+                                    >
+                                        {n.val}
+                                    </text>
+                                </g>
+                            );
+                        })}
+                    </svg>
+                );
+            }
+
+            function StepVisualization({ stepData }) {
+                const { lo, hi, mid, treeHighlight } = stepData;
+                return (
+                    <div className="mt-3 space-y-4">
+                        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200">
+                            <p className="text-xs text-slate-500 font-semibold mb-2 font-sans">
+                                配列の現在の処理範囲
+                            </p>
+                            <ArrayViz nums={EX_NUMS} lo={lo} hi={hi} mid={mid} />
+                        </div>
+                        <div className="grid grid-cols-2 gap-3">
+                            <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 font-mono text-xs">
+                                <div className="text-slate-500 mb-2 font-sans font-semibold">
+                                    🔍 現在の変数の状態
+                                </div>
+                                <div className="text-sky-700">lo = {lo !== null ? lo : '0'}</div>
+                                <div className="text-sky-700">hi = {hi !== null ? hi : '4'}</div>
+                                <div
+                                    className={
+                                        mid !== null
+                                            ? 'text-emerald-700 font-bold'
+                                            : 'text-slate-400'
+                                    }
+                                >
+                                    mid = {mid !== null ? mid : '（未計算）'}
+                                </div>
+                                <div
+                                    className={mid !== null ? 'text-emerald-700' : 'text-slate-400'}
+                                >
+                                    nums[mid] = {mid !== null ? EX_NUMS[mid] : '—'}
+                                </div>
+                            </div>
+                            <div className="p-3 rounded-xl bg-slate-50 border border-slate-200">
+                                <p className="text-xs text-slate-500 font-semibold mb-2 font-sans">
+                                    構築中の BST
+                                </p>
+                                <MiniTree highlight={treeHighlight} />
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            function StepsSection() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 2200);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                const handlePlay = () => {
+                    if (activeStep === stepsData.length) setActiveStep(1);
+                    setIsPlaying(true);
+                };
+
+                const current = stepsData.find((s) => s.step === activeStep);
+
+                return (
+                    <section id="steps" className="bg-white rounded-2xl p-8 shadow">
+                        <h2 className="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200">
+                            ステップバイステップ解説
+                        </h2>
+                        <p className="text-slate-500 text-sm mb-5">
+                            入力例{' '}
+                            <code className="bg-slate-100 px-1 rounded font-mono text-xs">
+                                nums = [-10, -3, 0, 5, 9]
+                            </code>{' '}
+                            を使って、アルゴリズムの各処理を順番に確認できます。
+                        </p>
+
+                        <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-6 mt-2">
+                            <div>
+                                <h3 className="mt-0 mb-3 text-teal-800 text-base 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-sm 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-0.5',
+                                                ].join(' ')}
+                                                onClick={() => {
+                                                    setActiveStep(s.step);
+                                                    setIsPlaying(false);
+                                                }}
+                                            >
+                                                <div
+                                                    className={[
+                                                        'font-semibold text-xs mb-1',
+                                                        isActive
+                                                            ? 'text-emerald-800'
+                                                            : 'text-teal-700',
+                                                    ].join(' ')}
+                                                >
+                                                    Step {s.step}
+                                                </div>
+                                                <div
+                                                    className={[
+                                                        'text-xs',
+                                                        isActive
+                                                            ? 'text-emerald-900 font-medium'
+                                                            : 'text-slate-600',
+                                                    ].join(' ')}
+                                                >
+                                                    {s.title}
+                                                </div>
+                                            </button>
+                                        );
+                                    })}
+                                </div>
+                            </div>
+
+                            <div>
+                                {activeStep > 1 && (
+                                    <div className="mb-3 px-3 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                        ← Step {activeStep - 1}「{stepsData[activeStep - 2].title}
+                                        」の続き
+                                    </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 {current.step}: {current.title}
+                                    </h3>
+                                    <p className="text-slate-600 leading-7 text-sm mt-2">
+                                        {current.desc}
+                                    </p>
+                                </div>
+
+                                <StepVisualization stepData={current} />
+
+                                <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                    <button
+                                        type="button"
+                                        className="px-4 py-2 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={handlePlay}
+                                        disabled={isPlaying}
+                                    >
+                                        ▶ Play
+                                    </button>
+                                    <button
+                                        type="button"
+                                        className="px-4 py-2 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-4 py-2 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-4 py-2 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>
+                    </section>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('steps-react')).render(<StepsSection />);
+        </script>
+
+        <script>
+            document.addEventListener('DOMContentLoaded', function () {
+                Prism.highlightAll();
+            });
+        </script>
+    </body>
+</html>
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md b/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Level_Order_Traversal_Python.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Python.md
rename to Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Level_Order_Traversal_Python.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Rust.md b/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Level_Order_Traversal_Rust.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Rust.md
rename to Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Level_Order_Traversal_Rust.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md b/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Level_Order_Traversal_Typescript.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/Binary_Tree_Level_Order_Traversal_Typescript.md
rename to Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Level_Order_Traversal_Typescript.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md b/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/README.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README.md
rename to Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/README.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html b/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/README_react.html
similarity index 99%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html
rename to Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/README_react.html
index 2b92a39..4375c3b 100644
--- a/Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html	
+++ b/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/README_react.html	
@@ -326,7 +326,7 @@ <h1 class="outfit text-4xl font-black text-teal-900 mb-1 leading-tight">
 
 
 class Solution:
-    def levelOrder(self, root: Optional[TreeNode]) -> list[list[int]]:
+    def levelOrder(self, root: Optional[TreeNode]) -&gt; list[list[int]]:
         # 基底条件: root が None（空ツリー）なら即座に空リストを返す
         # None チェックをしないと後続の node.val アクセスでクラッシュする
         if root is None:
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Python.md b/Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Zigzag_Level_Order_Traversal_Python.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Python.md
rename to Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Zigzag_Level_Order_Traversal_Python.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Rust.md b/Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Zigzag_Level_Order_Traversal_Rust.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Rust.md
rename to Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Zigzag_Level_Order_Traversal_Rust.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Typescript.md b/Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Zigzag_Level_Order_Traversal_Typescript.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/Binary_Tree_Zigzag_Level_Order_Traversal_Typescript.md
rename to Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/Binary_Tree_Zigzag_Level_Order_Traversal_Typescript.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README.md b/Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/README.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README.md
rename to Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/README.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html b/Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/README_React.html
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html
rename to Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/README_React.html
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/Maximum_Depth_of_Binary_Tree_Python.md b/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/Maximum_Depth_of_Binary_Tree_Python.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/Maximum_Depth_of_Binary_Tree_Python.md
rename to Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/Maximum_Depth_of_Binary_Tree_Python.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/Maximum_Depth_of_Binary_Tree_Rust.md b/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/Maximum_Depth_of_Binary_Tree_Rust.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/Maximum_Depth_of_Binary_Tree_Rust.md
rename to Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/Maximum_Depth_of_Binary_Tree_Rust.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/Maximum_Depth_of_Binary_Tree_Typescript.md b/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/Maximum_Depth_of_Binary_Tree_Typescript.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/Maximum_Depth_of_Binary_Tree_Typescript.md
rename to Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/Maximum_Depth_of_Binary_Tree_Typescript.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/README.md b/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/README.md
rename to Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/README_React.html b/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README_React.html
similarity index 99%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/README_React.html
rename to Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README_React.html
index 483ae39..dd415be 100644
--- a/Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/README_React.html	
+++ b/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README_React.html	
@@ -292,7 +292,7 @@ <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight"
 # 業務開発版：反復 BFS（CPython 再帰制限を回避）
 # ════════════════════════════════════════════════
 class Solution:
-    def maxDepth(self, root: Optional[TreeNode]) -> int:
+    def maxDepth(self, root: Optional[TreeNode]) -&gt; int:
         # エッジケース：空の木（ノードが1つもない）→ 深さ 0
         # 後続の deque 処理に None を入れないための早期リターン
         if root is None:
@@ -329,7 +329,7 @@ <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight"
 # 競技プログラミング版：再帰 DFS（最もシンプル）
 # ════════════════════════════════════════════════
 class Solution2:
-    def maxDepth(self, root: Optional[TreeNode]) -> int:
+    def maxDepth(self, root: Optional[TreeNode]) -&gt; int:
         # ベースケース：None = 存在しないノードの深さは 0
         # "is None" を使う理由：
         #   通常のノードオブジェクトはvalの値にかかわらずtruthyですが、
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Python.md b/Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Python.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Python.md
rename to Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Python.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Rust.md b/Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Rust.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Rust.md
rename to Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Rust.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Typescript.md b/Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Typescript.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Typescript.md
rename to Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal_Typescript.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/README.md b/Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/README.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/README.md
rename to Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/README.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/README_React.html b/Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/README_React.html
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/README_React.html
rename to Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/README_React.html
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_Python.md b/Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_Python.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_Python.md
rename to Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_Python.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_Rust.md b/Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_Rust.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_Rust.md
rename to Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_Rust.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_TypeScript.md b/Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_TypeScript.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_TypeScript.md
rename to Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal_TypeScript.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/README.md b/Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/README.md
rename to Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/README_React.html b/Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README_React.html
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/README_React.html
rename to Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README_React.html
diff --git a/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Go.md b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Go.md
new file mode 100644
index 0000000..afe6599
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Go.md	
@@ -0,0 +1,456 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Go
+> 適用ルールセット: 共通5ルール + Go固有ルール
+> 参照ファイル: references/common.md + references/go.md
+
+---
+
+# LeetCode 110 · Balanced Binary Tree — Go 完全解説
+
+---
+
+## 1. 問題分析結果
+
+> 💡 **この問題は一言で言うと**：「木のすべての分岐点で、左右の枝の深さの差が1以内かを判定する問題」です。
+
+---
+
+### 🐹 Goで解く際に特に気をつけるべき点
+
+Go版での最大の利点は、**`*TreeNode` というシンプルなポインタ（＝メモリ上の別の場所を指し示す値）** だけで木構造を表現できることです。RustのようなRc/RefCellや、TypeScriptのunion型と違い、「ポインタが `nil`（＝何も指していない状態）かどうか」だけを確認すればよいため、コードが非常にシンプルになります。また、Goでは**クロージャ（＝外側の変数を参照できる関数）** を使って再帰関数を定義する慣用句があります。これがGoにおける「ネスト再帰関数」の標準的な書き方です。
+
+---
+
+### 競技プログラミング視点
+
+- **制約分析**：ノード数最大5000。再帰の深さはO(h)（木の高さ）。スタックオーバーフローの心配なし
+- **最速手法**：番兵値（＝通常あり得ない特別な値でエラーを伝える）`-1` を使ったボトムアップDFS（深さ優先探索）
+- **メモリ最小化**：`*TreeNode` のポインタをたどるだけ。追加のスライスやマップは一切不要
+
+### 業務開発視点
+
+- **型安全設計**：`*TreeNode` と `nil` チェックで null 安全性を確保（Goでは `nil` ポインタに対してフィールドアクセスするとパニックになるため、必ず先にチェックする）
+- **エラーハンドリング**：今回は戻り値が `bool` のみなのでエラー戻り値は不要。ただし内部の `checkHeight` は `int` で `-1`（番兵値）を使ってエラーを表現する
+- **可読性**：クロージャを使ったネスト関数により、`checkHeight` のスコープを `isBalanced` 内に閉じ込め、外部から誤って呼ばれる心配がなくなる
+
+### Go特有分析
+
+- **データ構造選択**：`*TreeNode` の連鎖ポインタ。追加のデータ構造は不要
+- **標準ライブラリ活用度**：今回は不要。組み込みの `if` 分岐と算術演算のみ
+- **並行処理適性**：木の再帰DFSは各ノードが依存関係を持つため、ゴルーチン化のメリットがない（オーバーヘッドの方が大きくなる）
+- **エスケープ解析**：`checkHeight` の内部変数（`leftHeight`, `rightHeight` など `int` 型）はすべてスタック（＝関数内で完結する高速なメモリ領域）に配置される。ヒープアロケーション（＝動的メモリ確保）はゼロ
+
+> 📖 **このセクションで登場した用語**
+>
+> - **ポインタ**：メモリ上の別の場所のアドレスを保持する値。`*TreeNode` は「TreeNode の場所を指し示す」という意味
+> - **`nil`**：Goにおける「何も指していない」ポインタの値。JavaやPythonの `null` に相当するが、型を持つ
+> - **クロージャ**：外側の変数を「閉じ込めて」参照できる関数。Goでは `func(引数) 戻り値 { ... }` という無名関数で書く
+> - **スタック**：関数呼び出し時に使われる高速なメモリ領域。関数が終了すると自動で解放される
+> - **ヒープ**：動的に確保されるメモリ領域。GC（ガベージコレクション）が管理する。スタックより低速
+
+---
+
+## 2. アルゴリズム比較表
+
+> 💡 同じ問題でも解き方は複数あります。Go固有の視点として「追加のアロケーションが発生するか」「ポインタの参照回数が最小か」も重要な選択基準です。
+
+| アプローチ                        | 時間計算量 | 空間計算量 | Go実装コスト | 可読性 | 標準ライブラリ活用 | 備考                                           |
+| --------------------------------- | ---------- | ---------- | ------------ | ------ | ------------------ | ---------------------------------------------- |
+| **① トップダウン再帰（素朴）**    | O(n²)      | O(h)       | 低           | ★★☆    | なし               | 同じサブツリーのポインタを繰り返したどる       |
+| **② ボトムアップDFS（番兵値-1）** | O(n)       | O(h)       | 低           | ★★★    | なし               | 1パスで完結。Goクロージャとの相性◎             |
+| **③ BFS（幅優先探索）**           | O(n)       | O(n)       | 高           | ★☆☆    | `container/list`   | キュー管理複雑。`*TreeNode` のスライスが増える |
+
+`h` = 木の高さ。均衡木では O(log n)、一直線の木（最悪ケース）では O(n)
+
+### なぜ①（トップダウン）が非効率なのか
+
+```
+① トップダウン：各ノードで「高さ計算」と「均衡チェック」を分けてしまう問題
+
+isBalanced(root=1) を呼んだ場合：
+  → height(2) を計算 → height(4) → height(5) ...（再帰）
+  → height(3) を計算 → height(6) → height(7) ...（再帰）
+  → |height(2) - height(3)| を確認
+  → isBalanced(2) の中でもう一度 height(4), height(5) を計算！ ← 二重計算
+
+② ボトムアップ（採用）：1回のDFSで高さと均衡チェックを同時に行う
+  → 各ノードをちょうど1回だけポインタでたどれば完了
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **BFS（幅優先探索）**：木を同じ深さの層ごとに探索する手法。キュー（行列）を使う
+> - **`container/list`**：Go標準ライブラリの双方向リンクリスト。BFSのキューとして使えるが、スライスより遅いことが多い
+
+---
+
+## 3. 採用アルゴリズムと根拠
+
+- **選択したアプローチ**：② ボトムアップDFS（番兵値 `-1` パターン）
+
+**理由（他のアプローチとの対比）：**
+
+- ① トップダウンを「選ばなかった」理由：同じ `*TreeNode` ポインタを最大O(n)回たどり直すためO(n²)になるから
+- ③ BFSを「選ばなかった」理由：`*TreeNode` を格納するスライス（キュー）の確保・拡張でアロケーションが発生し、空間計算量もO(n)になるから
+
+**Go固有の採用理由：**
+
+- 🟢 **クロージャの再帰定義**：`var checkHeight func(*TreeNode) int` → `checkHeight = func(...) {...}` というGoの慣用句がそのまま使える
+- 🟢 **`nil` チェックの明快さ**：`if node == nil { return 0 }` の1行でベースケースが完結。Rustの `match` や TypeScriptの `if (node === null)` より簡潔
+- 🟢 **追加アロケーションゼロ**：`int` 型の返り値のみやり取りするため、エスケープ解析の結果すべてスタック割り当てになる
+
+**Go最適化戦略：**
+
+- `leftHeight`, `rightHeight` は `int`（サイズ固定）なのでスタック上に確保
+- `diff := leftHeight - rightHeight` で減算を1回だけ行い、正負両方を1つの変数で判定
+
+> 📖 **このセクションで登場した用語**
+>
+> - **クロージャの再帰定義**：Goで再帰クロージャを書く際は、`var f func(...)` で先に変数を宣言してから代入する必要がある。これはGoの変数スコープのルール（代入の右辺は左辺が宣言済みでないと参照できない）による
+> - **エスケープ解析**：変数をスタックに置けるかヒープに「逃がす」必要があるかをコンパイラが自動判断する仕組み
+> - **ベースケース**：再帰関数が「これ以上深く潜らなくてよい」と判断して返す終端条件
+
+---
+
+## 4. 実装パターン
+
+> 💡 **コードの骨格（構造）**
+>
+> 1. `isBalanced` はエントリポイント。`checkHeight` を呼んで `-1` でなければ `true`
+> 2. クロージャ `checkHeight` を `var` で先に宣言し、代入する（再帰できるようにするため）
+> 3. ベースケース：`node == nil` なら高さ `0` を返す
+> 4. 左右を再帰的にチェックし、どちらかが `-1` なら即座に `-1` を伝播する（早期リターン）
+> 5. 左右の差の絶対値が1より大きければ `-1`、そうでなければ `max(左, 右) + 1` を返す
+
+---
+
+### 【競技プログラミング版】 — LeetCode提出フォーマット
+
+LeetCodeで制限時間内に通すことが目的です。エラーハンドリングを省略し、実行速度・コードの簡潔さを最優先します。
+
+```go
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 7.38 MB
+// Beats 40.08%
+func isBalanced(root *TreeNode) bool {
+
+    // ── クロージャとして再帰ヘルパーを定義 ─────────────────────────────
+    // なぜ `var` で先に宣言するか：
+    // Goでは「短縮変数宣言 :=」の右辺に、まだ宣言されていない変数を参照できない。
+    // `checkHeight` 内で自分自身を呼ぶ（再帰）には、先に変数名を宣言しておく必要がある。
+    //
+    // なぜクロージャか：
+    // Go の関数はトップレベルにしか定義できないが、クロージャ（無名関数）なら
+    // 関数の中に「内部関数」を定義できる。外部から呼ばれない補助ロジックを
+    // スコープ内に閉じ込めることができるため、名前の衝突を防げる。
+    var checkHeight func(node *TreeNode) int
+
+    checkHeight = func(node *TreeNode) int {
+
+        // ── ベースケース ────────────────────────────────────────────────
+        // `nil` は「ノードが存在しない」＝木の終端を意味する。
+        // JavaやPythonの null と同じ概念だが、Goでは型を持った nil なので
+        // 型の混乱が起きにくい。
+        // 空の木の高さは 0 と定義する。この値が親ノードの高さ計算に使われる。
+        if node == nil {
+            return 0
+        }
+
+        // ── 左サブツリーを再帰的に検査 ──────────────────────────────────
+        // `node.Left` は `*TreeNode` 型のポインタ。
+        // ポインタをたどって左の子ノードにアクセスする。
+        leftHeight := checkHeight(node.Left)
+
+        // 左が -1（不均衡検知済み）なら、このノードでこれ以上調べても意味がない。
+        // 早期リターンで無駄な処理を打ち切る。
+        // これが「ボトムアップ」の核心：葉から根への帰り道でエラーを伝播させる。
+        if leftHeight == -1 {
+            return -1
+        }
+
+        // ── 右サブツリーを再帰的に検査 ──────────────────────────────────
+        rightHeight := checkHeight(node.Right)
+
+        // 右も同様に早期リターン。
+        if rightHeight == -1 {
+            return -1
+        }
+
+        // ── このノードでの均衡チェック ───────────────────────────────────
+        // diff を1回計算して再利用することで、
+        // `leftHeight - rightHeight` の計算が1回で済む（軽微な最適化）。
+        // Go 1.21+ の組み込み `min` / `max` は整数に対応しているが、
+        // 絶対値（abs）は組み込み関数がないため、`diff > 1 || diff < -1` で代替する。
+        // なぜ math.Abs を使わないか：`math.Abs` は float64 用のため
+        // int を渡すには型変換が必要で冗長になるから。
+        diff := leftHeight - rightHeight
+        if diff > 1 || diff < -1 {
+            return -1
+        }
+
+        // ── このノードの高さを返す ───────────────────────────────────────
+        // Go 1.21+ では組み込み `max` が整数に対して直接使えるようになった。
+        // 以前は `if leftHeight > rightHeight { return leftHeight + 1 }` と
+        // 書く必要があったが、より簡潔に書ける。
+        // +1 は「自分自身のノード」分を追加している。忘れると高さが1ずれる。
+        return max(leftHeight, rightHeight) + 1
+    }
+
+    // checkHeight が -1 でなければ均衡している。
+    // シンプルな != -1 の比較で完結する。
+    return checkHeight(root) != -1
+}
+```
+
+---
+
+### 【業務開発版】 — エラーハンドリング・可読性重視
+
+チームで長期間メンテナンスするプロダクションコードに向きます。Goの慣用句に従い、`error` 戻り値を使ってエラーを明示的に表現します。
+
+```go
+import "fmt"
+
+// ErrInvalidTree は木の構造が不正な場合のセンチネルエラー（＝パッケージレベルで定義する特定のエラー値）。
+// errors.Is(err, ErrInvalidTree) で呼び出し元がエラー種別を確認できる。
+var ErrInvalidTree = fmt.Errorf("invalid tree structure")
+
+// isBalancedProduction は業務開発向けの実装。
+//
+// Goではエラーを戻り値で返す（try-catch を使わない）。
+// JavaやPythonの例外と違い、呼び出し元が if err != nil で必ずエラーを確認する設計。
+//
+// Time Complexity: O(n) — 各ノードをちょうど1回訪問
+// Space Complexity: O(h) — 再帰のコールスタック（h = 木の高さ）
+func isBalancedProduction(root *TreeNode) (bool, error) {
+
+    // ── 内部ヘルパー：高さを返し、不均衡なら (-1, nil) を返す ──────────
+    // `error` を一緒に返すことで、将来的な拡張（例：ノード数の上限チェック追加）に対応できる。
+    var checkHeight func(*TreeNode) (int, error)
+
+    checkHeight = func(node *TreeNode) (int, error) {
+
+        // ベースケース：nil ノード = 高さ 0
+        if node == nil {
+            return 0, nil
+        }
+
+        // 左サブツリーを再帰的に検査
+        leftHeight, err := checkHeight(node.Left)
+        if err != nil {
+            // エラーが発生した場合、0 と error を返して呼び出し元に伝播する。
+            // ? 演算子がないGoでは、この if err != nil パターンが慣用句。
+            return 0, err
+        }
+        if leftHeight == -1 {
+            return -1, nil // 不均衡を示す番兵値を伝播（これはエラーではなく仕様上の戻り値）
+        }
+
+        // 右サブツリーを再帰的に検査
+        rightHeight, err := checkHeight(node.Right)
+        if err != nil {
+            return 0, err
+        }
+        if rightHeight == -1 {
+            return -1, nil
+        }
+
+        // 均衡チェック
+        diff := leftHeight - rightHeight
+        if diff > 1 || diff < -1 {
+            return -1, nil // 不均衡
+        }
+
+        // このノードの高さを返す（Go 1.21+ の組み込み max を使用）
+        return max(leftHeight, rightHeight) + 1, nil
+    }
+
+    // ── メイン処理 ────────────────────────────────────────────────────
+    height, err := checkHeight(root)
+    if err != nil {
+        // fmt.Errorf の %w（エラーラップ）で元のエラーを包む。
+        // errors.Is(err, ErrInvalidTree) で上位が種別確認できるようにする。
+        return false, fmt.Errorf("isBalancedProduction: %w", err)
+    }
+
+    return height != -1, nil
+}
+```
+
+> 💡 **業務版と競技版の使い分け**
+>
+> |                | 競技プログラミング版     | 業務開発版                       |
+> | -------------- | ------------------------ | -------------------------------- |
+> | **目的**       | LeetCodeで正解を出すこと | プロダクションで長期メンテナンス |
+> | **エラー**     | 番兵値 `-1` のみ         | `error` 戻り値で明示             |
+> | **拡張性**     | 低い                     | 高い（将来の仕様追加に対応）     |
+> | **コード量**   | 少ない                   | やや多い                         |
+> | **今回の選択** | ✅ LeetCode提出はこちら  | 参考実装として提示               |
+
+---
+
+### 🔍 動作トレース（入力例での変数変化）
+
+**Example 1** `root = [3, 9, 20, null, null, 15, 7]`
+
+```
+木の構造：
+        3          ← root
+       / \
+      9  20
+         / \
+        15   7
+
+isBalanced(root=&{3, ...}) の呼び出し
+  ↓
+checkHeight(node=&{3}) 開始
+  ├─ checkHeight(node=&{9}) 開始
+  │    ├─ checkHeight(node=nil) → return 0   ← 9.Left が nil
+  │    │   leftHeight = 0; (0 != -1) → 早期リターンしない
+  │    ├─ checkHeight(node=nil) → return 0   ← 9.Right が nil
+  │    │   rightHeight = 0; (0 != -1) → 早期リターンしない
+  │    ├─ diff = 0 - 0 = 0; (0 <= 1 && 0 >= -1) → 均衡OK
+  │    └─ return max(0, 0) + 1 = 1
+  │
+  │   leftHeight = 1; (1 != -1) → 早期リターンしない
+  │
+  ├─ checkHeight(node=&{20}) 開始
+  │    ├─ checkHeight(node=&{15}) → return 1  ← 同様の手順
+  │    │   leftHeight = 1; (1 != -1) → 早期リターンしない
+  │    ├─ checkHeight(node=&{7}) → return 1
+  │    │   rightHeight = 1; (1 != -1) → 早期リターンしない
+  │    ├─ diff = 1 - 1 = 0; 均衡OK
+  │    └─ return max(1, 1) + 1 = 2
+  │
+  │   rightHeight = 2; (2 != -1) → 早期リターンしない
+  │
+  ├─ diff = 1 - 2 = -1; (-1 <= 1 && -1 >= -1) → 均衡OK
+  └─ return max(1, 2) + 1 = 3
+
+checkHeight(root) = 3
+isBalanced: 3 != -1 → true ✅
+```
+
+---
+
+**Example 2** `root = [1, 2, 2, 3, 3, null, null, 4, 4]`
+
+```
+木の構造：
+              1
+            /   \
+           2     2
+          / \
+         3   3
+        / \
+       4   4
+
+（葉からの帰り道）
+checkHeight(&{4}) → 1
+checkHeight(&{4}) → 1
+
+checkHeight(&{3}) [左の3]
+  └─ leftHeight=1, rightHeight=1, diff=0 → return 2
+
+checkHeight(&{3}) [右の3]
+  └─ leftHeight=0, rightHeight=0, diff=0 → return 1
+
+checkHeight(&{2}) [左の2]
+  └─ leftHeight=2, rightHeight=1
+  └─ diff = 2 - 1 = 1; (1 <= 1) → 均衡ギリギリOK → return max(2,1)+1 = 3
+
+checkHeight(&{2}) [右の2]
+  └─ leftHeight=0, rightHeight=0 → return 1
+
+checkHeight(&{1}) ← ルート
+  └─ leftHeight=3, rightHeight=1
+  └─ diff = 3 - 1 = 2; (2 > 1) → 不均衡！ → return -1
+
+checkHeight(root) = -1
+isBalanced: -1 == -1 → false ✅
+```
+
+---
+
+**Example 3** `root = nil`（空の木）
+
+```
+checkHeight(node=nil) → return 0   ← ベースケースで即座に返す
+
+isBalanced: 0 != -1 → true ✅
+```
+
+---
+
+### 🔬 Goクロージャの再帰定義を図解
+
+```go
+// ❌ これはコンパイルエラーになる（checkHeight が未宣言のまま右辺で参照している）
+checkHeight := func(node *TreeNode) int {
+    return checkHeight(node.Left)  // ← この時点で checkHeight はまだ宣言されていない！
+}
+
+// ✅ Goの正しい書き方：先に var で型だけ宣言 → 後から代入
+var checkHeight func(*TreeNode) int   // ← ここで型だけ決める（値はゼロ値 nil）
+checkHeight = func(node *TreeNode) int {
+    return checkHeight(node.Left)  // ← 今度は checkHeight が宣言済みなので参照できる
+}
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **ポインタレシーバ `*T`**：`func (s *Solution) Method()` のように型に `*` を付けること。フィールドを変更したい場合に必要。今回は struct のフィールドを変えないため不要
+> - **`defer`**：関数終了時に必ず実行される後処理を登録する仕組み。今回は再帰DFSなのでリソース解放は不要だが、`sync.Mutex` のロック解除などに活用される
+> - **早期リターン**：条件を満たした時点で即座に `return` すること。不要な後続処理を省いて効率を上げる
+> - **センチネルエラー**：`var ErrNotFound = errors.New("not found")` のようにパッケージレベルで定義した特定のエラー値。`errors.Is` で比較できる
+> - **`max` 組み込み関数**：Go 1.21+ で追加。以前は `if a > b { return a }` と書く必要があったが、整数に対しても直接使えるようになった
+
+---
+
+## 最終回答（LeetCode 提出フォーマット）
+
+```go
+func isBalanced(root *TreeNode) bool {
+    var checkHeight func(node *TreeNode) int
+    checkHeight = func(node *TreeNode) int {
+        if node == nil {
+            return 0
+        }
+        leftHeight := checkHeight(node.Left)
+        if leftHeight == -1 {
+            return -1
+        }
+        rightHeight := checkHeight(node.Right)
+        if rightHeight == -1 {
+            return -1
+        }
+        diff := leftHeight - rightHeight
+        if diff > 1 || diff < -1 {
+            return -1
+        }
+        return max(leftHeight, rightHeight) + 1
+    }
+    return checkHeight(root) != -1
+}
+```
+
+**計算量サマリー**
+
+|          | 計算量   | 詳細                                                                                     |
+| -------- | -------- | ---------------------------------------------------------------------------------------- |
+| ⏱ Time  | **O(n)** | 各ノードのポインタをちょうど1回たどる                                                    |
+| 💾 Space | **O(h)** | 再帰のコールスタックが木の高さ分だけ積まれる（均衡木ならO(log n)、最悪の一直線木でO(n)） |
+| 🔒 Alloc | **ゼロ** | `int` のやり取りのみ。追加のスライス・マップ・ヒープ確保なし                             |
+
+**3言語比較まとめ**
+
+|                   | TypeScript                        | Rust                            | Go                             |
+| ----------------- | --------------------------------- | ------------------------------- | ------------------------------ |
+| ノードの型        | `TreeNode \| null`                | `Option<Rc<RefCell<TreeNode>>>` | `*TreeNode`                    |
+| null/nil チェック | `if (node === null)`              | `match node { None => ... }`    | `if node == nil`               |
+| 再帰関数の定義    | `function checkHeight(...) {...}` | `fn check_height(...) {...}`    | `var f func; f = func() {...}` |
+| 簡潔さ            | ⭐⭐⭐                            | ⭐⭐                            | ⭐⭐⭐⭐                       |
+| 型安全の強度      | ⭐⭐⭐                            | ⭐⭐⭐⭐⭐                      | ⭐⭐⭐⭐                       |
diff --git a/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Python.md b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Python.md
new file mode 100644
index 0000000..7da3640
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Python.md	
@@ -0,0 +1,444 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Python
+> 適用ルールセット: 共通5ルール + Python固有ルール
+> 参照ファイル: references/common.md + references/python.md
+
+---
+
+# LeetCode 110 · Balanced Binary Tree — Python 完全解説
+
+---
+
+## 1. 問題分析結果
+
+> 💡 **この問題は一言で言うと**：「木のすべてのノードで、左右の枝の深さの差が1以内かどうかを判定する問題」です。
+
+---
+
+### 🐍 Pythonで解く際に特に気をつけるべきCPython特有の注意点
+
+Pythonのデフォルト再帰（＝関数が自分自身を呼び出すこと）の深さ上限は **`sys.getrecursionlimit()` で確認でき、デフォルトは1000** です。ノード数が最大5000のこの問題では、最悪の場合（一直線の木）に再帰が5000回まで達する可能性があります。ただし **LeetCodeのPython環境は再帰上限が引き上げられている**ため、今回は `sys.setrecursionlimit()` の呼び出しは不要です。また、Pythonは **`is None`（同一性チェック）を `== None`（等値チェック）より優先的に使う** のがPythonの慣習（PEP 8）です。これはPythonの `None` がシングルトン（＝プログラム中に1つしか存在しないオブジェクト）であるために、`is` のほうが意味的に正確だからです。
+
+---
+
+### 競技プログラミング視点
+
+- **制約分析**：ノード数最大5000。O(n) の1パスDFS（深さ優先探索）で十分
+- **最速手法**：番兵値（＝通常あり得ない特別な値でエラーを伝える） `-1` を使ったボトムアップ再帰
+- **CPython最適化**：`abs()`（C実装の組み込み関数）と `max()`（C実装）を使うことで、Pure Python（＝Pythonコードで書かれた処理）より高速に絶対値・最大値を計算できる
+
+### 業務開発視点
+
+- **型安全設計**：`Optional[TreeNode]`（＝`TreeNode`か`None`のどちらか）を明示し、pylance（＝VSCodeのPython型チェックツール）がエラーを実行前に検出できるようにする
+- **エラーハンドリング**：LeetCodeが保証する制約（ノード数0〜5000、値-10⁴〜10⁴）の範囲内なので、`TreeNode` の型検証は省略し、`None`チェックのみ行う
+- **可読性**：ヘルパー関数 `check_height` をメソッド内のネスト関数（＝関数の中に定義する関数）として定義し、外部からの誤った呼び出しを防ぐ
+
+### Python特有分析
+
+- **データ構造選択**：`TreeNode` オブジェクトへの参照（＝Pythonオブジェクトのアドレス）をたどるだけ。追加の `list`/`deque`/`dict` は不要
+- **標準ライブラリ活用度**：`abs()`（組み込み・C実装）と `max()`（組み込み・C実装）のみ。外部ライブラリ不要
+- **CPython最適化度**：ネスト関数はクロージャ（＝外側のスコープの変数を参照できる関数）として実装され、グローバルスコープの関数より少し高速に名前解決される
+
+> 📖 **このセクションで登場した用語**
+>
+> - **CPython**：最も広く使われるPythonの実装。C言語で書かれており、組み込み関数の多くがC実装のため高速
+> - **シングルトン**：プログラム中に1つしか存在しないオブジェクト。`None`、`True`、`False` がこれにあたる
+> - **PEP 8**：Pythonの公式コーディングスタイルガイド。`is None` vs `== None` の使い分けもここで定義されている
+> - **ネスト関数**：関数の中に定義された関数。外部スコープから直接呼べないため、内部実装を隠蔽できる
+> - **クロージャ**：外側のスコープの変数を「閉じ込めて」参照できる関数
+
+---
+
+## 2. 採用アルゴリズムと根拠
+
+> 💡 同じ問題でも解き方は複数あります。Python固有の観点として「C実装の組み込み関数を使えるか」「追加のオブジェクト生成（メモリ確保）が起きるか」も重要な選択基準です。
+
+| アプローチ                        | 時間計算量 | 空間計算量 | Python実装コスト | 可読性 | 標準ライブラリ活用  | CPython最適化 | 備考                             |
+| --------------------------------- | ---------- | ---------- | ---------------- | ------ | ------------------- | ------------- | -------------------------------- |
+| **① トップダウン再帰（素朴）**    | O(n²)      | O(h)       | 低               | ★★☆    | なし                | 不適          | 同じノードを繰り返し訪問         |
+| **② ボトムアップDFS（番兵値-1）** | O(n)       | O(h)       | 低               | ★★★    | `abs()` `max()`     | 適            | 1パス。C実装の組み込み関数を活用 |
+| **③ BFS（幅優先探索）**           | O(n)       | O(n)       | 高               | ★☆☆    | `collections.deque` | 中            | `deque` の確保コストあり         |
+
+`h` = 木の高さ。均衡木ではO(log n)、最悪（一直線の木）ではO(n)
+
+### なぜ①（トップダウン）がO(n²)なのか
+
+```
+① の問題：「高さ計算」と「均衡チェック」を分けてしまう
+
+isBalanced(root=1) を呼んだとき：
+  → height(node=2) を計算 → height(4) → height(5) ...（再帰）
+  → height(node=3) を計算 → height(6) → height(7) ...（再帰）
+  → |height(2) - height(3)| ≤ 1 を確認
+  → isBalanced(2) でもう一度 height(4), height(5) を計算！← 二重計算
+
+② の解決策：高さ計算しながら均衡チェックも同時に行う（1パスで完結）
+```
+
+**Python固有の観点：**
+
+- ① では各ノードで `height()` を再帰呼び出しするたびに **Pythonのフレームオブジェクト（＝関数呼び出しの状態を保持するオブジェクト）** が生成される。O(n²)の場合、フレームの生成・破棄コストが無視できなくなる
+- ② では各ノードに対してフレームがちょうど1回生成されるだけ
+
+> 📖 **このセクションで登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **フレームオブジェクト**：Pythonが関数を呼び出すときに作るオブジェクト。ローカル変数・呼び出し元の情報などを保持する。再帰が深いほど大量に生成される
+> - **`collections.deque`**：前からも後ろからも O(1) で追加・削除できるデータ構造。BFS のキュー（行列）として最適
+
+---
+
+## 3. 実装パターン
+
+> 💡 **コードの骨格（構造）**
+>
+> 1. `isBalanced` はエントリポイント。`check_height` を呼んで `-1` でなければ `True`
+> 2. ネスト関数 `check_height` が再帰の本体。`Optional[TreeNode]` を受け取り `int` を返す
+> 3. `node is None` のベースケース（＝再帰の終端条件）で `0` を返す
+> 4. 左右を再帰チェックし、どちらかが `-1` なら即 `-1` を伝播（早期リターン）
+> 5. `abs()` で差の絶対値を計算し、`> 1` なら `-1`、そうでなければ `max() + 1` を返す
+
+---
+
+### 【競技プログラミング版】 — LeetCode 提出フォーマット
+
+LeetCodeで制限時間内に正解を出すことが目的です。型ヒントは最低限にとどめ、実行速度とコードの簡潔さを優先します。
+
+```python
+# Runtime 0 ms
+# Beats 100.00%
+# Memory 20.38 MB
+# Beats 71.71%
+
+from typing import Optional
+
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+
+        # ── ネスト関数としてヘルパーを定義 ──────────────────────────────
+        # ネスト関数にする理由：
+        # Pythonではクラスのメソッドとして定義すると `self` 経由のアクセスで
+        # 名前解決コストが発生する。ネスト関数はローカルスコープで解決されるため
+        # わずかに高速になる（CPythonの名前解決の仕組みによる）。
+        #
+        # 引数に `Optional[TreeNode]` を使う理由：
+        # `node.left` や `node.right` は `TreeNode | None` の可能性がある。
+        # pylance がこれを認識するために `Optional[TreeNode]` の型ヒントが必要。
+        def check_height(node: Optional[TreeNode]) -> int:
+
+            # ── ベースケース ─────────────────────────────────────────────
+            # `is None` を使う理由：
+            # Pythonの `None` はシングルトン（プログラム中に1つだけ存在するオブジェクト）。
+            # `is` は「同じオブジェクトかどうか」を確認する。
+            # `== None` は `__eq__` メソッドを呼び出すため遅く、意味的にも不正確。
+            # PEP 8（Pythonの公式スタイルガイド）でも `is None` が推奨されている。
+            if node is None:
+                return 0  # 空の木の高さ = 0。この値が親ノードの計算に使われる。
+
+            # ── 左サブツリーを再帰的に検査 ──────────────────────────────
+            # `node.left` は `Optional[TreeNode]` 型。
+            # None のときは次の再帰呼び出しでベースケースとして処理される。
+            left_height: int = check_height(node.left)
+
+            # 左が -1（不均衡検知済み）なら即座に -1 を返す。
+            # Pythonの短絡評価（＝条件が確定した時点で後続の評価をやめること）と同様の考え方。
+            # 早期リターンで不要な右サブツリーの探索を省く。
+            if left_height == -1:
+                return -1
+
+            # ── 右サブツリーを再帰的に検査 ──────────────────────────────
+            right_height: int = check_height(node.right)
+
+            # 右が -1 のときも同様に伝播させる。
+            if right_height == -1:
+                return -1
+
+            # ── このノードでの均衡チェック ───────────────────────────────
+            # `abs()` を使う理由：
+            # abs() はCPythonのC実装（組み込み関数）なので、
+            # Pure Pythonの `if left_height > right_height:` より高速。
+            # また「左が深い」「右が深い」の両ケースを1行で処理できる。
+            if abs(left_height - right_height) > 1:
+                return -1  # 不均衡 → 番兵値 -1 を返す
+
+            # ── このノードの高さを返す ────────────────────────────────────
+            # `max()` はCPythonのC実装（組み込み関数）なので高速。
+            # `if left_height > right_height: return left_height + 1` より簡潔で速い。
+            # +1 は「自分自身のノード」の分を追加している。省略すると高さが1ずれる。
+            return max(left_height, right_height) + 1
+
+        # check_height が -1 でなければ均衡している。
+        # `!= -1` の単純比較で完結する。
+        return check_height(root) != -1
+```
+
+---
+
+### 【業務開発版】 — 型安全・可読性・エラーハンドリング重視
+
+チームで長期間メンテナンスするプロダクションコードに向きます。pylance が通る厳密な型ヒントを付け、コードの意図をドキュメントとして残します。
+
+```python
+from typing import Optional
+
+
+class Solution:
+    """
+    LeetCode 110 - Balanced Binary Tree 解決クラス。
+
+    高さ均衡二分木とは、すべてのノードで左右の部分木の高さの差が
+    1以内である木のこと。
+    """
+
+    # 番兵値を定数として定義する。
+    # なぜ定数にするか：マジックナンバー（意味不明な数値リテラル）を排除し、
+    # 「-1 が何を意味するか」をコードで表現するため。
+    _UNBALANCED: int = -1
+
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        """
+        二分木が高さ均衡かどうかを判定する。
+
+        ボトムアップDFS（深さ優先探索）と番兵値パターンを使い、
+        O(n) の1パスで完結する実装。
+
+        Args:
+            root: 二分木のルートノード。空の木の場合は None。
+
+        Returns:
+            すべてのノードで左右の高さの差が1以内なら True、そうでなければ False。
+
+        Note:
+            制約（LeetCode保証）:
+            - ノード数: 0 ≤ n ≤ 5000
+            - ノード値: -10^4 ≤ Node.val ≤ 10^4
+
+        Time Complexity:  O(n) — 各ノードをちょうど1回訪問する
+        Space Complexity: O(h) — 再帰のコールスタック（h = 木の高さ）
+        """
+        # ── ネスト関数（ヘルパー） ──────────────────────────────────────
+        # ネスト関数を使う理由：
+        # `_check_height` をクラスメソッドとして定義すると、
+        # 外部から直接呼べてしまい、番兵値パターンの内部実装が漏れる。
+        # ネスト関数にすることで「外部に見せるAPI（isBalanced）」と
+        # 「内部実装（check_height）」を明確に分離できる。
+        def check_height(node: Optional[TreeNode]) -> int:
+            """
+            サブツリーの高さを返す。不均衡が検出された場合は -1 を返す。
+
+            Args:
+                node: 現在のノード（None = 木の終端）
+
+            Returns:
+                均衡している場合は 0 以上の高さ、不均衡なら -1
+            """
+            # ベースケース：None ノード（木の終端）は高さ 0
+            # `is None` を使うのはPEP 8（Pythonスタイルガイド）の推奨する慣習。
+            if node is None:
+                return 0
+
+            # 左サブツリーを再帰的に検査
+            left_height: int = check_height(node.left)
+            # 早期リターン：左で不均衡が見つかれば右は調べなくてよい
+            if left_height == self._UNBALANCED:
+                return self._UNBALANCED
+
+            # 右サブツリーを再帰的に検査
+            right_height: int = check_height(node.right)
+            # 早期リターン：右で不均衡が見つかれば即座に伝播
+            if right_height == self._UNBALANCED:
+                return self._UNBALANCED
+
+            # このノードでの均衡チェック
+            # abs() は C実装の組み込み関数で高速
+            if abs(left_height - right_height) > 1:
+                return self._UNBALANCED  # 定数を使うことで意味が明確になる
+
+            # このノードの高さ = 左右の最大 + 自分自身の1
+            return max(left_height, right_height) + 1
+
+        # check_height が UNBALANCED(-1) でなければ均衡している
+        return check_height(root) != self._UNBALANCED
+```
+
+> 💡 **業務版と競技版の使い分け**
+>
+> |                  | 競技プログラミング版  | 業務開発版                         |
+> | ---------------- | --------------------- | ---------------------------------- |
+> | **目的**         | LeetCode での正解     | プロダクションのメンテナンス       |
+> | **型ヒント**     | 最低限                | 厳密（pylance対応）                |
+> | **定数定義**     | なし（`-1` リテラル） | `_UNBALANCED = -1`（意味を明確化） |
+> | **ドキュメント** | コメントのみ          | `docstring` + コメント             |
+> | **LeetCode提出** | ✅ こちらを使う       | 参考実装として提示                 |
+
+---
+
+### 🔍 動作トレース（入力例での変数変化）
+
+**Example 1** `root = [3, 9, 20, null, null, 15, 7]`
+
+```
+木の構造：
+        3          ← root
+       / \
+      9  20
+         / \
+        15   7
+
+isBalanced(root) の呼び出し
+  ↓
+check_height(node=TreeNode(3)) 開始
+  │
+  ├─ check_height(node=TreeNode(9)) 開始
+  │    ├─ check_height(node=None) → return 0   ← 9.left が None
+  │    │   left_height = 0; (0 != -1) → 早期リターンしない
+  │    ├─ check_height(node=None) → return 0   ← 9.right が None
+  │    │   right_height = 0; (0 != -1) → 早期リターンしない
+  │    ├─ abs(0 - 0) = 0 ≤ 1 → 均衡OK
+  │    └─ return max(0, 0) + 1 = 1
+  │
+  │   left_height = 1; (1 != -1) → 早期リターンしない
+  │
+  ├─ check_height(node=TreeNode(20)) 開始
+  │    ├─ check_height(node=TreeNode(15)) → return 1  ← 同様の手順
+  │    │   left_height = 1; (1 != -1) → 早期リターンしない
+  │    ├─ check_height(node=TreeNode(7)) → return 1
+  │    │   right_height = 1; (1 != -1) → 早期リターンしない
+  │    ├─ abs(1 - 1) = 0 ≤ 1 → 均衡OK
+  │    └─ return max(1, 1) + 1 = 2
+  │
+  │   right_height = 2; (2 != -1) → 早期リターンしない
+  │
+  ├─ abs(1 - 2) = 1 ≤ 1 → 均衡OK（ぎりぎり均衡）
+  └─ return max(1, 2) + 1 = 3
+
+check_height(root) = 3
+isBalanced: 3 != -1 → True ✅
+```
+
+---
+
+**Example 2** `root = [1, 2, 2, 3, 3, null, null, 4, 4]`
+
+```
+木の構造：
+              1
+            /   \
+           2     2
+          / \
+         3   3
+        / \
+       4   4
+
+（葉ノードから帰り道の結果だけ示す）
+check_height(TreeNode(4)) → 1  ← 左の4
+check_height(TreeNode(4)) → 1  ← 右の4
+
+check_height(TreeNode(3)) [左の3]
+  └─ left=1, right=1, abs(1-1)=0 → return max(1,1)+1 = 2
+
+check_height(TreeNode(3)) [右の3]
+  └─ left=0, right=0, abs(0-0)=0 → return 1
+
+check_height(TreeNode(2)) [左の2]
+  └─ left_height=2, right_height=1
+  └─ abs(2-1) = 1 ≤ 1 → 均衡ギリギリOK → return max(2,1)+1 = 3
+
+check_height(TreeNode(2)) [右の2]
+  └─ left=0, right=0 → return 1
+
+check_height(TreeNode(1)) ← ルート
+  └─ left_height=3, right_height=1
+  └─ abs(3-1) = 2 > 1 → 不均衡！ → return -1
+
+check_height(root) = -1
+isBalanced: -1 == -1 → False ✅
+```
+
+---
+
+**Example 3** `root = None`（空の木）
+
+```
+check_height(node=None)
+  └─ node is None → return 0   ← ベースケースで即座に返す
+
+check_height(root) = 0
+isBalanced: 0 != -1 → True ✅
+```
+
+---
+
+### 🔬 `Optional[TreeNode]` と pylance の役割を図解
+
+```python
+# ❌ 型ヒントなし → pylance はエラーを検出できない
+def check_height(node):
+    if node is None:
+        return 0
+    return check_height(node.left)  # node が None なのに .left にアクセスしても気づかれない
+
+# ✅ 型ヒントあり → pylance が静的解析でエラーを実行前に検出
+def check_height(node: Optional[TreeNode]) -> int:
+    if node is None:
+        return 0
+    # この行以降、pylance は node が TreeNode 型だと推論できる（型の絞り込み）
+    return check_height(node.left)  # node.left が Optional[TreeNode] であることも認識される
+
+# Optional[TreeNode] の意味：
+# Optional[TreeNode] = TreeNode | None （Python 3.10+ の書き方）
+#   → 「TreeNode か None のどちらか」という型
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`Optional[T]`**：`T` または `None` のどちらかであることを表す型ヒント。`from typing import Optional` が必要。Python 3.10+ では `T | None` と書ける
+> - **型の絞り込み（Type Narrowing）**：`if node is None: return` の後、pylance が「以降の `node` は絶対に `None` でない」と推論してくれる仕組み
+> - **マジックナンバー**：コード中に突然現れる意味不明な数値リテラル（例：`return -1`）。定数に名前を付けることで意図が明確になる
+> - **早期リターン（Early Return）**：条件を満たした時点で即座に `return` すること。ネストが深くなるのを防ぎ、コードをフラットに保てる
+> - **`abs()`**：絶対値を返す組み込み関数。CPythonのC実装なので Pure Python のif文より高速
+
+---
+
+## 最終回答（LeetCode 提出フォーマット）
+
+```python
+from typing import Optional
+
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        def check_height(node: Optional[TreeNode]) -> int:
+            if node is None:
+                return 0
+            left_height = check_height(node.left)
+            if left_height == -1:
+                return -1
+            right_height = check_height(node.right)
+            if right_height == -1:
+                return -1
+            if abs(left_height - right_height) > 1:
+                return -1
+            return max(left_height, right_height) + 1
+
+        return check_height(root) != -1
+```
+
+**計算量サマリー**
+
+|                  | 計算量   | 詳細                                                                   |
+| ---------------- | -------- | ---------------------------------------------------------------------- |
+| ⏱ Time          | **O(n)** | 各ノードをちょうど1回訪問。`abs()` `max()` はC実装でO(1)               |
+| 💾 Space         | **O(h)** | 再帰のコールスタック（CPythonのフレームオブジェクトが h 個生成される） |
+| 🐍 CPython最適化 | **高**   | `abs()` `max()` `is None` すべてC実装 or 最適化パス                    |
+
+**4言語まとめ比較**
+
+|                    | TypeScript         | Rust                       | Go               | **Python**                |
+| ------------------ | ------------------ | -------------------------- | ---------------- | ------------------------- |
+| **ノードの型**     | `TreeNode \| null` | `Option<Rc<RefCell<...>>>` | `*TreeNode`      | `Optional[TreeNode]`      |
+| **nullチェック**   | `=== null`         | `match { None => }`        | `== nil`         | **`is None`**             |
+| **絶対値**         | `Math.abs()`       | `.abs()`                   | 手動比較         | **`abs()`（C実装）**      |
+| **最大値**         | `Math.max()`       | `.max()`                   | `max()` 組み込み | **`max()`（C実装）**      |
+| **コードの簡潔さ** | ⭐⭐⭐             | ⭐⭐                       | ⭐⭐⭐⭐         | **⭐⭐⭐⭐⭐**            |
+| **型安全の強度**   | ⭐⭐⭐             | ⭐⭐⭐⭐⭐                 | ⭐⭐⭐⭐         | **⭐⭐⭐**（pylance依存） |
diff --git a/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Rust.md b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Rust.md
new file mode 100644
index 0000000..888da2d
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Rust.md	
@@ -0,0 +1,364 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: Rust
+> 適用ルールセット: 共通5ルール + Rust固有4ルール
+> 参照ファイル: references/common.md + references/rust.md
+
+---
+
+# LeetCode 110 · Balanced Binary Tree — Rust 完全解説
+
+---
+
+## 1. 問題の分析
+
+> 💡 **この問題は一言で言うと**：「すべてのノードで左右の部分木の高さの差が1以内かを判定する問題」です。
+
+---
+
+### 🦀 Rustで解く際に特に気をつけるべき点
+
+この問題をRustで解く上で最大のポイントは **`Option<Rc<RefCell<TreeNode>>>` という型**です。これはLeetCodeがRustで木構造を表現するために使う特殊な型で、「ノードが存在するかもしれない（Option）、複数の場所から参照されるかもしれない（Rc）、ノードの中身を変更するかもしれない（RefCell）」という3つの要件を同時に満たすために組み合わされています。今回は**読み取り専用の再帰DFS（深さ優先探索）**なので `borrow()`（共有借用）だけを使い、`borrow_mut()` は一切不要です。
+
+---
+
+### 競技プログラミング視点での分析
+
+- ノード数は最大5000。再帰の深さはO(h)（木の高さ）
+- **番兵値（＝通常あり得ない特別な値でエラーを上位に伝える手法）** `-1` を使った1パスDFSが最速
+- `Rc<RefCell<T>>` の `borrow()` は実行時チェックを伴うが、LeetCodeのこの問題では回避不可能
+
+### 業務開発視点での分析
+
+- `Option<Rc<RefCell<TreeNode>>>` の `match` パターンマッチング（＝値の形によって処理を分岐する仕組み）を使い、`None`（ノードなし）と `Some`（ノードあり）を明示的に分離
+- 戻り値は `i32`（高さ または `-1`）とシンプルに保ち、追加の `enum` 定義は省略（LeetCode形式の実用性優先）
+- 内部ヘルパーをクロージャではなくネスト関数（`fn`）で定義することで、スタックフレームを明確に分離
+
+### Rust特有の考慮点
+
+- **借用**（＝所有権を渡さずに値を参照する仕組み）：ノードを `&Option<Rc<RefCell<TreeNode>>>` で受け取ることで、所有権の移動（move）を防ぐ
+- **`Rc::borrow()`**（RefCellの共有借用）：実行時に借用チェックを行う。今回は読み取り専用なので `borrow()` のみ使用
+- **ネスト関数**：Rustでは関数の中に関数を定義できる。クロージャと違いライフタイムが単純で推論しやすい
+
+> 📖 **このセクションで登場した用語**
+>
+> - **所有権**：値を"誰が管理するか"をコンパイル時に決めるRust独自の仕組み。JavaやPythonのGC（ガベージコレクタ）とは異なり、コンパイル時にメモリを自動管理する
+> - **`Rc<T>`**：「参照カウント付きポインタ」。複数の場所から同じデータを共有できる。ただしシングルスレッド専用
+> - **`RefCell<T>`**：「内部可変性」を持つコンテナ。通常Rustは借用規則をコンパイル時に検査するが、`RefCell` は実行時に検査を先送りする
+> - **パターンマッチング**：`match` 式で値の「形」によって処理を分岐する仕組み。Rustのパターンマッチはコンパイラが網羅性を保証する
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+> 💡 解き方は複数ありますが、Rust固有の視点として「所有権の移動が発生するか」「`Rc` のクローン（参照カウントの増加）が起きるか」も重要な選択基準です。
+
+| アプローチ                        | 時間計算量 | 空間計算量 | Rust実装コスト | 安全性 | 可読性 | 備考                                           |
+| --------------------------------- | ---------- | ---------- | -------------- | ------ | ------ | ---------------------------------------------- |
+| **① トップダウン再帰（素朴）**    | O(n²)      | O(h)       | 中             | 高     | 中     | 各ノードで高さを再計算。`Rc::clone` が多発する |
+| **② ボトムアップDFS（番兵値-1）** | O(n)       | O(h)       | 低             | 高     | 高     | 1パスで完結。`&Option<...>` の参照借用のみ     |
+| **③ 反復（スタック＋BFS）**       | O(n)       | O(n)       | 高             | 高     | 低     | `VecDeque` 管理が複雑。`Rc::clone` コストあり  |
+
+**Rust固有の重要な観点：**
+
+- ① では高さ計算のたびに `Rc::clone`（参照カウントのインクリメント）が発生し、定数倍のオーバーヘッドがある
+- ② では `&Option<Rc<RefCell<TreeNode>>>` を参照として渡すため、**所有権移動もクローンも発生しない**
+
+> 📖 **このセクションで登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安。`h` は木の高さ（均衡木ではO(log n)、最悪O(n)）
+> - **`Rc::clone`**：参照カウントを1増やす操作。完全なデータコピーではないが、カウンタ更新のコストが生じる
+> - **参照借用**：`&` を付けて所有権を渡さずに値を「借りる」こと。借用中は貸し主もデータを使い続けられる
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**：② ボトムアップDFS（番兵値 `-1` パターン）
+
+**理由（他のアプローチとの対比）：**
+
+- ① トップダウンを「選ばなかった」理由：同じサブツリーを最大O(n)回再計算するためO(n²)になる上、`Rc::clone` が多発してパフォーマンスが低下するから
+- ③ BFSを「選ばなかった」理由：`VecDeque`（双方向キュー）の管理が複雑で、O(n)の追加メモリが必要になるから
+
+**②を選んだ根拠：**
+
+- 🟢 **参照借用のみ**：`&Option<Rc<RefCell<TreeNode>>>` を渡すため、所有権移動もクローンもゼロ
+- 🟢 **`borrow()` が1ノードにつき1回**：読み取りの実行時チェックを最小限に抑えられる
+- 🟢 **`-1` 番兵値による早期リターン**：不均衡を検知した瞬間に以降の探索を打ち切れる
+
+**Rust特有の最適化ポイント：**
+
+- ネスト関数 `check_height` はモノモーフィゼーション（＝型ごとに専用コードへ自動展開）不要の具体型関数なので、インライン展開が起きやすい
+- スタック上の `i32` のみをやり取りするため、ヒープアロケーション（＝動的メモリ確保）が発生しない
+
+> 📖 **このセクションで登場した用語**
+>
+> - **ゼロコスト抽象化**：便利な書き方をしても手書きの低レベルコードと同じ速さになるRustの性質
+> - **モノモーフィゼーション**：ジェネリクス関数が使われる型ごとに専用コードへ自動展開される仕組み
+> - **ヒープアロケーション**：`Vec` や `Box` などの動的なメモリ確保。スタックより低速だがサイズが可変
+> - **インライン展開**：関数呼び出しを、関数の中身をそのまま埋め込むことで呼び出しオーバーヘッドをゼロにする最適化
+
+---
+
+## 4. 実装コード
+
+> 💡 **コードの大まかな構造（骨格）**
+>
+> 1. `is_balanced` はエントリポイント。ルートノードを参照として `check_height` に渡す
+> 2. ネスト関数 `check_height` が再帰の本体。`&Option<...>` を受け取り、`i32`（高さ or -1）を返す
+> 3. `None` のノード（木の終端）に達したら高さ `0` を返す（ベースケース）
+> 4. `Some(n)` の場合は `n.borrow()` でノードを共有借用し、左右を再帰的に検査する
+> 5. 左右どちらかが `-1` なら即座に `-1` を伝播する（早期リターン）
+> 6. 高さの差が1以下なら `max(左, 右) + 1` を返す
+
+```rust
+// Runtime 0 ms
+// Beats 100.00%
+// Memory 2.80 MB
+// Beats 81.58%
+
+use std::rc::Rc;
+use std::cell::RefCell;
+
+impl Solution {
+    pub fn is_balanced(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+
+        // ── ネスト関数としてヘルパーを定義 ─────────────────────
+        // クロージャ（|x| { ... }）ではなく fn を使う理由：
+        // 再帰呼び出しに self キャプチャが不要で、
+        // コンパイラがライフタイムを単純に推論できるから。
+        //
+        // 引数を `&Option<Rc<RefCell<TreeNode>>>` の"参照借用"で受け取る理由：
+        // `Option<Rc<...>>` を値で渡すと所有権が移動（move）してしまい、
+        // 呼び出し元で同じノードを再び使えなくなるから。
+        // `&` を付けることで、所有権を渡さず「読み取り専用で借りる」だけにする。
+        fn check_height(node: &Option<Rc<RefCell<TreeNode>>>) -> i32 {
+
+            // ── パターンマッチングで None / Some を分岐 ────────
+            // `match` はRustのパターンマッチング構文。
+            // コンパイラが「None と Some の両方を必ず処理しているか」を検査するため、
+            // うっかりケースを見落とすことがない（Pythonや JavaのifによるNullチェックとの違い）。
+            match node {
+
+                // ベースケース：None = ノードが存在しない（木の終端）
+                // JavaScriptの `null` や Javaの `null` と違い、
+                // `None` を使い忘れた場合はコンパイルエラーになるため安全。
+                // 空の木の高さは 0 と定義する。
+                None => 0,
+
+                // Some(n)：ノードが存在する場合
+                // n は `Rc<RefCell<TreeNode>>` 型。
+                // Rc（参照カウントポインタ）を介してノードにアクセスする。
+                Some(n) => {
+
+                    // `n.borrow()` で RefCell の共有借用を行う。
+                    // 「共有借用」＝読み取り専用の参照を取得すること。
+                    // Rust通常の &T 借用はコンパイル時にチェックされるが、
+                    // RefCell はこのチェックを"実行時"に行う（LeetCode の木構造上やむを得ない）。
+                    // .borrow() が返す `Ref<T>` はスコープを抜けると自動で解放される。
+                    let borrowed = n.borrow();
+
+                    // ── 左サブツリーを再帰的に検査 ────────────
+                    // `&borrowed.left` で左の子ノードへの参照を渡す。
+                    // `borrowed.left` の型は `Option<Rc<RefCell<TreeNode>>>` なので、
+                    // `&` を付けて参照として渡すことで所有権移動を防ぐ。
+                    let left_height = check_height(&borrowed.left);
+
+                    // 左サブツリーが -1（不均衡）なら、このノードで調べ続けても意味がない。
+                    // 即座に -1 を返して呼び出し元に伝播させる（早期リターン）。
+                    if left_height == -1 {
+                        return -1;
+                    }
+
+                    // ── 右サブツリーを再帰的に検査 ────────────
+                    let right_height = check_height(&borrowed.right);
+
+                    // 右サブツリーも同様に早期リターン。
+                    if right_height == -1 {
+                        return -1;
+                    }
+
+                    // ── このノードでの均衡チェック ─────────────
+                    // (left_height - right_height).abs() で絶対値（常に0以上の値）を取る。
+                    // Rust の i32 には abs() メソッドが標準で存在する。
+                    // 差が1より大きければ不均衡 → -1 を返す。
+                    if (left_height - right_height).abs() > 1 {
+                        return -1;
+                    }
+
+                    // ── このノードの高さを返す ─────────────────
+                    // left_height.max(right_height) は std::cmp::max と同義。
+                    // i32 型に直接 .max() メソッドが定義されているため、
+                    // 関数呼び出しなしにシンプルに書ける（Rustの std の利便性）。
+                    // +1 は「自分自身のノード」の分を追加している。
+                    left_height.max(right_height) + 1
+                }
+            }
+        }
+
+        // check_height が -1 でなければ均衡している。
+        // `!= -1` という単純な比較で完結するため、追加の型定義が不要。
+        check_height(&root) != -1
+    }
+}
+```
+
+---
+
+### 🔍 動作トレース（入力例での変数変化）
+
+**Example 1** `root = [3, 9, 20, null, null, 15, 7]`
+
+```
+木の構造：
+        3
+       / \
+      9  20
+         / \
+        15   7
+
+再帰の解決順（葉 → 根）：
+
+check_height(&Some(9))
+  └─ borrowed = borrow() で 9 のノードを読み取り専用で借用
+  └─ check_height(&None) → 0    ← 9.left が None
+  └─ left_height = 0; (0 != -1) → 早期リターンしない
+  └─ check_height(&None) → 0    ← 9.right が None
+  └─ right_height = 0; (0 != -1) → 早期リターンしない
+  └─ (0 - 0).abs() = 0 ≤ 1 → 均衡OK
+  └─ return 0.max(0) + 1 = 1
+
+check_height(&Some(15)) → 1  （同様）
+check_height(&Some(7))  → 1  （同様）
+
+check_height(&Some(20))
+  └─ left_height  = check_height(&Some(15)) = 1
+  └─ right_height = check_height(&Some(7))  = 1
+  └─ (1 - 1).abs() = 0 ≤ 1 → 均衡OK
+  └─ return 1.max(1) + 1 = 2
+
+check_height(&Some(3))   ← ルートノード
+  └─ left_height  = check_height(&Some(9))  = 1
+  └─ right_height = check_height(&Some(20)) = 2
+  └─ (1 - 2).abs() = 1 ≤ 1 → 均衡OK
+  └─ return 1.max(2) + 1 = 3
+
+is_balanced: check_height(&root) = 3 ≠ -1 → true ✅
+```
+
+---
+
+**Example 2** `root = [1, 2, 2, 3, 3, null, null, 4, 4]`
+
+```
+木の構造：
+              1
+            /   \
+           2     2
+          / \
+         3   3
+        / \
+       4   4
+
+check_height(4) → 1, check_height(4) → 1
+
+check_height(&Some(3)) [左の3]
+  └─ left_height=1, right_height=1 → return 2
+
+check_height(&Some(3)) [右の3]
+  └─ left_height=0, right_height=0 → return 1
+
+check_height(&Some(2)) [左の2]
+  └─ left_height=2, right_height=1
+  └─ (2 - 1).abs() = 1 ≤ 1 → 均衡OK → return 3
+
+check_height(&Some(2)) [右の2]
+  └─ return 1
+
+check_height(&Some(1)) ← ルート
+  └─ left_height=3, right_height=1
+  └─ (3 - 1).abs() = 2 > 1 → 不均衡！ → return -1
+
+is_balanced: check_height(&root) = -1 → false ✅
+```
+
+---
+
+**Example 3** `root = []`（空の木）
+
+```
+root = None
+
+check_height(&None) → match None => 0 （ベースケースで即座に 0 を返す）
+
+is_balanced: 0 ≠ -1 → true ✅
+```
+
+---
+
+### 🔬 `Option<Rc<RefCell<TreeNode>>>` の構造を図解
+
+```
+JavaScriptの木ノード（参考）：
+  node.left → 直接参照またはnull（型の保証なし）
+
+Rustの木ノード：
+  node.left: Option< Rc< RefCell<TreeNode> > >
+              │       │    │
+              │       │    └── 内部可変性（読み書き可能なコンテナ）
+              │       └─────── 参照カウント（複数箇所からの共有所有）
+              └─────────────── Some（存在する）/ None（存在しない）
+
+アクセスの流れ：
+  n.borrow()       ← RefCell から読み取り専用の共有参照を取得
+      ↓
+  borrowed.left    ← TreeNode の left フィールドにアクセス
+      ↓
+  &borrowed.left   ← 参照として渡す（所有権移動を防ぐ）
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **`match` (パターンマッチング)**：値の「形」によって処理を分岐する構文。コンパイラがすべてのケースの網羅を強制するため、処理漏れが起きない
+> - **`borrow()`**：`RefCell<T>` から共有（読み取り専用）の借用を行うメソッド。実行時に他のミュータブル借用がないか確認する
+> - **`Ref<T>`**：`borrow()` が返す型。スコープ（`{}`ブロック）を抜けると自動で借用が解放されるRAIIパターンを採用している
+> - **RAII（Resource Acquisition Is Initialization）**：スコープを抜けると自動でリソースが解放されるRustの根本的な設計パターン。C++由来。JavaのtryWithResourcesやPythonのwithに相当するが、Rustは言語レベルで強制される
+> - **早期リターン**：条件を満たした時点で `return` を使い即座に関数を終了させること。不要な後続処理を省いて効率を上げる
+
+---
+
+## 最終回答（LeetCode 提出フォーマット）
+
+```rust
+use std::rc::Rc;
+use std::cell::RefCell;
+
+impl Solution {
+    pub fn is_balanced(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        fn check_height(node: &Option<Rc<RefCell<TreeNode>>>) -> i32 {
+            match node {
+                None => 0,
+                Some(n) => {
+                    let borrowed = n.borrow();
+                    let left_height = check_height(&borrowed.left);
+                    if left_height == -1 { return -1; }
+                    let right_height = check_height(&borrowed.right);
+                    if right_height == -1 { return -1; }
+                    if (left_height - right_height).abs() > 1 { return -1; }
+                    left_height.max(right_height) + 1
+                }
+            }
+        }
+        check_height(&root) != -1
+    }
+}
+```
+
+**計算量サマリー**
+
+|          | 計算量   | 詳細                                                                                     |
+| -------- | -------- | ---------------------------------------------------------------------------------------- |
+| ⏱ Time  | **O(n)** | 各ノードをちょうど1回 `borrow()` してアクセスする                                        |
+| 💾 Space | **O(h)** | 再帰のコールスタックが木の高さ分だけ積まれる（均衡木ならO(log n)、最悪の一直線木でO(n)） |
+| 🔒 Alloc | **ゼロ** | ヒープアロケーション追加なし（`borrow()` は Ref を返すがスタック上）                     |
diff --git a/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Typescript.md b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Typescript.md
new file mode 100644
index 0000000..f65dc75
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/Balanced_Binary_Tree_Typescript.md	
@@ -0,0 +1,348 @@
+> 🎯 **[algo-beginner スキル発火]**
+> 言語/カテゴリ: TypeScript
+> 適用ルールセット: 共通5ルール + TS固有5ルール
+> 参照ファイル: references/common.md + references/typescript.md
+
+---
+
+# LeetCode 110 · Balanced Binary Tree — 完全解説
+
+---
+
+## 1. 問題の分析
+
+> 💡 **この問題は一言で言うと**：「二分木（＝各ノードが最大2つの子を持つ木構造）のすべての節で、左右の高さの差が1以下かどうかを判定する問題」です。
+
+---
+
+### 🌳 「高さ均衡」とは何か？（日常の例え）
+
+クリスマスツリーを想像してください。左側と右側の枝が大きく偏っていたら「バランスが悪い」ですよね。二分木でも同じで、**すべての分岐点（ノード）で、左の枝と右の枝の「深さ（高さ）」の差が1以内**であれば「均衡している（balanced）」と言います。
+
+```
+均衡している例（各ノードで左右差 ≤ 1）    均衡していない例（左が深すぎる）
+        3                                      1
+       / \                                    /
+      9  20                                  2
+         / \                                /
+        15   7                             3
+```
+
+---
+
+### 競技プログラミング視点での分析
+
+- **最大ノード数は5000**。単純な全探索でも間に合うが、最適解はO(n)の1パスDFS（深さ優先探索）
+- **各ノードを1回だけ訪問**すれば十分。再計算を避けることが鍵
+- **番兵値（＝通常あり得ない特別な値でエラーを伝える手法）** `-1` を使って「不均衡」を上位ノードへ伝播させる
+
+### 業務開発視点での分析
+
+- **型安全性**：`TreeNode | null` の union型（＝複数の型のどちらかを取れる型）を正しく扱う
+- **null安全性**：ノードが `null` の場合のベースケースを確実に処理
+- **可読性**：ヘルパー関数を分離することで `isBalanced` の責務を明確化
+
+### TypeScript特有の考慮点
+
+- `TreeNode | null`：LeetCodeが定義済みのユニオン型を利用
+- **型ガード**（＝実行時に型を絞り込む仕組み）として `node === null` チェックを活用
+- `readonly` は今回TreeNodeクラス定義が固定のため不要だが、ヘルパー関数の戻り値型を明示することで保守性が上がる
+
+> 📖 **このセクションで登場した用語**
+>
+> - **二分木**：各ノードが最大2つの子（左・右）を持つ木構造のデータ構造
+> - **DFS（深さ優先探索）**：木の根から枝の末端まで深く潜ってから戻る探索方法。スタック（積み重ね構造）を使う
+> - **番兵値**：「通常の値ではない特別な状態」を伝えるために使う特殊な値。今回は `-1` が「不均衡」を意味する
+> - **ユニオン型**：`A | B` のように「AかBのどちらか」を表すTypeScript固有の型表現
+
+---
+
+## 2. アルゴリズムアプローチ比較
+
+> 💡 同じ問題でも解き方は複数あります。それぞれの「速さ（時間計算量＝処理にかかる手間の目安）」と「メモリ量（空間計算量）」を比べて最適なものを選びます。
+
+| アプローチ                       | 時間計算量 | 空間計算量 | TS実装コスト | 型安全性 | 可読性 | 備考                                      |
+| -------------------------------- | ---------- | ---------- | ------------ | -------- | ------ | ----------------------------------------- |
+| **① トップダウン（素朴な再帰）** | O(n²)      | O(h)       | 低           | 高       | 中     | 各ノードで高さを毎回再計算するため遅い    |
+| **② ボトムアップDFS（番兵値）**  | O(n)       | O(h)       | 低           | 高       | 高     | 1回のパスで高さ＋均衡チェックを同時に行う |
+| **③ BFS（幅優先探索）**          | O(n)       | O(n)       | 高           | 中       | 低     | キューの管理が複雑で直感的でない          |
+
+`h` = 木の高さ。最悪O(n)（一直線の木）、均衡木ではO(log n)
+
+> 💡 **Big-O記法の読み方**
+>
+> - `O(n²)`：ノードが100個 → 最大10,000回の処理（遅い）
+> - `O(n)`：ノードが100個 → 最大100回の処理（速い）
+> - `O(h)`：再帰（＝関数が自分自身を呼び出すこと）の深さ分だけスタックメモリを使う
+
+### なぜ①（トップダウン）が遅いのか？
+
+```
+トップダウンの問題：同じサブツリーを何度も計算してしまう
+
+       3          ← ここで高さを計算するとき
+      / \
+     9  20        ← 20の高さを計算
+        / \
+       15   7     ← 15と7の高さを計算（これは3の高さ計算でも使われる）
+
+ノード3の高さ計算中に → ノード20の高さを計算中に → ノード15,7の高さを計算
+ノード20の均衡チェック中にも → ノード15,7の高さをまた計算 ← 二重計算！
+```
+
+> 📖 **このセクションで登場した用語**
+>
+> - **時間計算量**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量**：処理中に使うメモリ量がどう増えるかの目安
+> - **BFS（幅優先探索）**：木を同じ深さの階層ごとに探索する方法。キュー（行列構造）を使う
+
+---
+
+## 3. 選択したアルゴリズムと理由
+
+- **選択したアプローチ**：② ボトムアップDFS（番兵値 `-1` パターン）
+
+**理由（他のアプローチとの対比）：**
+
+- ① トップダウンを「選ばなかった」理由：同じサブツリーを最大 O(n) 回再計算するため、全体でO(n²)になってしまうから
+- ③ BFSを「選ばなかった」理由：高さの計算にキュー管理が必要で実装が複雑になり、空間もO(n)かかるから
+
+**②を選んだ根拠：**
+
+- 🟢 **1回の再帰（葉 → 根）** で「高さの計算」と「均衡チェック」を同時に行える
+- 🟢 `-1` という番兵値によって **不均衡を検知した瞬間に伝播を止められる**（無駄な探索をしない）
+- 🟢 TypeScriptの型推論で `number`（高さ）と `-1`（エラー）を同じ型に乗せられ、追加の型定義が不要
+
+**TypeScript特有の最適化ポイント：**
+
+- `node === null` チェックが **型ガード** として機能し、以降の `node.left/right` アクセスでコンパイルエラーが出なくなる（TypeScriptにしかない静的型チェックの恩恵）
+- 戻り値型 `number` を明示することで「-1 か 0以上の整数」という意図がドキュメントとして機能する
+
+> 📖 **このセクションで登場した用語**
+>
+> - **型推論**：型を明示しなくてもTypeScriptが自動で型を判断してくれる機能
+> - **型ガード**：`if (node === null)` などの条件分岐で、その後の型を絞り込む仕組み（JavaScriptには概念として存在するが、TypeScriptはそれをコンパイル時に静的検証できる）
+> - **静的型チェック**：コードを実行する前に型の誤りを見つけること。TypeScript最大の強み
+
+---
+
+## 4. 実装コード
+
+> 💡 **コードの大まかな構造（骨格）**
+>
+> 1. ヘルパー関数 `checkHeight` を定義する（高さを返す、不均衡なら `-1` を返す）
+> 2. `checkHeight` 内で `null` ノード（木の終端）に達したら高さ `0` を返す（ベースケース）
+> 3. 左・右のサブツリーを再帰的にチェックし、どちらかが `-1` なら即 `-1` を伝播する
+> 4. 左右の高さの差が 1 より大きければ `-1` を返す
+> 5. 問題なければ `max(左, 右) + 1` を現在のノードの高さとして返す
+> 6. `isBalanced` は `checkHeight(root) !== -1` を返すだけでよい
+
+```typescript
+// Runtime 1 ms
+// Beats 84.82%
+// Memory 60.76 MB
+// Beats 64.38%
+
+// ─────────────────────────────────────────────────────
+// LeetCode フォーマット（提出用）
+// ─────────────────────────────────────────────────────
+
+function isBalanced(root: TreeNode | null): boolean {
+    /**
+     * ボトムアップで高さを返すヘルパー関数。
+     * 「高さを計算しながら、同時に均衡チェックをする」ことが目的。
+     * 不均衡が見つかった場合は -1（番兵値）を返して上位に伝播させる。
+     *
+     * @param node 現在注目しているノード（null = 木の終端）
+     * @returns 均衡していれば 0以上の高さ、不均衡なら -1
+     * @complexity Time: O(n), Space: O(h)  h=木の高さ
+     */
+    function checkHeight(node: TreeNode | null): number {
+        // ── ベースケース ──────────────────────────────────
+        // null は「木が存在しない（空っぽ）」を意味する。
+        // 空の木の高さは 0 と定義する。
+        // ここでの型ガードにより、以降 node.left/right に安全にアクセスできる。
+        if (node === null) return 0;
+
+        // ── 左サブツリーを再帰的に検査 ───────────────────
+        // まず左の枝を根元まで潜ってから結果を受け取る（ボトムアップ）。
+        const leftHeight: number = checkHeight(node.left);
+
+        // 左サブツリーですでに不均衡が検出されていれば、
+        // このノードでこれ以上調べても意味がないので即座に -1 を返す。
+        // これが「早期リターン（無駄な計算を省く）」の核心。
+        if (leftHeight === -1) return -1;
+
+        // ── 右サブツリーを再帰的に検査 ───────────────────
+        const rightHeight: number = checkHeight(node.right);
+
+        // 右サブツリーで不均衡なら同様に早期リターン。
+        if (rightHeight === -1) return -1;
+
+        // ── このノードでの均衡チェック ────────────────────
+        // |左の高さ - 右の高さ| が 1 より大きければ不均衡。
+        // Math.abs で絶対値（＝常に0以上の値）を取ることで
+        // 「左が深すぎる」「右が深すぎる」の両方を一度に判定できる。
+        if (Math.abs(leftHeight - rightHeight) > 1) return -1;
+
+        // ── このノードの高さを返す ────────────────────────
+        // 現在ノードの高さ = 左右のうち深い方 + 1（自分自身の分）。
+        // +1 を忘れると親ノードの高さ計算がずれるため必須。
+        return Math.max(leftHeight, rightHeight) + 1;
+    }
+
+    // checkHeight が -1 でなければ均衡している。
+    // -1 でないことを確認するだけでよいので、この1行で完結する。
+    return checkHeight(root) !== -1;
+}
+```
+
+---
+
+### 🔍 動作トレース（入力例での変数変化）
+
+**Example 1** `root = [3, 9, 20, null, null, 15, 7]`
+
+```
+木の構造：
+        3
+       / \
+      9  20
+         / \
+        15   7
+
+再帰の呼び出し順（葉 → 根 の順に解決される）：
+
+checkHeight(9)
+  └─ checkHeight(null) → 0   ← 9の左（なし）
+  └─ checkHeight(null) → 0   ← 9の右（なし）
+  └─ |0 - 0| = 0 ≤ 1 → OK → return max(0,0)+1 = 1
+
+checkHeight(15)
+  └─ checkHeight(null) → 0
+  └─ checkHeight(null) → 0
+  └─ return 1
+
+checkHeight(7)
+  └─ checkHeight(null) → 0
+  └─ checkHeight(null) → 0
+  └─ return 1
+
+checkHeight(20)
+  └─ leftHeight  = checkHeight(15) = 1
+  └─ rightHeight = checkHeight(7)  = 1
+  └─ |1 - 1| = 0 ≤ 1 → OK → return max(1,1)+1 = 2
+
+checkHeight(3)   ← ルートノード
+  └─ leftHeight  = checkHeight(9)  = 1
+  └─ rightHeight = checkHeight(20) = 2
+  └─ |1 - 2| = 1 ≤ 1 → OK → return max(1,2)+1 = 3
+
+isBalanced: checkHeight(root) = 3 ≠ -1 → true ✅
+```
+
+---
+
+**Example 2** `root = [1, 2, 2, 3, 3, null, null, 4, 4]`
+
+```
+木の構造：
+              1
+            /   \
+           2     2
+          / \
+         3   3
+        / \
+       4   4
+
+checkHeight(4) → 1  ← 葉ノード
+checkHeight(4) → 1  ← 葉ノード
+
+checkHeight(3) [左の3]
+  └─ leftHeight  = 1, rightHeight = 1
+  └─ return 2
+
+checkHeight(3) [右の3]
+  └─ leftHeight = null→0, rightHeight = null→0
+  └─ return 1
+
+checkHeight(2) [左の2]
+  └─ leftHeight  = 2
+  └─ rightHeight = 1
+  └─ |2 - 1| = 1 ≤ 1 → OK → return 3
+
+checkHeight(2) [右の2]
+  └─ return 1
+
+checkHeight(1) ← ルート
+  └─ leftHeight  = 3
+  └─ rightHeight = 1
+  └─ |3 - 1| = 2 > 1 → 不均衡！ → return -1
+
+isBalanced: checkHeight(root) = -1 → false ✅
+```
+
+---
+
+**Example 3** `root = []`（空の木）
+
+```
+checkHeight(null) → 0   ← ベースケースで即座に 0 を返す
+
+isBalanced: 0 ≠ -1 → true ✅
+```
+
+---
+
+> 📖 **このセクションで登場した用語**
+>
+> - **ベースケース**：再帰関数が「これ以上潜らなくていい」と判断して処理を終える条件。再帰の終わりを決める「底」にあたる
+> - **再帰（Recursion）**：関数が自分自身を呼び出すこと。木構造の探索に非常に向いている（木も「小さな木の集まり」という再帰的な構造を持つため）
+> - **ボトムアップ**：木の葉（末端）から根（頂上）に向かって結果を積み上げていく処理の方向
+> - **早期リターン**：条件を満たした時点で即座に関数を終了させること。不要な後続処理を省いて効率を上げる
+
+---
+
+## TypeScript固有の最適化観点まとめ
+
+### 型安全性の活用（JavaScriptにない理由とセット）
+
+| TypeScript固有の機能                  | JavaScriptにない理由                           | この問題での恩恵                                           |
+| ------------------------------------- | ---------------------------------------------- | ---------------------------------------------------------- |
+| `node: TreeNode \| null` のユニオン型 | JSは変数がnullかどうかを型として表現できない   | `node.left` アクセス前に必ず null チェックを強制できる     |
+| `number` の戻り値型注釈               | JSは戻り値の型を強制できない                   | `-1` か `0以上の整数` という仕様をコンパイル時に保証       |
+| 型ガード `if (node === null)`         | JSにも書けるが型の絞り込みが静的に検証されない | コンパイラが「以降は非null」と認識し、安全なアクセスを許可 |
+
+### コンパイル時最適化
+
+- **型推論の活用**：`const leftHeight: number` の `: number` は実際には省略可能（TypeScriptが推論してくれる）。ただし今回は**読み手への意図伝達**として明示
+- **strict mode**：`null` チェックを怠ると `tsc` がエラーを出す。実行前にバグを発見できる
+
+---
+
+## 最終回答（LeetCode 提出フォーマット）
+
+```typescript
+function isBalanced(root: TreeNode | null): boolean {
+    function checkHeight(node: TreeNode | null): number {
+        if (node === null) return 0;
+
+        const leftHeight = checkHeight(node.left);
+        if (leftHeight === -1) return -1;
+
+        const rightHeight = checkHeight(node.right);
+        if (rightHeight === -1) return -1;
+
+        if (Math.abs(leftHeight - rightHeight) > 1) return -1;
+
+        return Math.max(leftHeight, rightHeight) + 1;
+    }
+
+    return checkHeight(root) !== -1;
+}
+```
+
+**計算量サマリー**
+
+- ⏱ Time: **O(n)** — 各ノードをちょうど1回だけ訪問する
+- 💾 Space: **O(h)** — 再帰の呼び出しスタックが木の高さ分だけ積まれる（均衡木ならO(log n)、最悪の一直線木でO(n)）
diff --git a/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README.md b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README.md
new file mode 100644
index 0000000..602964f
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README.md	
@@ -0,0 +1,666 @@
+# Balanced Binary Tree — ボトムアップDFSで O(n) 判定
+
+<h2 id="toc">目次</h2>
+
+- [概要](#overview)
+- [アルゴリズム要点（TL;DR）](#tldr)
+- [図解](#figures)
+- [正しさのスケッチ](#correctness)
+- [計算量](#complexity)
+- [Python 実装](#impl)
+- [CPython最適化ポイント](#cpython)
+- [エッジケースと検証観点](#edgecases)
+- [FAQ](#faq)
+
+---
+
+<h2 id="overview">概要</h2>
+
+> 💡 **この問題を一言で言うと**：「木のすべてのノードで、左右の枝の深さの差が1以内かどうかを判定する問題」です。
+
+与えられた二分木が **高さ均衡（height-balanced）** かどうかを `True`/`False` で返します。高さ均衡とは、**すべてのノードにおいて**左サブツリーの高さと右サブツリーの高さの差が最大1であることを指します。
+
+```
+入力:  root = [3, 9, 20, null, null, 15, 7]
+出力:  True
+
+入力:  root = [1, 2, 2, 3, 3, null, null, 4, 4]
+出力:  False
+
+入力:  root = []
+出力:  True
+```
+
+**なぜ難しいのか**：「全ノードで差が1以内」という条件は、根ノードだけでなく**葉に至るまですべてのノードで成立**しなければなりません。素朴に「高さを計算してから均衡を確認する」アプローチを取ると、同じノードを何度も訪問してしまい O(n²) になります。これを O(n) に改善するには、「高さ計算」と「均衡チェック」を**1パスで同時に行う**設計が必要です。
+
+**制約**：
+
+- ノード数：`0 ≤ n ≤ 5000`
+- ノード値：`-10^4 ≤ Node.val ≤ 10^4`
+
+> 📖 **この章で登場した用語**
+>
+> - **高さ均衡（height-balanced）**：木の全ノードで、左右の部分木の高さの差が最大1であるという性質
+> - **サブツリー（部分木）**：あるノードを根として、そこから下のすべてのノードの集合
+> - **葉ノード（leaf node）**：子ノードを持たない末端のノード
+> - **制約**：入力として与えられる値の範囲や条件のこと
+
+---
+
+<h2 id="tldr">アルゴリズム要点（TL;DR）</h2>
+
+> 💡 **TL;DR（Too Long; Didn't Read）**とは「長くて読めない人向けの要約」という意味の略語です。ここではアルゴリズム全体の戦略をまとめます。「なんとなくこういう手順で解くんだな」というイメージを掴むための章です。
+
+- **手法**：ボトムアップDFS（深さ優先探索）＋ 番兵値 `-1`
+    - 葉ノードから根ノードに向かって「高さ」を積み上げながら、同時に均衡チェックを行います。不均衡が確定した時点で番兵値 `-1` を上位ノードへ返すことで、無駄な探索を打ち切ります。
+- **データ構造**：`TreeNode` への参照のみ。追加のリストや辞書は不要です。
+    - 再帰のコールスタック（＝関数呼び出しが積み重なるメモリ領域）が唯一の追加メモリです。
+- **時間計算量**：`O(n)` — 各ノードをちょうど1回だけ訪問します。
+- **空間計算量**：`O(h)` — `h` は木の高さ。均衡木なら `O(log n)`、一直線の木（最悪）なら `O(n)`。
+- **番兵値パターン**：高さは常に `≥ 0` なので、`-1` を「不均衡が検知済み」という特別な信号として使います。
+    - これにより「高さを返す関数」と「均衡チェックを行う関数」を1つの関数にまとめられます。
+
+> 📖 **この章で登場した用語**
+>
+> - **DFS（深さ優先探索 / Depth-First Search）**：木やグラフを「できるだけ深く進んでから戻る」方式で探索するアルゴリズム
+> - **ボトムアップ**：葉ノード（末端）から根ノードに向かって結果を積み上げていく処理の方向
+> - **番兵値（Sentinel Value）**：通常の値としてあり得ない特別な値を使ってエラーや特殊状態を表す手法
+> - **コールスタック（Call Stack）**：関数呼び出しが積み重なっていく記録。再帰が深くなるほど大きくなる
+
+---
+
+<h2 id="figures">図解</h2>
+
+> 💡 **Mermaidフローチャートの読み方**：ひし形 `{}` は「条件分岐」（はい/いいえの分かれ道）、長方形 `[]` は「処理ステップ」を表します。矢印のラベル（`Yes` / `No`）が処理の流れを示します。
+
+## フローチャート
+
+以下の図は `check_height(node)` 関数の処理の流れを表しています。上から下へ読み進めてください。`check_height` は `isBalanced` の内部で呼ばれ、結果（高さ または `-1`）を根ノードまで積み上げていきます。
+
+```mermaid
+flowchart TD
+  Start[Start check_height node]
+  Start --> BaseCheck{node is None}
+  BaseCheck -- Yes --> Ret0[return 0]
+  BaseCheck -- No --> LeftCall[left_h = check_height node.left]
+  LeftCall --> LeftCheck{left_h == -1}
+  LeftCheck -- Yes --> RetN1a[return -1]
+  LeftCheck -- No --> RightCall[right_h = check_height node.right]
+  RightCall --> RightCheck{right_h == -1}
+  RightCheck -- Yes --> RetN1b[return -1]
+  RightCheck -- No --> BalCheck{abs left_h - right_h gt 1}
+  BalCheck -- Yes --> RetN1c[return -1]
+  BalCheck -- No --> RetH[return max left_h right_h + 1]
+```
+
+**主要なノードの意味**：
+
+- `Start[Start check_height node]`：`check_height` が呼ばれた入り口。引数 `node` は現在処理中のノード
+- `BaseCheck{node is None}`：木の末端（これ以上子がない）かを判定する条件分岐
+- `Ret0[return 0]`：空のノードは「高さ0の木」なので 0 を返す（ベースケース）
+- `LeftCheck{left_h == -1}`：左サブツリーで不均衡が検知済みかを判定する早期リターン
+- `BalCheck{abs left_h - right_h gt 1}`：このノードで左右の高さの差が大きすぎるかを判定
+- `RetN1c[return -1]`：番兵値 `-1` を返して「不均衡」を上位ノードへ伝播させる
+- `RetH[return max left_h right_h + 1]`：均衡OKのノードは「自分の高さ」を返して上位へ報告
+
+---
+
+### データフロー図
+
+以下の図は、入力ツリーがどのように処理されて最終的な `True`/`False` が得られるかを示しています。
+
+```mermaid
+graph LR
+  subgraph Input
+    A[TreeNode root]
+  end
+  subgraph Core
+    A --> B[check_height root]
+    B --> C[check_height left subtree]
+    B --> D[check_height right subtree]
+    C --> E[height or -1]
+    D --> F[height or -1]
+    E --> G[combine at node]
+    F --> G
+    G --> H[propagate up]
+  end
+  subgraph Output
+    H --> I{result != -1}
+    I -- True --> J[return True balanced]
+    I -- False --> K[return False unbalanced]
+  end
+```
+
+**主要な流れの説明**：
+
+- `Input → check_height root`：ルートノードから再帰が始まる
+- `check_height → left/right subtree`：左右のサブツリーを再帰的に処理する
+- `height or -1 → combine at node`：左右の結果を受け取り、このノードでの均衡を判定する
+- `propagate up`：結果（高さ または `-1`）を親ノードへ返していく
+- `result != -1 → True/False`：最終的な判定を行う
+
+---
+
+💡 **代表例 `root = [3, 9, 20, null, null, 15, 7]` でのトレース**
+
+>
+
+```
+Step 1: check_height(3) 開始
+
+Step 2: check_height(9) を呼ぶ（node=3 の左）
+        check_height(None) → 0 （9の左）
+        check_height(None) → 0 （9の右）
+        abs(0-0) = 0 ≤ 1 → 均衡OK
+        return max(0,0) + 1 = 1
+        → left_h = 1 （node=3 にとって）
+
+Step 3: check_height(20) を呼ぶ（node=3 の右）
+        check_height(15) → 1 （None + None から）
+        check_height(7)  → 1 （None + None から）
+        abs(1-1) = 0 ≤ 1 → 均衡OK
+        return max(1,1) + 1 = 2
+        → right_h = 2 （node=3 にとって）
+
+Step 4: node=3 での均衡チェック
+        abs(1-2) = 1 ≤ 1 → 均衡OK（ぎりぎり均衡）
+        return max(1,2) + 1 = 3
+
+Step 5: isBalanced → 3 != -1 → True ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **フローチャート**：処理の手順を図形と矢印で表したもの。ひし形=条件分岐、長方形=処理
+> - **データフロー図**：データがどのように変換・移動するかを示す図
+> - **伝播（propagate）**：ある値や信号が下位から上位へ（または逆に）次々と渡されていくこと
+
+---
+
+<h2 id="correctness">正しさのスケッチ</h2>
+
+> 💡 **「正しさのスケッチ」**とは、アルゴリズムが**常に正しい答えを返すことの根拠**を整理したものです。数学的な厳密証明ではなく「なぜ正しいと言えるか」を直感的に説明します。
+
+### 不変条件（アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件）
+
+`check_height(node)` が返す値は、常に以下のどちらかです：
+
+1. `node` を根とするサブツリーが均衡している場合 → そのサブツリーの正確な高さ（`≥ 0`）
+2. `node` を根とするサブツリーが不均衡の場合 → 番兵値 `-1`
+
+この不変条件が成立する理由：
+
+- 高さは「子の高さの最大値 + 1」で定義されるため、ベースケース（高さ0）から帰納的に正しい値が積み上がります
+- `-1` は通常の高さとして絶対に現れない値（高さは常に `≥ 0`）なので、信号として安全に使えます
+
+### 網羅性（すべてのケースをもれなく処理できているという保証）
+
+`check_height` は以下の4パターンをすべてカバーしています：
+
+| 状況                 | 条件                        | 処理                              |
+| -------------------- | --------------------------- | --------------------------------- |
+| 末端ノードに到達     | `node is None`              | `return 0`                        |
+| 左サブツリーが不均衡 | `left_h == -1`              | `return -1`（早期リターン）       |
+| 右サブツリーが不均衡 | `right_h == -1`             | `return -1`（早期リターン）       |
+| このノードで不均衡   | `abs(left_h - right_h) > 1` | `return -1`                       |
+| 均衡している         | 上記以外                    | `return max(left_h, right_h) + 1` |
+
+### ベースケース（再帰の終了条件）
+
+`node is None` のとき `return 0` を返します。これは「空の木の高さは0」という定義と一致します。空の木は高さの差を計算するノードが存在しないため、定義上「均衡している」と言えます（`0 != -1` なので `True` を返す）。
+
+### 終了性（アルゴリズムが必ず有限ステップで終わるという保証）
+
+`check_height` の再帰呼び出しは毎回 `node.left` または `node.right` を渡します。二分木は有限個のノードを持ち、各呼び出しで必ず「深さが1増える」ため、有限ステップで `None`（葉の下）に到達します。循環参照は二分木の定義上存在しないため、無限ループは発生しません。
+
+> 📖 **この章で登場した用語**
+>
+> - **不変条件（Invariant）**：アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件
+> - **網羅性（Completeness）**：すべてのケースをもれなく処理できているという保証
+> - **ベースケース（Base Case）**：再帰の終了条件。これがないと無限再帰になる
+> - **終了性（Termination）**：アルゴリズムが必ず有限ステップで終わるという保証
+> - **帰納的（Inductive）**：小さいケースが正しければ、より大きいケースも正しいという論法
+
+---
+
+<h2 id="complexity">計算量</h2>
+
+> 💡 **計算量**とは「入力が大きくなるにつれて、処理にかかる時間・メモリがどう増えるか」の目安です。
+
+| 記法       | 意味                   | 直感的なイメージ           |
+| ---------- | ---------------------- | -------------------------- |
+| `O(1)`     | 入力サイズによらず一定 | 辞書で直接ページを開く     |
+| `O(log n)` | 入力の対数で増加       | 辞書を二分探索で引く       |
+| `O(n)`     | 入力に比例して増加     | リストを端から順に読む     |
+| `O(n²)`    | 入力の2乗で増加        | 全ペアを総当たりで確認する |
+
+### このアルゴリズムの計算量
+
+|          | 計算量 | 理由                                                                                                         |
+| -------- | ------ | ------------------------------------------------------------------------------------------------------------ |
+| **時間** | `O(n)` | `check_height` は各ノードをちょうど1回だけ訪問する。早期リターンにより不均衡が確定した先のノードは訪問しない |
+| **空間** | `O(h)` | 再帰のコールスタックが木の高さ `h` 分だけ積み重なる                                                          |
+
+`h` の具体的な値：
+
+- **均衡木**（AVL木など）：`h = O(log n)` → 空間 `O(log n)`
+- **最悪ケース**（一直線の木）：`h = O(n)` → 空間 `O(n)`
+
+### 素朴な実装（トップダウン）との比較
+
+| アプローチ                    | 時間計算量 | 空間計算量 | 備考                                                      |
+| ----------------------------- | ---------- | ---------- | --------------------------------------------------------- |
+| **ボトムアップDFS（本実装）** | `O(n)`     | `O(h)`     | 1パス。各ノードを1回だけ訪問                              |
+| トップダウン再帰（素朴）      | `O(n²)`    | `O(h)`     | `height()` と `isBalanced()` を分離するため二重訪問が発生 |
+| BFS（幅優先探索）             | `O(n)`     | `O(n)`     | `deque` の確保コストがある。実装も複雑                    |
+
+**なぜトップダウンが O(n²) になるのか**：トップダウンでは「まず根での高さ差を確認 → 左右の子での高さ差を確認 → ...」と繰り返すため、深い部分のノードは繰り返し `height()` の計算対象になります。n 段の木では最悪 `1 + 2 + ... + n = O(n²)` の訪問回数になります。
+
+> 📖 **この章で登場した用語**
+>
+> - **時間計算量（Time Complexity）**：入力の大きさに対して処理にかかる手間がどう増えるかの目安
+> - **空間計算量（Space Complexity）**：処理中に使うメモリ量がどう増えるかの目安
+> - **トップダウン（Top-Down）**：根ノードから葉ノードに向かって処理する方向
+> - **コールスタック（Call Stack）**：関数呼び出しが積み重なっていく記録領域
+
+---
+
+<h2 id="impl">Python 実装</h2>
+
+> 💡 **コードを読む前に、実装の全体的な骨格を確認しましょう。**
+>
+> 1. `isBalanced` が外部に公開するエントリポイント。内部で `check_height` を呼ぶ
+> 2. `check_height` をネスト関数（関数の中の関数）として定義することで内部実装を隠す
+> 3. ベースケース（`node is None`）を最初にチェックし `0` を返す
+> 4. 左右のサブツリーを再帰的に処理し、`-1` が返ってきたら即座に `return -1`（早期リターン）
+> 5. `abs(left_h - right_h) > 1` で均衡チェックを行い、OKなら `max(left_h, right_h) + 1` を返す
+> 6. `isBalanced` は `check_height(root) != -1` を返す
+
+```python
+from __future__ import annotations
+# from __future__ import annotations：型ヒントを文字列として扱うようにする宣言。
+# Python 3.10 以前でも `TreeNode | None` のような記法を使えるようにするため。
+
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # TYPE_CHECKING ブロック：pylance（型チェッカー）のためだけに読まれる宣言。
+    # 実行時には読み込まれないため、TreeNode が未定義でもエラーにならない。
+    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: ...
+
+# LeetCode の実行環境では TreeNode は事前に定義されている。
+# ローカルで動かすときのフォールバック定義。
+try:
+    TreeNode  # 既に定義されていればこのブロックはスキップ
+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 = val
+            self.left = left
+            self.right = right
+
+
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        """
+        二分木が高さ均衡かどうかを判定する。
+
+        ボトムアップDFS + 番兵値パターンで O(n) を実現する。
+
+        Args:
+            root: 二分木のルートノード。空の木の場合は None。
+
+        Returns:
+            すべてのノードで左右の高さの差が 1 以内なら True、そうでなければ False。
+        """
+
+        def check_height(node: Optional[TreeNode]) -> int:
+            """
+            サブツリーの高さを返す。不均衡が検出された場合は -1 を返す。
+
+            なぜネスト関数にするか：
+            外部から直接呼べないようにし、「-1 という番兵値を返す」という
+            内部の詳細を isBalanced の呼び出し元に見せないようにするため。
+            また、ネスト関数はローカルスコープで名前解決されるため、
+            クラスメソッドより少し高速（CPythonの名前解決の仕組みによる）。
+
+            Args:
+                node: 現在処理中のノード（None = 木の末端）
+
+            Returns:
+                均衡している場合は 0 以上の高さ、不均衡なら -1。
+            """
+
+            # ── ベースケース ────────────────────────────────────────────
+            # node is None を使う理由：
+            # Python の None はシングルトン（プログラム中に1つしか存在しないオブジェクト）。
+            # `is` は「同じオブジェクトかどうか」を確認するため、
+            # `== None` より意味的に正確で高速。PEP 8（Pythonの公式スタイルガイド）でも推奨。
+            if node is None:
+                # 空の木（ノードなし）の高さは 0。
+                # この 0 が親ノードの left_h または right_h として使われる。
+                return 0
+
+            # ── 左サブツリーを再帰的に検査 ──────────────────────────────
+            # node.left は Optional[TreeNode] 型（TreeNode か None のどちらか）。
+            # None のときは次の再帰呼び出しでベースケースとして処理される。
+            left_h: int = check_height(node.left)
+
+            # 早期リターン（Early Return）：
+            # 左で不均衡が確定していれば、右サブツリーを調べる必要が全くない。
+            # これにより不必要な再帰呼び出しを省き、効率を保つ。
+            if left_h == -1:
+                return -1
+
+            # ── 右サブツリーを再帰的に検査 ──────────────────────────────
+            right_h: int = check_height(node.right)
+
+            # 右サブツリーで不均衡が検知済みのときも、-1 を上位へ伝播させる。
+            if right_h == -1:
+                return -1
+
+            # ── このノードでの均衡チェック ───────────────────────────────
+            # abs() を使う理由：
+            # 「左が深い」「右が深い」の両パターンを1行で処理でき、
+            # かつ abs() はCPythonのC実装（組み込み関数）なので高速。
+            if abs(left_h - right_h) > 1:
+                # このノードで不均衡 → 番兵値 -1 を返して不均衡を上位へ知らせる
+                return -1
+
+            # ── このノードの高さを返す ────────────────────────────────────
+            # このノードの高さ = 左右の最大値 + 自分自身の1段分。
+            # +1 を忘れると高さが1ずれて正しい均衡チェックができなくなる。
+            # max() もCPythonのC実装で高速。
+            return max(left_h, right_h) + 1
+
+        # check_height(root) が -1 でなければ、全ノードが均衡している。
+        # -1 でない（True） = 均衡、-1（False） = 不均衡。
+        return check_height(root) != -1
+```
+
+---
+
+💡 **コードの動作トレース**（代表例 `root = [3, 9, 20, null, null, 15, 7]`）
+
+```
+isBalanced(root) 呼び出し
+  → check_height(node=TreeNode(3)) 開始
+
+  ├─ check_height(node=TreeNode(9))  ← 3の左
+  │    ├─ check_height(None) → return 0    ← 9の左
+  │    │   left_h=0; (0 != -1) → 継続
+  │    ├─ check_height(None) → return 0    ← 9の右
+  │    │   right_h=0; (0 != -1) → 継続
+  │    ├─ abs(0-0) = 0 ≤ 1 → 均衡OK
+  │    └─ return max(0,0)+1 = 1
+  │
+  │   left_h = 1; (1 != -1) → 継続
+  │
+  ├─ check_height(node=TreeNode(20))  ← 3の右
+  │    ├─ check_height(TreeNode(15)) → return 1   ← 同様の手順
+  │    │   left_h=1; (1 != -1) → 継続
+  │    ├─ check_height(TreeNode(7))  → return 1
+  │    │   right_h=1; (1 != -1) → 継続
+  │    ├─ abs(1-1) = 0 ≤ 1 → 均衡OK
+  │    └─ return max(1,1)+1 = 2
+  │
+  │   right_h = 2; (2 != -1) → 継続
+  │
+  ├─ abs(1-2) = 1 ≤ 1 → 均衡OK（ぎりぎり均衡）
+  └─ return max(1,2)+1 = 3
+
+check_height(root) = 3
+3 != -1 → isBalanced = True ✅
+```
+
+**不均衡ケース** `root = [1, 2, 2, 3, 3, null, null, 4, 4]`（抜粋）：
+
+```
+ check_height(TreeNode(1)) ← ルート
+   left_h  = check_height(2の左) = 3   （深い）
+   right_h = check_height(2の右) = 1
+   abs(3-1) = 2 > 1 → 不均衡！
+   return -1
+
+ check_height(root) = -1
+ -1 == -1 → isBalanced = False ✅
+```
+
+> 📖 **この章で登場した用語**
+>
+> - **`from __future__ import annotations`**：型ヒントを文字列として扱うようにする宣言。前方参照の問題を回避できる
+> - **`TYPE_CHECKING`**：`True` になるのは型チェッカー（pylance等）が解析するときだけ。実行時は `False`
+> - **`Optional[X]`**：`X` または `None` のどちらかであることを表す型ヒント。`X | None` と同義（Python 3.10+）
+> - **`__slots__`**：クラスの属性をあらかじめ宣言し、辞書の代わりにスロットで管理する機能
+> - **ネスト関数（Nested Function）**：関数の中に定義された関数。外部スコープから直接呼べない
+> - **早期リターン（Early Return）**：条件が確定した時点で即座に `return` する手法。ネストを浅く保てる
+
+---
+
+<h2 id="cpython">CPython最適化ポイント</h2>
+
+> 💡 この章では「同じ処理でも書き方によって速さが変わる理由」を説明します。最適化テクニックは「最適化前 → 最適化後 → なぜ速いか」の3点セットで説明します。
+
+### 最適化1：`is None` vs `== None`
+
+```python
+# 最適化前（遅い・意味的にも不正確）
+if node == None:
+    return 0
+
+# 最適化後（速い・PEP 8 推奨）
+if node is None:
+    return 0
+```
+
+**なぜ速いか**：`== None` は `__eq__` メソッドを呼び出すため関数呼び出しのオーバーヘッドがあります。一方 `is` は「同じオブジェクトかどうか」をポインタ（＝メモリアドレス）の比較だけで判断するため、C レベルで1命令で完了します。`None` は Python のシングルトンなので `is` が意味的にも正確です。
+
+---
+
+### 最適化2：組み込み関数 `abs()` と `max()` の活用
+
+```python
+# 最適化前（Pure Python の条件分岐）
+if left_h > right_h:
+    diff = left_h - right_h
+else:
+    diff = right_h - left_h
+if diff > 1:
+    return -1
+
+# 最適化後（C実装の組み込み関数を使う）
+if abs(left_h - right_h) > 1:
+    return -1
+```
+
+**なぜ速いか**：`abs()` と `max()` はCPythonのC実装（組み込み関数）であり、Pure Python（＝Pythonコードで書かれた処理）より高速に動作します。またコードが簡潔になり「左が深い」「右が深い」の両パターンを1行で処理できます。
+
+```python
+# 最終的な高さの計算も max() を使う（同様の理由）
+return max(left_h, right_h) + 1
+```
+
+---
+
+### 最適化3：ネスト関数でのローカルスコープ活用
+
+```python
+# 最適化前（クラスメソッドとして定義）
+class Solution:
+    def check_height(self, node):  # self 経由のアクセスで辞書検索が発生
+        ...
+    def isBalanced(self, root):
+        return self.check_height(root) != -1
+
+# 最適化後（ネスト関数として定義）
+class Solution:
+    def isBalanced(self, root):
+        def check_height(node):  # ローカルスコープで名前解決 → 高速
+            ...
+        return check_height(root) != -1
+```
+
+**なぜ速いか**：Pythonの名前解決は「ローカル → エンクロージング → グローバル → 組み込み」の順に探索します（LEGB ルール）。ネスト関数はエンクロージングスコープで見つかるため、`self.check_height` のようにグローバルスコープ経由で辞書検索するより高速です。
+
+---
+
+### 最適化4：早期リターンによる枝刈り
+
+```python
+# 最適化なし（両サブツリーを必ず計算する）
+left_h = check_height(node.left)
+right_h = check_height(node.right)
+if left_h == -1 or right_h == -1:
+    return -1
+
+# 最適化あり（左で不均衡が確定したら右を調べない）
+left_h = check_height(node.left)
+if left_h == -1:
+    return -1          # ← ここで右サブツリーの探索をスキップ
+right_h = check_height(node.right)
+```
+
+**なぜ速いか**：不均衡が左サブツリーで確定した時点で、右サブツリーの探索は結果に影響しません。早期リターン（枝刈り＝答えが得られないと分かった探索経路を途中で切り捨てること）により、最悪ケースに近い木での探索コストを大幅に削減できます。
+
+> 📖 **この章で登場した用語**
+>
+> - **LEGB ルール**：Python の名前解決の優先順位。Local（ローカル）→ Enclosing（エンクロージング）→ Global（グローバル）→ Built-in（組み込み）の順
+> - **C実装の組み込み関数**：`abs()` `max()` `len()` など、Pythonコードではなく C 言語で実装された関数。オーバーヘッドが少なく高速
+> - **枝刈り（Pruning）**：答えが得られないと分かった探索経路を途中で切り捨てること。探索空間を削減できる
+> - **シングルトン（Singleton）**：プログラム中に1つしか存在しないオブジェクト。Python の `None`・`True`・`False` がこれにあたる
+
+---
+
+<h2 id="edgecases">エッジケースと検証観点</h2>
+
+> 💡 **エッジケース**とは「入力が空・最小値・最大値・特殊な形状」など、通常とは異なる境界的な入力のことです。エッジケースを見落とすと、普通のテストは通るのに特定の入力でだけバグが発生します。
+
+| #   | エッジケース                     | 入力例                                          | 期待出力 | なぜ問題になりうるか                                                                                                                                |
+| --- | -------------------------------- | ----------------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 1   | **空の木**                       | `root = None`                                   | `True`   | ベースケースで即座に `0` を返すため、`check_height(None) = 0 != -1 → True` になることを確認                                                         |
+| 2   | **ノード1個**                    | `root = [1]`                                    | `True`   | 左右ともに `None` → `abs(0-0) = 0 ≤ 1` → 均衡                                                                                                       |
+| 3   | **片側にのみ子がある（右傾き）** | `root = [1, None, 2, None, 3]`                  | `False`  | 高さの差が `abs(0-2) = 2 > 1` となるため不均衡。`[1, None, 2]` の場合は `abs(0-1) = 1` で均衡（`True`）となる。                                     |
+| 4   | **一直線の木（最悪ケース）**     | `[1, 2, null, 3, null, 4, ...]` n=5000          | `False`  | 再帰の深さが n=5000 に達する。LeetCodeの Python 環境は再帰上限が引き上げられているが、ローカルでは `sys.setrecursionlimit()` が必要になる場合がある |
+| 5   | **完全二分木**                   | n=5000 の完全二分木                             | `True`   | すべてのノードで `abs(h_left - h_right) ≤ 1` が成立。高さは `O(log n)`                                                                              |
+| 6   | **根のみ不均衡・子は均衡**       | `[1, 2, None, 3, 4]`                            | `False`  | 子ノードが均衡でも根ノードで `abs(2-0) = 2 > 1` → 不均衡                                                                                            |
+| 7   | **根は均衡・深いところで不均衡** | `[1, 2, 2, 3, null, null, 3, 4, null, null, 4]` | `False`  | 根でのチェックを通過しても、深いノードで不均衡が検知されると `-1` が伝播する                                                                        |
+| 8   | **ノード値が境界値**             | ノード値 = `-10^4` や `10^4`                    | 正常動作 | `val` は均衡チェックに影響しないため、値の大小は結果に無関係                                                                                        |
+
+> 📖 **この章で登場した用語**
+>
+> - **エッジケース（Edge Case）**：空のリスト・要素1つ・最大サイズ入力など、境界的な条件の入力
+> - **完全二分木（Complete Binary Tree）**：最後の段を除く全段が埋まっており、最後の段は左から詰まっている二分木
+> - **再帰上限（Recursion Limit）**：Python が許可する最大の再帰深さ。デフォルトは 1000。`sys.setrecursionlimit()` で変更できる
+
+---
+
+<h2 id="faq">FAQ</h2>
+
+> 💡 **FAQ（Frequently Asked Questions）**は「初学者がつまずきやすいポイント」を想定した質問と回答です。各回答は「結論 → 理由 → 補足（具体例）」の順で書かれています。
+
+---
+
+**Q1. なぜ番兵値として `-1` を使うのですか？ `False` を使えばよいのでは？**
+
+**結論**：`-1` を使うのは、「高さを返す」と「不均衡を伝える」の2つの役割を1つの関数でこなすためです。
+
+**理由**：`False` を返すと型が `bool` になり、「高さ（`int`）」と「不均衡フラグ（`bool`）」の2種類が混在して型安全でなくなります。`-1` は「高さは常に `≥ 0`」という性質を利用した安全な番兵値で、型を `int` 一種類に保てます。
+
+**補足**：例えば `return (height, is_balanced)` のようにタプルで返すこともできますが、タプルの生成コストが発生します。`-1` を使う実装は最もシンプルで高速です。
+
+---
+
+**Q2. トップダウン再帰（素朴な方法）がなぜ O(n²) になるのか、具体例で教えてください。**
+
+**結論**：トップダウンでは「高さ計算」と「均衡チェック」を別々に行うため、同じノードが複数回 `height()` の計算対象になります。
+
+**理由**：以下の木を例に考えます。
+
+```
+        1
+       / \
+      2   3
+     / \
+    4   5
+```
+
+トップダウンで `isBalanced(1)` を呼ぶと：
+
+1. `height(2)` と `height(3)` を計算（4, 5 を訪問）
+2. `isBalanced(2)` を再帰呼び出し → また `height(4)` と `height(5)` を計算（二重訪問！）
+3. `isBalanced(3)` を再帰呼び出し → また `height()` を計算
+
+**補足**：一直線の木（n 段）では、最深ノードが `1 + 2 + ... + n = n(n+1)/2 = O(n²)` 回訪問されます。
+
+---
+
+**Q3. `node is None` と `not node` はどちらが良いですか？**
+
+**結論**：`node is None` の方が推奨されます。
+
+**理由**：`not node` は「`node` がFalsy（偽と評価される値）かどうか」を判定します。`None` はFalsyですが、`0`・`[]`・`""` もFalsyです。もし `TreeNode` が `__bool__` を実装していて特定の条件で `False` を返す場合、`not node` は意図しない動作をする可能性があります。`node is None` は「None と同じオブジェクトかどうか」だけを確認するため、常に意図通りに動作します。
+
+**補足**：PEP 8（Pythonの公式コーディングスタイルガイド）でも `None` との比較には `is` / `is not` を使うことが明示されています。
+
+---
+
+**Q4. 再帰ではなくイテレーティブ（繰り返し処理）で実装できますか？**
+
+**結論**：できます。ただし実装が大幅に複雑になります。
+
+**理由**：再帰はコールスタックを暗黙的に利用しますが、イテレーティブ実装では自分でスタック（`deque` など）を管理し、「後処理」（子ノードを処理してから親を処理する後順DFS）を明示的に実装する必要があります。
+
+**補足（イテレーティブの骨格）**：
+
+```python
+from collections import deque
+
+stack: deque = deque()
+heights: dict = {}
+# ... post-order traversal を手動で実装する（複雑）
+```
+
+ノード数 n が最大 5000 という制約のもとでは、再帰の深さが問題になりにくいため、再帰実装の方がシンプルで保守性が高いです。
+
+---
+
+**Q5. `check_height` を `Solution` のメソッドとして定義するのと、ネスト関数にするのでは何が違いますか？**
+
+**結論**：ネスト関数の方が「情報隠蔽」と「わずかな速度向上」の2点で優れています。
+
+**理由**：
+
+- **情報隠蔽**：`check_height` は「-1 という番兵値を返す内部実装」です。クラスメソッドにすると `solution.check_height(node)` として外部から呼べてしまい、番兵値パターンの内部実装が漏れます。ネスト関数にすると `isBalanced` の外から直接呼ぶことができません
+- **速度**：Pythonの名前解決はローカルスコープが最速です（LEGB ルール）。ネスト関数はエンクロージングスコープで解決されるため、`self.check_height` のようにグローバル辞書を経由するより高速です
+
+**補足**：チームのコーディング規約やコードの規模によっては、クラスメソッドとして定義して `_check_height`（アンダースコアで「内部メソッド」を示す慣習）とすることも一般的です。
+
+> 📖 **この章で登場した用語**
+>
+> - **Falsy（偽値）**：`if` 文で `False` として評価される値。Python では `None`・`0`・`[]`・`""`・`{}` など
+> - **後順DFS（Post-order DFS）**：左サブツリー → 右サブツリー → 自分自身 の順に訪問するDFS。ボトムアップ処理に対応
+> - **情報隠蔽（Information Hiding）**：内部実装の詳細を外部から見えないようにすること。インターフェースをシンプルに保つ設計原則
+> - **PEP 8**：Pythonの公式コーディングスタイルガイド。命名規則・空白の使い方・`is None` の使用など多くのルールを定めている
+
+---
+
+_LeetCode 110 — Balanced Binary Tree_
+_アルゴリズム：ボトムアップDFS + 番兵値パターン | Time: O(n) | Space: O(h)_
diff --git a/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html
new file mode 100644
index 0000000..e0dd375
--- /dev/null
+++ b/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html	
@@ -0,0 +1,1958 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <title>LeetCode 110 · Balanced Binary Tree</title>
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;500;700&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <script src="https://unpkg.com/react@18/umd/react.development.js" crossorigin></script>
+        <script
+            src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"
+            crossorigin
+        ></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"
+        />
+        <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>
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            .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;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            details[open] > summary .arrow {
+                transform: rotate(90deg);
+            }
+            .arrow {
+                display: inline-block;
+                transition: transform 0.2s;
+            }
+        </style>
+    </head>
+    <body class="bg-gradient-to-br from-emerald-50 via-sky-50 to-slate-100 min-h-screen py-8 px-4">
+        <div class="max-w-5xl mx-auto">
+            <!-- ===================== HEADER ===================== -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-lg"
+                style="background: linear-gradient(135deg, #d1fae5, #bfdbfe)"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >LeetCode 110</span
+                    >
+                    <span
+                        class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Easy</span
+                    >
+                    <span
+                        class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Tree · DFS</span
+                    >
+                </div>
+                <h1 class="outfit text-4xl font-extrabold text-teal-900 mb-1">
+                    Balanced Binary Tree
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    ボトムアップDFS（番兵値-1）による O(n) 実装
+                </p>
+                <div
+                    class="mt-4 inline-block bg-white/70 rounded-xl px-5 py-3 text-teal-800 font-semibold text-base"
+                >
+                    💡
+                    一言で言うと：「木のすべてのノードで、左右の枝の深さの差が1以内かどうかを判定する問題」
+                </div>
+                <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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ===================== OVERVIEW ===================== -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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">
+                        💡
+                        この問題を一言で言うと：「木のすべてのノードで、左右の枝の深さの差が1以内かどうかを判定する問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2 leading-7">
+                        高さ均衡二分木（height-balanced binary
+                        tree）とは、全ノードで左右の部分木の高さの差が最大1であるような二分木です。
+                        空の木（root = null）も高さ均衡として扱います。
+                    </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 leading-7">
+                        <li>
+                            「高さ計算」と「均衡チェック」を別々に行うと、同じノードを何度も訪問するためO(n²)になってしまいます（素朴なトップダウン再帰の罠）。
+                        </li>
+                        <li>
+                            不均衡が見つかった瞬間に結果を上位ノードへ伝える仕組みがないと、無駄な計算が増えてしまいます。
+                        </li>
+                    </ul>
+                </div>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-7">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-base 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-base font-mono">O(h)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            Bottom-up DFS
+                        </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">
+                            番兵値 -1
+                        </div>
+                        <div class="text-xs mt-1">エラー伝播</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 1 — true
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+    3
+   / \
+  9  20
+     / \
+    15   7</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            全ノードで左右の高さの差 ≤ 1 →
+                            <span class="text-emerald-600 font-bold">true</span>
+                        </p>
+                    </div>
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 2 — false
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+      1
+    /   \
+   2     2
+  / \
+ 3   3
+/ \
+4   4</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            ルートの左右の高さ差 = 2 →
+                            <span class="text-red-500 font-bold">false</span>
+                        </p>
+                    </div>
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 3 — true
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+（空の木）
+root = null</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            空の木は定義上 均衡 →
+                            <span class="text-emerald-600 font-bold">true</span>
+                        </p>
+                    </div>
+                </div>
+
+                <div class="p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        🧠 解法のアイデア：1パスで高さ計算と均衡チェックを同時に行う
+                    </p>
+                    <p class="text-slate-600 text-sm leading-7">
+                        葉ノード（子のないノード）から根ノードに向かってさかのぼりながら（ボトムアップ）、高さを返しつつ同時に均衡チェックも行います。
+                        不均衡が見つかったら
+                        <span class="font-mono bg-white px-1 rounded text-red-600">-1</span
+                        >（番兵値）を返し、上位ノードへ伝播させます。
+                        これにより各ノードをちょうど1回だけ訪問する O(n) が実現できます。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===================== STEPS (React) ===================== -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-2 pb-2 border-b-4 border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    各ステップをクリックするか ▶ Play で自動再生できます。
+                </p>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ===================== CODE ===================== -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-5 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 leading-7">
+                        <li>
+                            <strong>isBalanced</strong
+                            >：外部に公開するエントリポイント。check_height を呼んで -1 でなければ
+                            True を返す
+                        </li>
+                        <li>
+                            <strong>check_height（ネスト関数）</strong
+                            >：再帰の本体。高さを返しつつ不均衡なら -1 を返す
+                        </li>
+                        <li>ベースケース：node が None なら高さ 0 を返す</li>
+                        <li>左右を再帰し、-1 が返ってきたら即 -1 を伝播（早期リターン）</li>
+                        <li>
+                            左右の高さの差 &gt; 1 なら -1、そうでなければ max(左, 右) + 1 を返す
+                        </li>
+                    </ol>
+                </div>
+
+                <pre class="line-numbers"><code class="language-python">from typing import Optional
+
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -&gt; bool:
+
+        def check_height(node: Optional[TreeNode]) -&gt; int:
+            # ベースケース：空のノードは高さ0
+            # `is None` はPEP 8推奨。None はシングルトンなので is が正確
+            if node is None:
+                return 0
+
+            # 左サブツリーの高さを再帰で取得
+            left_height = check_height(node.left)
+            # 左が -1（不均衡検知済み）なら即座に -1 を返す（早期リターン）
+            if left_height == -1:
+                return -1
+
+            # 右サブツリーの高さを再帰で取得
+            right_height = check_height(node.right)
+            # 右が -1 のときも同様に伝播
+            if right_height == -1:
+                return -1
+
+            # このノードでの均衡チェック
+            # abs() はC実装の組み込み関数で高速
+            if abs(left_height - right_height) &gt; 1:
+                return -1  # 番兵値 -1 を返して不均衡を上位へ知らせる
+
+            # このノードの高さ = max(左, 右) + 自分の1
+            # max() もC実装の組み込み関数で高速
+            return max(left_height, right_height) + 1
+
+        # check_height が -1 でなければ均衡している
+        return check_height(root) != -1</code></pre>
+
+                <div class="mt-5 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"
+                    >
+check_height(3)  開始
+  ├─ check_height(9)   → left=0, right=0, diff=0 ≤ 1  → return 1
+  │   left_height=1 (≠-1、継続)
+  ├─ check_height(20)  開始
+  │   ├─ check_height(15) → return 1
+  │   │   left_height=1 (≠-1、継続)
+  │   ├─ check_height(7)  → return 1
+  │   │   right_height=1 (≠-1、継続)
+  │   └─ abs(1-1)=0 ≤ 1 → return max(1,1)+1 = 2
+  │   right_height=2 (≠-1、継続)
+  └─ abs(1-2)=1 ≤ 1 → return max(1,2)+1 = 3
+
+check_height(root) = 3
+3 != -1  →  isBalanced = True ✅</pre
+                    >
+                </div>
+
+                <div class="mt-4 p-4 rounded-xl bg-red-50 border border-red-200">
+                    <p class="text-red-800 font-semibold text-sm mb-2">
+                        ▶ 不均衡ケース [1,2,2,3,3,null,null,4,4] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-7 overflow-x-auto whitespace-pre"
+                    >
+check_height(4) → 1  (左の4)
+check_height(4) → 1  (右の4)
+check_height(3) [左]  → abs(1-1)=0 → return 2
+check_height(3) [右]  → abs(0-0)=0 → return 1
+check_height(2) [左]  → abs(2-1)=1 ≤ 1 → return 3
+check_height(2) [右]  → return 1
+check_height(1) [ルート]
+  left_height=3, right_height=1
+  abs(3-1) = 2  &gt; 1  → return -1  ← 不均衡！
+
+check_height(root) = -1
+-1 == -1  →  isBalanced = False ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ===================== FLOWCHART ===================== -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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="28" height="18">
+                                <ellipse
+                                    cx="14"
+                                    cy="9"
+                                    rx="13"
+                                    ry="8"
+                                    fill="#d1fae5"
+                                    stroke="#10b981"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <rect
+                                    x="1"
+                                    y="2"
+                                    width="26"
+                                    height="14"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <polygon
+                                    points="14,1 27,9 14,17 1,9"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 col-span-2 md:col-span-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500 mr-1"></span
+                            ><span class="mr-2">緑＝はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-500 mr-1"></span>赤＝いいえ
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-5 overflow-x-auto">
+                    <svg
+                        viewBox="0 0 560 1200"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Balanced Binary Tree DFS 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="#dc2626" />
+                            </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>
+
+                        <!-- N1: START -->
+                        <ellipse
+                            cx="280"
+                            cy="44"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="40"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#065f46"
+                            font-weight="600"
+                        >
+                            isBalanced(root) 開始
+                        </text>
+                        <text
+                            x="280"
+                            y="55"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            check_height(root) を呼ぶ
+                        </text>
+
+                        <!-- Arrow N1→N2 -->
+                        <line
+                            x1="280"
+                            y1="72"
+                            x2="280"
+                            y2="105"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N2: check_height(node) called -->
+                        <rect
+                            x="80"
+                            y="108"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="128"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            check_height(node) を呼ぶ
+                        </text>
+                        <text
+                            x="280"
+                            y="148"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            node = 現在処理中のノード
+                        </text>
+
+                        <!-- Arrow N2→N3 -->
+                        <line
+                            x1="280"
+                            y1="158"
+                            x2="280"
+                            y2="195"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N3: node is None? -->
+                        <polygon
+                            points="280,198 430,248 280,298 130,248"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="243"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            node is None ?
+                        </text>
+                        <text
+                            x="280"
+                            y="260"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （木の末端に到達したか）
+                        </text>
+
+                        <!-- N3 → YES → return 0 -->
+                        <line
+                            x1="430"
+                            y1="248"
+                            x2="500"
+                            y2="248"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="464"
+                            y="240"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="220"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="244"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="262"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            0
+                        </text>
+
+                        <!-- N3 → NO → continue down -->
+                        <line
+                            x1="280"
+                            y1="298"
+                            x2="280"
+                            y2="335"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="293"
+                            y="320"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N4: left_height = check_height(node.left) -->
+                        <rect
+                            x="80"
+                            y="338"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="358"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            left_height = check_height(node.left)
+                        </text>
+                        <text
+                            x="280"
+                            y="378"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            左の部分木の高さを再帰で計算
+                        </text>
+
+                        <!-- Arrow N4→N5 -->
+                        <line
+                            x1="280"
+                            y1="388"
+                            x2="280"
+                            y2="425"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N5: left_height == -1 ? -->
+                        <polygon
+                            points="280,428 430,478 280,528 130,478"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="473"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            left_height == -1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="490"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （左サブツリーで不均衡を検知済みか）
+                        </text>
+
+                        <!-- N5 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="478"
+                            x2="500"
+                            y2="478"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="470"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="450"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="474"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="492"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N5 → NO -->
+                        <line
+                            x1="280"
+                            y1="528"
+                            x2="280"
+                            y2="565"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="550"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N6: right_height = check_height(node.right) -->
+                        <rect
+                            x="80"
+                            y="568"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="588"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            right_height = check_height(node.right)
+                        </text>
+                        <text
+                            x="280"
+                            y="608"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            右の部分木の高さを再帰で計算
+                        </text>
+
+                        <!-- Arrow N6→N7 -->
+                        <line
+                            x1="280"
+                            y1="618"
+                            x2="280"
+                            y2="655"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N7: right_height == -1 ? -->
+                        <polygon
+                            points="280,658 430,708 280,758 130,708"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="703"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            right_height == -1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="720"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （右サブツリーで不均衡を検知済みか）
+                        </text>
+
+                        <!-- N7 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="708"
+                            x2="500"
+                            y2="708"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="700"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="680"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="704"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="722"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N7 → NO -->
+                        <line
+                            x1="280"
+                            y1="758"
+                            x2="280"
+                            y2="795"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="780"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N8: abs(left-right) > 1 ? -->
+                        <polygon
+                            points="280,798 430,858 280,918 130,858"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="848"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            abs(left_height - right_height) &gt; 1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="868"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （このノードで左右の高さの差が大きすぎるか）
+                        </text>
+
+                        <!-- N8 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="858"
+                            x2="500"
+                            y2="858"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="850"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="830"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="854"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="872"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N8 → NO -->
+                        <line
+                            x1="280"
+                            y1="918"
+                            x2="280"
+                            y2="955"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="940"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N9: return max(l,r)+1 -->
+                        <rect
+                            x="80"
+                            y="958"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="978"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            return max(left_height, right_height) + 1
+                        </text>
+                        <text
+                            x="280"
+                            y="998"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            このノードの高さ（均衡OK）を親へ返す
+                        </text>
+
+                        <!-- Arrow N9→N10 -->
+                        <line
+                            x1="280"
+                            y1="1008"
+                            x2="280"
+                            y2="1045"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N10: END -->
+                        <ellipse
+                            cx="280"
+                            cy="1080"
+                            rx="140"
+                            ry="32"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="1074"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#065f46"
+                            font-weight="600"
+                        >
+                            check_height(root) != -1 を返す
+                        </text>
+                        <text
+                            x="280"
+                            y="1092"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            True（均衡）または False（不均衡）
+                        </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-2 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→ check_height(node=3) を呼ぶ。node は None でないので処理継続
+                        </li>
+                        <li>
+                            左サブツリー check_height(9) を計算 → 9の左右はどちらも None
+                            なので高さ1を返す。-1 でないので継続
+                        </li>
+                        <li>
+                            右サブツリー check_height(20) を計算 → 15と7の高さがそれぞれ1 →
+                            abs(1-1)=0 ≤ 1 → 高さ2を返す。-1 でないので継続
+                        </li>
+                        <li>ルート3での均衡チェック：abs(1-2)=1 ≤ 1 → 均衡OK → 高さ3を返す</li>
+                        <li>
+                            「終了」→ 3 != -1 → isBalanced =
+                            <span class="text-emerald-600 font-bold">True</span>
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ===================== COMPLEXITY ===================== -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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(log n)</div>
+                            <div class="leading-5">
+                                log倍に増加<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-5">
+                    <table class="w-full border-collapse text-sm">
+                        <thead>
+                            <tr class="bg-gradient-to-r from-emerald-100 to-sky-100">
+                                <th
+                                    class="p-3 text-left text-slate-700 font-bold border border-slate-200 rounded-tl-lg"
+                                >
+                                    アプローチ
+                                </th>
+                                <th
+                                    class="p-3 text-center text-slate-700 font-bold border border-slate-200"
+                                >
+                                    時間計算量
+                                </th>
+                                <th
+                                    class="p-3 text-center text-slate-700 font-bold border border-slate-200"
+                                >
+                                    空間計算量
+                                </th>
+                                <th
+                                    class="p-3 text-left text-slate-700 font-bold border border-slate-200 rounded-tr-lg"
+                                >
+                                    備考
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="bg-emerald-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-emerald-800"
+                                >
+                                    ✅ ボトムアップDFS（番兵値-1）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-emerald-700"
+                                >
+                                    O(n)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-emerald-700"
+                                >
+                                    O(h)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    各ノードを1回だけ訪問。h=木の高さ（均衡木ではO(log
+                                    n)、最悪O(n)）
+                                </td>
+                            </tr>
+                            <tr class="bg-red-50">
+                                <td class="p-3 border border-slate-200 font-semibold text-red-700">
+                                    ❌ トップダウン再帰（素朴）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-red-600"
+                                >
+                                    O(n²)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono text-red-600"
+                                >
+                                    O(h)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    高さ計算と均衡チェックを分離するため同じノードを繰り返し訪問してしまう
+                                </td>
+                            </tr>
+                            <tr class="bg-amber-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-amber-700"
+                                >
+                                    BFS（幅優先探索）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-amber-600"
+                                >
+                                    O(n)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono text-amber-600"
+                                >
+                                    O(n)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    dequeのメモリ確保コストがある。実装も複雑になりやすい
+                                </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>：check_height
+                        はすべてのノードをちょうど1回だけ訪問します。不均衡が見つかった瞬間に -1
+                        を返す早期リターンにより、無駄な再帰呼び出しを省けています。<br />
+                        <strong>空間計算量 O(h)</strong>：再帰呼び出しのコールスタックが木の高さ h
+                        分だけ積み重なります。均衡木では h = O(log n)、最悪の一直線の木では h = O(n)
+                        になります。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===================== GLOSSARY ===================== -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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="arrow text-emerald-500">▶</span>
+                            高さ均衡二分木（Height-balanced Binary Tree）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            すべてのノードで、左右の部分木の高さの差が最大1である二分木のこと。AVL木がこの代表例です。均衡が保たれていると、検索・挿入・削除などの操作をO(log
+                            n)で行えます。
+                        </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="arrow text-emerald-500">▶</span> 番兵値（Sentinel Value）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            通常の値としてあり得ない特別な値を使ってエラーや特殊状態を表す手法です。この問題では
+                            -1 が番兵値で「不均衡が検知済み」を意味します。高さは常に0以上なので、-1
+                            は安全な番兵値として機能します。
+                        </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="arrow text-emerald-500">▶</span>
+                            ボトムアップ再帰（Bottom-up Recursion）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            葉ノード（末端）から根ノードに向かって結果を積み上げていく再帰の方向です。対義語はトップダウン（根から葉へ）。ボトムアップにすると、計算結果を再利用できるためO(n)が実現できます。
+                        </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="arrow text-emerald-500">▶</span> ネスト関数（Nested
+                            Function）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数の中に定義された関数のこと。外部スコープから直接呼べないため、内部実装を隠蔽できます。Pythonではネスト関数はローカルスコープで名前解決されるため、クラスメソッドより少し高速です。
+                        </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="arrow text-emerald-500">▶</span> DFS（深さ優先探索 /
+                            Depth-First Search）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木やグラフを探索する方法の一つで、できるだけ深く進んでから戻る方式です。迷路を解くとき「行き止まりになるまで進んで、戻って別の道を試す」イメージです。木の問題では再帰で自然に実装できます。
+                        </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="arrow text-emerald-500">▶</span> ベースケース（Base Case）
+                        </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 is None</code
+                            >
+                            がベースケースで、高さ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="arrow text-emerald-500">▶</span> 早期リターン（Early
+                            Return）
+                        </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">return</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="arrow text-emerald-500">▶</span> シングルトン（Singleton）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            プログラム中に1つしか存在しないオブジェクトのことです。Pythonの
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">None</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs">True</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >False</code
+                            >
+                            がこれにあたります。<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >is None</code
+                            >
+                            が
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">== None</code>
+                            より正確で速い理由は、Noneがシングルトンだからです。
+                        </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="arrow text-emerald-500">▶</span> コールスタック（Call
+                            Stack）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数呼び出しが積み重なっていく記録です。「お皿の積み重ね」のように、最後に呼んだ関数が最初に終わります（LIFO）。再帰が深くなるほどコールスタックが大きくなり、空間計算量に影響します。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center text-slate-400 text-sm py-4">
+                LeetCode 110 · Balanced Binary Tree — ボトムアップDFS解説
+            </footer>
+        </div>
+
+        <!-- ===================== REACT COMPONENT ===================== -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: 'isBalanced でエントリポイントを定義',
+                    desc: 'まず外部に公開する関数 isBalanced を定義し、その中でヘルパー関数 check_height を呼び出します。なぜヘルパーをネスト関数にするかというと、「高さを返す / -1 を返す」という内部の詳細を外に見せないためです。外部から見ると isBalanced は「True/False を返す」だけのシンプルなAPIになります。例）isBalanced(root=TreeNode(3)) を呼ぶと、内部で check_height(TreeNode(3)) が実行されます。',
+                    visual: 'entry',
+                },
+                {
+                    step: 2,
+                    title: 'ベースケース：node is None → return 0',
+                    desc: 'check_height が最初に確認するのは「今のノードが None（空）かどうか」です。なぜなら、再帰はいつか木の末端（葉の下）に到達し、そこで処理を止める必要があるからです。None のノードは「高さ0の空の木」なので 0 を返します。`is None` を使う理由：Pythonの None はシングルトン（プログラム中に1つだけ存在）なので、`is` による同一性チェックが正確かつ高速です。',
+                    visual: 'base',
+                },
+                {
+                    step: 3,
+                    title: '左サブツリーを再帰処理',
+                    desc: '現在のノードの左の子 node.left を引数に check_height を再帰呼び出しし、左サブツリーの高さを取得します。なぜ先に左を処理するかは、左右どちらから始めても正解ですが、DFSは慣習的に左から始めます。返り値が -1 なら左サブツリーで不均衡が見つかっているので、即座に -1 を上位ノードへ返します（早期リターン）。例）node=TreeNode(3) で left=TreeNode(9) のとき、check_height(9) を呼ぶ。',
+                    visual: 'left',
+                },
+                {
+                    step: 4,
+                    title: '右サブツリーを再帰処理',
+                    desc: '左サブツリーが均衡していた（left_height ≠ -1）場合のみ、右の子 node.right を引数に check_height を再帰呼び出しします。なぜ左の確認後に右を処理するかというと、左で不均衡が確定しているなら右を調べる必要が全くないからです（早期リターンで効率化）。返り値が -1 なら同様に -1 を伝播します。例）left_height=1 (≠-1) なので right=TreeNode(20) を処理 → check_height(20) を呼ぶ。',
+                    visual: 'right',
+                },
+                {
+                    step: 5,
+                    title: '均衡チェック：abs(left - right) > 1 ?',
+                    desc: '左右両サブツリーが均衡している（どちらも ≠ -1）場合、このノードでの均衡チェックを行います。abs(left_height - right_height) > 1 であれば不均衡なので -1 を返します。abs()（絶対値）を使う理由：左が深い場合も右が深い場合も1行で処理でき、かつCPythonのC実装なので高速です。例）left=1, right=2 → abs(1-2)=1 ≤ 1 → 均衡OK。left=3, right=1 → abs(3-1)=2 > 1 → 不均衡 → return -1。',
+                    visual: 'balance',
+                },
+                {
+                    step: 6,
+                    title: '高さを返す：return max(left, right) + 1',
+                    desc: '均衡チェックを通過したノードは「高さ = max(左の高さ, 右の高さ) + 1」を返します。+1 は「自分自身のノード1段分」を追加しています。max() を使う理由：左右のうち深い方が実際のサブツリーの高さになるからです。max() もCPythonのC実装で高速です。例）left=1, right=2 → max(1,2)+1 = 3 を親ノードへ返す。これが親ノードの left_height または right_height になります。',
+                    visual: 'height',
+                },
+                {
+                    step: 7,
+                    title: '最終判定：check_height(root) != -1',
+                    desc: 'すべての再帰が完了して check_height(root) の結果が返ってきます。-1 でなければ全ノードが均衡していたことを意味し True を返します。-1 であれば不均衡が検知されたので False を返します。この != -1 という単純な比較で全体の判定が完結します。例）Example1 → check_height(3) = 3 → 3 != -1 → True。Example2 → check_height(1) = -1 → -1 == -1 → False。',
+                    visual: 'final',
+                },
+            ];
+
+            const treeNodes = {
+                entry: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#10b981' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '3',
+                    label: 'isBalanced(root=3) を呼び出し中',
+                },
+                base: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: 'N', x: 30, y: 160, c: '#f59e0b' },
+                        { v: 'N', x: 130, y: 160, c: '#f59e0b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 80, y1: 110, x2: 30, y2: 145 },
+                        { x1: 80, y1: 110, x2: 130, y2: 145 },
+                    ],
+                    highlight: 'N',
+                    label: 'None → return 0（高さ0）',
+                },
+                left: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#10b981' },
+                        { v: '20', x: 240, y: 95, c: '#e2e8f0' },
+                        { v: 'N', x: 30, y: 160, c: '#64748b' },
+                        { v: 'N', x: 130, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 80, y1: 110, x2: 30, y2: 145 },
+                        { x1: 80, y1: 110, x2: 130, y2: 145 },
+                    ],
+                    highlight: '9',
+                    label: 'check_height(9) → left_height = 1',
+                },
+                right: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#0ea5e9' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '20',
+                    label: 'check_height(20) → right_height = 2',
+                },
+                balance: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#a855f7' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '3',
+                    label: 'abs(1-2)=1 ≤ 1 → 均衡OK！',
+                },
+                height: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#f59e0b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                    ],
+                    highlight: '3',
+                    label: 'return max(1,2)+1 = 3 を返す',
+                },
+                final: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#10b981' },
+                        { v: '9', x: 80, y: 95, c: '#10b981' },
+                        { v: '20', x: 240, y: 95, c: '#10b981' },
+                        { v: '15', x: 190, y: 160, c: '#10b981' },
+                        { v: '7', x: 290, y: 160, c: '#10b981' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: 'all',
+                    label: '3 != -1 → True ✅ 全ノード均衡！',
+                },
+            };
+
+            const varStates = {
+                entry: { node: '3', left_height: '未計算', right_height: '未計算', result: '—' },
+                base: { node: 'None', left_height: '—', right_height: '—', result: '0 を返す' },
+                left: { node: '3', left_height: '1', right_height: '未計算', result: '—' },
+                right: { node: '3', left_height: '1', right_height: '2', result: '—' },
+                balance: {
+                    node: '3',
+                    left_height: '1',
+                    right_height: '2',
+                    result: 'abs(1-2)=1 ≤ 1 → OK',
+                },
+                height: { node: '3', left_height: '1', right_height: '2', result: 'return 3' },
+                final: {
+                    node: 'root',
+                    left_height: '—',
+                    right_height: '—',
+                    result: '3 != -1 → True',
+                },
+            };
+
+            function TreeViz({ visual }) {
+                const data = treeNodes[visual];
+                if (!data) return null;
+                return (
+                    <div className="mt-3">
+                        <svg
+                            viewBox="0 0 340 200"
+                            style={{
+                                width: '100%',
+                                maxWidth: '340px',
+                                display: 'block',
+                                margin: '0 auto',
+                            }}
+                        >
+                            {data.edges.map((e, i) => (
+                                <line
+                                    key={i}
+                                    x1={e.x1}
+                                    y1={e.y1}
+                                    x2={e.x2}
+                                    y2={e.y2}
+                                    stroke="#cbd5e1"
+                                    strokeWidth="2"
+                                />
+                            ))}
+                            {data.nodes.map((n, i) => (
+                                <g key={i}>
+                                    <circle
+                                        cx={n.x}
+                                        cy={n.y + 15}
+                                        r="22"
+                                        fill={n.c}
+                                        stroke={n.c === '#e2e8f0' ? '#cbd5e1' : 'white'}
+                                        strokeWidth="2.5"
+                                    />
+                                    <text
+                                        x={n.x}
+                                        y={n.y + 20}
+                                        textAnchor="middle"
+                                        fontSize="13"
+                                        fontFamily="JetBrains Mono,monospace"
+                                        fill="white"
+                                        fontWeight="700"
+                                    >
+                                        {n.v}
+                                    </text>
+                                </g>
+                            ))}
+                        </svg>
+                        <p className="text-center text-xs text-slate-500 mt-2 font-mono">
+                            {data.label}
+                        </p>
+                    </div>
+                );
+            }
+
+            function VarPanel({ visual }) {
+                const v = varStates[visual] || {};
+                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>
+                        <div className="grid grid-cols-2 gap-1">
+                            <div>
+                                <span className="text-violet-500">node</span> ={' '}
+                                <span className="text-slate-700">{v.node}</span>
+                            </div>
+                            <div>
+                                <span className="text-emerald-600">left_height</span> ={' '}
+                                <span className="text-slate-700">{v.left_height}</span>
+                            </div>
+                            <div>
+                                <span className="text-sky-600">right_height</span> ={' '}
+                                <span className="text-slate-700">{v.right_height}</span>
+                            </div>
+                            <div>
+                                <span className="text-amber-600">戻り値</span> ={' '}
+                                <span className="text-slate-700">{v.result}</span>
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            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);
+                            }
+                        }, 2000);
+                    }
+                    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((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-sm rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'bg-gradient-to-br from-emerald-50 to-teal-50 border-emerald-400 shadow-md'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-300 hover:translate-x-1',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5',
+                                                    isActive
+                                                        ? 'text-emerald-800'
+                                                        : 'text-slate-700',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}
+                                            </div>
+                                            <div className="text-slate-500 text-xs">
+                                                {step.title}
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        <div className="my-auto">
+                            {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}）：
+                                    {stepsData[activeStep - 2]?.title}
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-gradient-to-br from-emerald-50 to-sky-50">
+                                <h3 className="mt-0 text-teal-800 text-base font-bold mb-1">
+                                    Step {currentStepData.step}: {currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <TreeViz visual={currentStepData.visual} />
+                            <VarPanel visual={currentStepData.visual} />
+
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-emerald-500 to-emerald-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-sky-500 to-sky-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-sky-500 to-sky-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-slate-700 transition bg-white border-2 border-slate-200 text-sm shadow hover:-translate-y-0.5"
+                                    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 />);
+
+            setTimeout(() => {
+                if (window.Prism) Prism.highlightAll();
+            }, 500);
+        </script>
+    </body>
+</html>
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/Binary_Tree_Inorder_Traversal_Rust.md b/Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/Binary_Tree_Inorder_Traversal_Rust.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/Binary_Tree_Inorder_Traversal_Rust.md
rename to Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/Binary_Tree_Inorder_Traversal_Rust.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/Binary_Tree_Inorder_Traversal_python.md b/Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/Binary_Tree_Inorder_Traversal_python.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/Binary_Tree_Inorder_Traversal_python.md
rename to Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/Binary_Tree_Inorder_Traversal_python.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/Binary_Tree_Inorder_Traversal_typescript.md b/Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/Binary_Tree_Inorder_Traversal_typescript.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/Binary_Tree_Inorder_Traversal_typescript.md
rename to Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/Binary_Tree_Inorder_Traversal_typescript.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/README.md b/Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/README.md
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/README.md
rename to Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/README.md
diff --git a/Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/README_react.html b/Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/README_react.html
similarity index 100%
rename from Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/README_react.html
rename to Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/README_react.html
diff --git a/public/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README_react.html b/public/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README_react.html
new file mode 100644
index 0000000..5d4774f
--- /dev/null
+++ b/public/Algorithm/BinarySearch/leetcode/108. Convert Sorted Array to Binary Search Tree/claude sonnet 4.6 adaptive/README_react.html	
@@ -0,0 +1,1680 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 108 - 昇順配列を高さ平衡BSTに変換</title>
+        <link
+            href="https://fonts.googleapis.com/css2?family=Noto+Sans+JP:wght@400;500;700&family=JetBrains+Mono:wght@400;500;700&family=Outfit:wght@700;800&display=swap"
+            rel="stylesheet"
+        />
+        <script src="/vendor/tailwindcss/script.js"></script>
+        <link
+            href="/vendor/prismjs/themes/prism-tomorrow.css"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.css"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/plugins/toolbar/prism-toolbar.css"
+            rel="stylesheet"
+        />
+        <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>
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .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;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            details[open] > summary .arrow {
+                transform: rotate(90deg);
+            }
+            .arrow {
+                display: inline-block;
+                transition: transform 0.2s;
+            }
+        </style>
+    </head>
+    <body class="bg-gradient-to-br from-emerald-50 via-white to-sky-50 min-h-screen p-4 md:p-8">
+        <div class="max-w-5xl mx-auto">
+            <!-- ===== HEADER ===== -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.15)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full"
+                        >LeetCode 108</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"
+                        >分割統治法</span
+                    >
+                </div>
+                <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Convert Sorted Array to Binary Search Tree
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    再帰 + インデックス渡し による O(n) / O(log n) 実装
+                </p>
+                <div
+                    class="mt-4 text-base text-teal-800 bg-white/70 rounded-xl px-4 py-3 inline-block"
+                >
+                    💡
+                    一言で言うと：「昇順ソート済みリストを、左右の高さが均等な二分探索木（BST）に変換する問題」
+                </div>
+                <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="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 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-700 text-sm mt-2 leading-7">
+                        昇順ソート済みリストを受け取り、<strong
+                            >左右の部分木の高さの差が常に 1 以下</strong
+                        >（＝高さ平衡）になる二分探索木（BST）のルートノードを返す問題です。「真ん中の要素を根にする」という発想が核心で、これを再帰的に繰り返すことで自然に平衡が実現されます。
+                    </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-1 list-disc list-inside leading-7">
+                        <li>
+                            端から順に
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >insert()</code
+                            >
+                            を繰り返すと、毎回右の子に追加されて「竹のような一本道の木」になり、高さが
+                            O(n) になる
+                        </li>
+                        <li>
+                            高さ平衡の条件を満たすには、<strong>どの値を根に選ぶか</strong>を戦略的に決める必要がある
+                        </li>
+                        <li>
+                            スライス
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >nums[:mid]</code
+                            >
+                            を使うと再帰ごとにリストコピーが発生し、空間計算量が O(n log n)
+                            に悪化する
+                        </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(log n)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono break-all leading-tight">
+                            分割統治法
+                        </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-sm font-mono">再帰</div>
+                        <div class="text-xs mt-1">実装方式</div>
+                    </div>
+                </div>
+
+                <div class="grid md:grid-cols-2 gap-4 mb-5">
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <p class="text-slate-600 font-semibold text-sm mb-2">入出力例 1</p>
+                        <p class="font-mono text-xs text-slate-500 mb-1">
+                            入力: nums = [-10, -3, 0, 5, 9]
+                        </p>
+                        <p class="font-mono text-xs text-slate-500 mb-2">
+                            出力: [0, -3, 9, -10, null, 5]
+                        </p>
+                        <p class="text-slate-600 text-xs leading-6">
+                            → 配列の中央
+                            <code class="bg-slate-100 px-1 rounded font-mono">0</code
+                            >（インデックス2）を根にすることで、左右に各2要素ずつ分配でき、高さ平衡が実現されます。
+                        </p>
+                    </div>
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <p class="text-slate-600 font-semibold text-sm mb-2">入出力例 2</p>
+                        <p class="font-mono text-xs text-slate-500 mb-1">入力: nums = [1, 3]</p>
+                        <p class="font-mono text-xs text-slate-500 mb-2">
+                            出力: [3, 1] または [1, null, 3]
+                        </p>
+                        <p class="text-slate-600 text-xs leading-6">
+                            → 2要素の場合、中央インデックス
+                            <code class="bg-slate-100 px-1 rounded font-mono"
+                                >mid = (0+1)//2 = 0</code
+                            >
+                            なので
+                            <code class="bg-slate-100 px-1 rounded font-mono">1</code>
+                            が根になります。どちらの形も正解として受理されます。
+                        </p>
+                    </div>
+                </div>
+
+                <div class="rounded-xl bg-slate-50 border border-slate-200 p-4">
+                    <p class="text-slate-600 font-semibold text-sm mb-2">📌 制約</p>
+                    <ul class="text-slate-500 text-sm space-y-1 list-disc list-inside font-mono">
+                        <li>1 &lt;= nums.length &lt;= 10<sup>4</sup></li>
+                        <li>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></li>
+                        <li>nums は厳密な昇順（重複なし）</li>
+                    </ul>
+                </div>
+            </section>
+
+            <!-- ===== STEPS (React mount point) ===== -->
+            <div id="steps-react" class="mb-8"></div>
+
+            <!-- ===== CODE ===== -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 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 leading-7">
+                        <li>
+                            ネスト関数
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >build(lo, hi)</code
+                            >
+                            を定義して nums を引数なしで参照できるようにする
+                        </li>
+                        <li>
+                            ベースケース：<code
+                                class="bg-white px-1 rounded font-mono text-xs border"
+                                >lo &gt; hi</code
+                            >
+                            なら
+                            <code class="bg-white px-1 rounded font-mono text-xs border">None</code>
+                            を返して再帰終了
+                        </li>
+                        <li>
+                            中央インデックス
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >mid = (lo + hi) // 2</code
+                            >
+                            を計算して根ノードを作成
+                        </li>
+                        <li>左半分・右半分を再帰的に構築して左右の子に接続し、ノードを返す</li>
+                    </ol>
+                </div>
+
+                <pre class="line-numbers"><code class="language-python">from typing import Optional
+
+# 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 sortedArrayToBST(self, nums: list[int]) -&gt; Optional["TreeNode"]:
+        def build(lo: int, hi: int) -&gt; Optional["TreeNode"]:
+            # ベースケース：lo &gt; hi のとき空区間 → None を返して再帰終了
+            # この条件がないと無限ループになり RuntimeError が発生する
+            if lo &gt; hi:
+                return None
+
+            # 中央インデックスを床除算（//）で計算する
+            # スライス nums[lo:hi] を使わないのは、新しいリストのコピーが発生して
+            # 空間計算量が O(n log n) に悪化するため。インデックスなら O(1)。
+            mid = (lo + hi) // 2
+
+            # 中央の値でノードを作成（このノードが現在の区間の「根」になる）
+            # nums[mid] を根にすることで左右の要素数の差が常に 1 以下に保たれる
+            node = TreeNode(nums[mid])
+
+            # 左半分 [lo, mid-1] で左部分木を再帰構築
+            # mid 自体は現在のノードとして使用済みのため含まない（mid-1 まで）
+            node.left = build(lo, mid - 1)
+
+            # 右半分 [mid+1, hi] で右部分木を再帰構築
+            node.right = build(mid + 1, hi)
+
+            # 左右の子ノードが接続された完成ノードを返す
+            return node
+
+        # 全体の範囲（インデックス 0 〜 最後のインデックス）で再帰を開始
+        return build(0, len(nums) - 1)
+</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">
+                        ▶ 入力例 nums = [-10, -3, 0, 5, 9] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-6 overflow-x-auto whitespace-pre"
+                    >
+build(0, 4):
+  mid = 2 → node = TreeNode(0)    ← 根ノード確定！
+  node.left  = build(0, 1)
+    mid = 0 → node = TreeNode(-10)
+    node.left  = build(0, -1) → lo(0) &gt; hi(-1) → None
+    node.right = build(1, 1)
+      mid = 1 → node = TreeNode(-3) ← 葉ノード
+      return TreeNode(-3)
+    return TreeNode(-10, left=None, right=TreeNode(-3))
+  node.right = build(3, 4)
+    mid = 3 → node = TreeNode(5)
+    node.left  = build(3, 2) → lo(3) &gt; hi(2)  → None
+    node.right = build(4, 4)
+      mid = 4 → node = TreeNode(9)  ← 葉ノード
+      return TreeNode(9)
+    return TreeNode(5, left=None, right=TreeNode(9))
+
+完成した BST:
+         0          ← 根（配列の中央）
+        / \
+      -10    5
+         \    \
+         -3    9
+
+高さ: 左=2, 右=2  差=0  ✅ 高さ平衡！</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ===== DIAGRAM ===== -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 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="28" height="18">
+                                <ellipse
+                                    cx="14"
+                                    cy="9"
+                                    rx="13"
+                                    ry="8"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <rect
+                                    x="1"
+                                    y="3"
+                                    width="26"
+                                    height="12"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <polygon
+                                    points="14,1 27,9 14,17 1,9"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <rect
+                                    x="1"
+                                    y="3"
+                                    width="26"
+                                    height="12"
+                                    rx="3"
+                                    fill="#fee2e2"
+                                    stroke="#dc2626"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>赤ボックス＝ 終端処理</span>
+                        </div>
+                    </div>
+                    <div class="flex gap-6 mt-3 text-xs text-slate-600">
+                        <span
+                            ><span
+                                class="inline-block w-6 h-0.5 bg-emerald-500 align-middle mr-1"
+                            ></span
+                            >緑矢印＝「いいえ」（処理続行）</span
+                        >
+                        <span
+                            ><span
+                                class="inline-block w-6 h-0.5 bg-red-400 align-middle mr-1"
+                            ></span
+                            >赤矢印＝「はい」（早期終了）</span
+                        >
+                        <span
+                            ><span
+                                class="inline-block w-6 h-0.5 bg-slate-400 align-middle mr-1"
+                            ></span
+                            >グレー矢印＝通常フロー</span
+                        >
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto">
+                    <svg
+                        viewBox="0 0 560 680"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Convert Sorted Array to BST flowchart"
+                    >
+                        <defs>
+                            <marker
+                                id="fc-arrow"
+                                marker-width="10"
+                                marker-height="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                marker-units="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#64748b" />
+                            </marker>
+                            <marker
+                                id="fc-arrowGreen"
+                                marker-width="10"
+                                marker-height="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                marker-units="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#059669" />
+                            </marker>
+                            <marker
+                                id="fc-arrowRed"
+                                marker-width="10"
+                                marker-height="10"
+                                refX="9"
+                                refY="3"
+                                orient="auto"
+                                marker-units="strokeWidth"
+                            >
+                                <path d="M0,0 L0,6 L9,3 z" fill="#dc2626" />
+                            </marker>
+                        </defs>
+
+                        <!-- 1. Start -->
+                        <ellipse
+                            cx="280"
+                            cy="46"
+                            rx="180"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="46"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="14"
+                            font-weight="700"
+                            fill="#065f46"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            開始: build(lo, hi)
+                        </text>
+
+                        <!-- Arrow 1→2 -->
+                        <line
+                            x1="280"
+                            y1="74"
+                            x2="280"
+                            y2="107"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 2. Diamond: lo > hi? -->
+                        <polygon
+                            points="280,107 400,150 280,193 160,150"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="146"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="700"
+                            fill="#92400e"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            lo &gt; hi ?
+                        </text>
+                        <text
+                            x="280"
+                            y="164"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#b45309"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            （空区間の確認）
+                        </text>
+
+                        <!-- "Yes" label + arrow to Return None -->
+                        <text
+                            x="418"
+                            y="136"
+                            text-anchor="start"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            はい
+                        </text>
+                        <line
+                            x1="400"
+                            y1="150"
+                            x2="466"
+                            y2="150"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- Return None box -->
+                        <rect
+                            x="466"
+                            y="128"
+                            width="84"
+                            height="44"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="508"
+                            y="147"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="700"
+                            fill="#991b1b"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            None
+                        </text>
+                        <text
+                            x="508"
+                            y="163"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            を返す
+                        </text>
+
+                        <!-- "No" label + arrow down -->
+                        <text
+                            x="247"
+                            y="210"
+                            text-anchor="end"
+                            font-size="11"
+                            fill="#059669"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            いいえ
+                        </text>
+                        <line
+                            x1="280"
+                            y1="193"
+                            x2="280"
+                            y2="233"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+
+                        <!-- 3. Box: mid計算 + node作成 -->
+                        <rect
+                            x="60"
+                            y="233"
+                            width="440"
+                            height="68"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="256"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            fill="#1e40af"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            mid = (lo + hi) // 2
+                        </text>
+                        <text
+                            x="280"
+                            y="280"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            fill="#1e40af"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            node = TreeNode(nums[mid])
+                        </text>
+
+                        <!-- Arrow 3→4 -->
+                        <line
+                            x1="280"
+                            y1="301"
+                            x2="280"
+                            y2="335"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 4. Box: 左部分木 -->
+                        <rect
+                            x="60"
+                            y="335"
+                            width="440"
+                            height="52"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="361"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            fill="#1e40af"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            node.left = build(lo, mid - 1)
+                        </text>
+
+                        <!-- Arrow 4→5 -->
+                        <line
+                            x1="280"
+                            y1="387"
+                            x2="280"
+                            y2="421"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 5. Box: 右部分木 -->
+                        <rect
+                            x="60"
+                            y="421"
+                            width="440"
+                            height="52"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="447"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            fill="#1e40af"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            node.right = build(mid + 1, hi)
+                        </text>
+
+                        <!-- Arrow 5→6 -->
+                        <line
+                            x1="280"
+                            y1="473"
+                            x2="280"
+                            y2="507"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 6. Box: return node -->
+                        <rect
+                            x="60"
+                            y="507"
+                            width="440"
+                            height="46"
+                            rx="8"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="530"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="700"
+                            fill="#065f46"
+                            font-family="'JetBrains Mono', monospace"
+                        >
+                            return node
+                        </text>
+
+                        <!-- Arrow 6→7 -->
+                        <line
+                            x1="280"
+                            y1="553"
+                            x2="280"
+                            y2="587"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 7. End -->
+                        <ellipse
+                            cx="280"
+                            cy="613"
+                            rx="180"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                        />
+                        <text
+                            x="280"
+                            y="613"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="14"
+                            font-weight="700"
+                            fill="#065f46"
+                            font-family="'Noto Sans JP', sans-serif"
+                        >
+                            終了（サブツリーのルートを返した）
+                        </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">
+                        🔎 入力例 nums = [-10, -3, 0, 5, 9] でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-1 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >build(0, 4)</code
+                            >
+                            が呼ばれる
+                        </li>
+                        <li>「lo &gt; hi?」→ 0 ≤ 4 なので「いいえ」の経路へ</li>
+                        <li>
+                            「mid を計算」→
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >mid=2, node=TreeNode(0)</code
+                            >
+                        </li>
+                        <li>
+                            「左部分木」→
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >build(0,1)</code
+                            >
+                            で同じフローを再帰実行し
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >TreeNode(-10, right=TreeNode(-3))</code
+                            >
+                            を構築
+                        </li>
+                        <li>
+                            「右部分木」→
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >build(3,4)</code
+                            >
+                            で
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >TreeNode(5, right=TreeNode(9))</code
+                            >
+                            を構築
+                        </li>
+                        <li>
+                            「return node」→ 根
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >TreeNode(0)</code
+                            >
+                            を返して終了
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ===== COMPLEXITY ===== -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 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(log n)</div>
+                            <div class="leading-5">
+                                入力の対数に比例<br /><span class="text-sky-600">例：二分探索</span>
+                            </div>
+                        </div>
+                        <div class="text-center p-3 rounded-lg bg-teal-100 text-teal-800">
+                            <div class="font-bold font-mono text-base mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-teal-600"
+                                    >例：リストを1回走査</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-5">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-gradient-to-r from-emerald-50 to-sky-50">
+                                <th
+                                    class="text-left p-3 border border-slate-200 text-slate-700 font-semibold"
+                                >
+                                    計算量の種類
+                                </th>
+                                <th
+                                    class="text-center p-3 border border-slate-200 text-slate-700 font-semibold"
+                                >
+                                    本実装（インデックス版）
+                                </th>
+                                <th
+                                    class="text-center p-3 border border-slate-200 text-slate-700 font-semibold"
+                                >
+                                    スライス版（比較）
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr>
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    時間計算量
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span
+                                        class="font-mono font-bold text-emerald-700 bg-emerald-50 px-2 py-0.5 rounded"
+                                        >O(n)</span
+                                    >
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span
+                                        class="font-mono font-bold text-amber-700 bg-amber-50 px-2 py-0.5 rounded"
+                                        >O(n log n)</span
+                                    >
+                                </td>
+                            </tr>
+                            <tr class="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">
+                                    <span
+                                        class="font-mono font-bold text-emerald-700 bg-emerald-50 px-2 py-0.5 rounded"
+                                        >O(log n)</span
+                                    >
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span
+                                        class="font-mono font-bold text-amber-700 bg-amber-50 px-2 py-0.5 rounded"
+                                        >O(n log n)</span
+                                    >
+                                </td>
+                            </tr>
+                            <tr>
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    スライスコピー
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center text-emerald-700 font-semibold"
+                                >
+                                    なし ✅
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center text-red-500 font-semibold"
+                                >
+                                    あり（毎回コピー）❌
+                                </td>
+                            </tr>
+                            <tr class="bg-slate-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    n=10,000 時の再帰深度
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span class="font-mono text-slate-700">≈ 14 段</span>
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center">
+                                    <span class="font-mono text-slate-700">≈ 14 段</span>
+                                </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>
+                    <div class="text-slate-700 text-sm leading-7 space-y-2">
+                        <p>
+                            <strong>時間計算量 O(n)：</strong
+                            ><code class="bg-white px-1 rounded font-mono text-xs border"
+                                >nums</code
+                            >
+                            の各要素はちょうど1回だけ
+                            <code class="bg-white px-1 rounded font-mono text-xs border"
+                                >TreeNode(nums[mid])</code
+                            >
+                            として処理されます。n 個の要素なら n
+                            回のノード生成が起こり、それ以外の処理（インデックス計算・代入）も O(1)
+                            なので全体 O(n) です。
+                        </p>
+                        <p>
+                            <strong>空間計算量 O(log n)：</strong
+                            >スライスコピーを使わないため、追加メモリは<strong>再帰スタック</strong>（＝関数の呼び出し履歴を記録するメモリ）のみです。高さ平衡な木の高さは
+                            log₂(n) 程度なので、n=10,000 のとき再帰深度は最大 ⌈log₂(10000)⌉ = 14
+                            段程度。Python のデフォルト再帰上限（1000回）に対して余裕があります。
+                        </p>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ===== GLOSSARY ===== -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit 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="arrow text-emerald-500 text-xs">▶</span> O記法（Big-O
+                            記法）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            入力サイズ n
+                            が大きくなるにつれて処理時間・メモリがどう増えるかを表す記法。O(n) は「n
+                            に比例して増える」、O(log n) は「n
+                            が2倍になっても処理は1ステップ増えるだけ」を意味します。常数倍の差は無視して、最も支配的な項だけで表します。
+                        </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="arrow text-emerald-500 text-xs">▶</span> 二分探索木（BST）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Binary Search Tree
+                            の略。各ノードについて「左の子はすべて自分より小さく、右の子はすべて自分より大きい」という規則を持つ木構造です。この規則のおかげで、平衡が保たれていれば検索・挿入を
+                            O(log n) で行えます。
+                        </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="arrow 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
+                            以下であること。平衡が崩れた BST は最悪
+                            O(n)（一本道の竹のような形）になりますが、高さ平衡が保たれていれば O(log
+                            n) を維持できます。
+                        </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="arrow text-emerald-500 text-xs">▶</span> 再帰（recursion）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数が自分自身を呼び出すこと。「同じ構造の小さな問題に分割できる」場面で有効です。マトリョーシカ人形のように、外側のフィギュアを開くと同じ形の小さいフィギュアが入っているイメージです。必ず「終了条件（ベースケース）」が必要で、これがないと無限ループになります。
+                        </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="arrow 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"
+                                >lo &gt; hi</code
+                            >（有効な要素がない空区間）がベースケースで、<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >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="arrow 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"
+                        >
+                            大きな問題を「分割（Divide）」→
+                            小さな問題を「統治（Conquer）＝再帰で解く」→
+                            結果を「結合（Combine）」する手法。本問では「配列を左右に分割 →
+                            各部分で再帰 → 左右の子ノードとして接続」がこのパターンに当たります。
+                        </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="arrow 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"
+                        >
+                            小数点以下を切り捨てる割り算。Python では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">//</code>
+                            演算子で表します。例：<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >(0+4)//2 = 2</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >(0+3)//2 = 1</code
+                            >。<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >int((0+4)/2)</code
+                            >
+                            と同じ結果ですが、CPython では
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">//</code> は
+                            C言語レベルの整数演算に最適化されており、型変換コストがありません。
+                        </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="arrow 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"
+                        >
+                            関数が自分を呼び出すたびに「どこに戻るか」の情報が積み上がるメモリ領域。本問では木の高さ（log
+                            n 程度）分だけ積み重なります。Python のデフォルト上限は 1000
+                            段で、n=10,000 のとき本問の深さは最大 14 段なので余裕があります。
+                        </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="arrow 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"
+                                >nums[lo:hi]</code
+                            >
+                            のようにリストの一部を取り出す操作。Python
+                            では新しいリストオブジェクトがヒープ（動的メモリ領域）に生成されます。再帰のたびに呼ぶと
+                            O(n log n) のメモリが使われるため、本実装ではインデックス
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">lo</code
+                            >/<code class="bg-slate-100 px-1 rounded font-mono text-xs">hi</code>
+                            を渡すことでこのコストを O(1) に抑えています。
+                        </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="arrow text-emerald-500 text-xs">▶</span> 葉ノード（leaf
+                            node）
+                        </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">None</code>
+                            のノード。木の末端を形成します。本問では1要素の区間（lo=hi）から作られるノードが葉ノードになります（左右の子がともに空区間として
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">None</code>
+                            を返す）。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center py-6 text-slate-400 text-sm">
+                LeetCode 108 解説ページ ｜ React 18 + Tailwind CSS + Prism.js
+            </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 Steps Component -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const EX_NUMS = [-10, -3, 0, 5, 9];
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '全体区間を設定して再帰を開始する',
+                    desc: 'build(lo=0, hi=4) を呼び出します。lo は配列の先頭インデックス、hi は末尾インデックスです。この2つのインデックスだけで処理対象の範囲を表し、配列のコピーは一切作りません。なぜインデックスを使うかというと、nums[lo:hi] のようなスライスは新しいリストを生成してしまいメモリが O(n log n) 増えるからです。例として nums=[-10,-3,0,5,9] では lo=0, hi=4 の全5要素が最初の処理対象です。',
+                    lo: 0,
+                    hi: 4,
+                    mid: null,
+                    treeHighlight: [],
+                },
+                {
+                    step: 2,
+                    title: 'ベースケースを確認する（lo > hi?）',
+                    desc: 'lo=0 と hi=4 を比べます。0 ≤ 4 なので条件は「偽（False）」→ ノードを作成する処理へ進みます。なぜこの確認が必要かというと、再帰が深くなると lo > hi になる空区間が現れ、そこで None を返して再帰を終了させる必要があるからです。例として build(0,-1) が呼ばれたとき lo(0) > hi(-1) が真になり None を返します。この空区間チェックがないと無限ループになります。',
+                    lo: 0,
+                    hi: 4,
+                    mid: null,
+                    treeHighlight: [],
+                },
+                {
+                    step: 3,
+                    title: '中央インデックスを計算する',
+                    desc: 'mid = (lo + hi) // 2 = (0 + 4) // 2 = 2 を計算します。// は床除算（小数点以下切り捨て）です。なぜ中央を選ぶかというと、配列の真ん中の要素を根にすると左側と右側の要素数の差が最大1になり、自然と高さ平衡が実現されるからです。例として [0,4] の中央は 2、nums[2] = 0 がこの区間の根の値になります。辞書の「真ん中のページ」から引き始める二分探索と同じ発想です。',
+                    lo: 0,
+                    hi: 4,
+                    mid: 2,
+                    treeHighlight: [0],
+                },
+                {
+                    step: 4,
+                    title: '根ノードを作成する',
+                    desc: 'node = TreeNode(nums[2]) = TreeNode(0) を作成します。これが現在の区間全体の根ノードです。なぜ中央の値 0 が根になるかというと、0 より小さい値（-10, -3）を左部分木に、0 より大きい値（5, 9）を右部分木に自然に分配できるからです。BST の規則（左は小さく・右は大きく）を自動的に満たしながら、左右の要素数を均等にできます。',
+                    lo: 0,
+                    hi: 4,
+                    mid: 2,
+                    treeHighlight: [0],
+                },
+                {
+                    step: 5,
+                    title: '左部分木を再帰構築する',
+                    desc: 'node.left = build(lo=0, hi=1) を呼び出します。区間 [0, 1]（= nums[-10, -3]）で同じ処理を再帰的に繰り返します。なぜ [lo, mid-1] = [0, 1] かというと、mid=2 より左のインデックス（0〜1）の要素が BST の左部分木の値になるべきだからです（すべて 0 より小さい）。この再帰呼び出しでは mid=0、nums[0]=-10 が根になり、右の子に -3 がつく構造が作られます。',
+                    lo: 0,
+                    hi: 1,
+                    mid: 0,
+                    treeHighlight: [-10],
+                },
+                {
+                    step: 6,
+                    title: '右部分木を再帰構築する',
+                    desc: 'node.right = build(lo=3, hi=4) を呼び出します。区間 [3, 4]（= nums[5, 9]）で同じ処理を繰り返します。なぜ [mid+1, hi] = [3, 4] かというと、mid=2 より右のインデックス（3〜4）の要素が BST の右部分木の値になるべきだからです（すべて 0 より大きい）。この再帰では mid=3、nums[3]=5 が根になり、右の子に 9 がつきます。最終的に根=0、左=-10(-3付き)、右=5(9付き) の高さ平衡 BST が完成します！',
+                    lo: 3,
+                    hi: 4,
+                    mid: 3,
+                    treeHighlight: [5],
+                },
+            ];
+
+            function ArrayViz({ nums, lo, hi, mid }) {
+                const bw = 50,
+                    bh = 50,
+                    gap = 7;
+                const svgW = nums.length * (bw + gap) - gap + 20;
+                return (
+                    <svg
+                        viewBox={`0 0 ${svgW} 82`}
+                        style={{
+                            width: '100%',
+                            maxWidth: svgW + 'px',
+                            display: 'block',
+                            margin: '0 auto',
+                        }}
+                    >
+                        {nums.map((val, i) => {
+                            const x = 10 + i * (bw + gap);
+                            const inRange = lo !== null && hi !== null ? i >= lo && i <= hi : true;
+                            const isMid = mid !== null && i === mid;
+                            const fill = isMid ? '#10b981' : inRange ? '#bfdbfe' : '#f1f5f9';
+                            const textFill = isMid ? '#fff' : inRange ? '#1e40af' : '#94a3b8';
+                            const stroke = isMid ? '#059669' : inRange ? '#3b82f6' : '#e2e8f0';
+                            const sw = isMid ? 2.5 : 1;
+                            return (
+                                <g key={i}>
+                                    <text
+                                        x={x + bw / 2}
+                                        y={13}
+                                        textAnchor="middle"
+                                        fontSize={10}
+                                        fill="#94a3b8"
+                                        fontFamily="monospace"
+                                    >
+                                        {i}
+                                    </text>
+                                    <rect
+                                        x={x}
+                                        y={18}
+                                        width={bw}
+                                        height={bh}
+                                        rx={7}
+                                        fill={fill}
+                                        stroke={stroke}
+                                        strokeWidth={sw}
+                                    />
+                                    <text
+                                        x={x + bw / 2}
+                                        y={43}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize={14}
+                                        fontWeight={isMid ? '700' : '500'}
+                                        fill={textFill}
+                                        fontFamily="'JetBrains Mono', monospace"
+                                    >
+                                        {val}
+                                    </text>
+                                    {isMid && (
+                                        <text
+                                            x={x + bw / 2}
+                                            y={77}
+                                            textAnchor="middle"
+                                            fontSize={9}
+                                            fill="#059669"
+                                            fontFamily="sans-serif"
+                                        >
+                                            mid
+                                        </text>
+                                    )}
+                                    {!isMid && inRange && lo !== null && (
+                                        <text
+                                            x={x + bw / 2}
+                                            y={77}
+                                            textAnchor="middle"
+                                            fontSize={9}
+                                            fill="#3b82f6"
+                                            fontFamily="sans-serif"
+                                        >
+                                            {i === lo ? 'lo' : i === hi ? 'hi' : ''}
+                                        </text>
+                                    )}
+                                </g>
+                            );
+                        })}
+                    </svg>
+                );
+            }
+
+            function MiniTree({ highlight }) {
+                const nodes = [
+                    { val: 0, cx: 150, cy: 36, parent: null },
+                    { val: -10, cx: 72, cy: 96, parent: 0 },
+                    { val: -3, cx: 108, cy: 156, parent: -10 },
+                    { val: 5, cx: 228, cy: 96, parent: 0 },
+                    { val: 9, cx: 264, cy: 156, parent: 5 },
+                ];
+                const edges = [
+                    { x1: 150, y1: 57, x2: 72, y2: 75 },
+                    { x1: 150, y1: 57, x2: 228, y2: 75 },
+                    { x1: 72, y1: 117, x2: 108, y2: 135 },
+                    { x1: 228, y1: 117, x2: 264, y2: 135 },
+                ];
+                return (
+                    <svg
+                        viewBox="0 0 300 190"
+                        style={{
+                            width: '100%',
+                            maxWidth: '300px',
+                            display: 'block',
+                            margin: '0 auto',
+                        }}
+                    >
+                        {edges.map((e, i) => (
+                            <line
+                                key={i}
+                                x1={e.x1}
+                                y1={e.y1}
+                                x2={e.x2}
+                                y2={e.y2}
+                                stroke="#cbd5e1"
+                                strokeWidth={1.5}
+                            />
+                        ))}
+                        {nodes.map((n) => {
+                            const hl = highlight && highlight.includes(n.val);
+                            const fill = hl ? '#10b981' : '#e0f2fe';
+                            const tfill = hl ? '#fff' : '#1e40af';
+                            const stroke = hl ? '#059669' : '#93c5fd';
+                            return (
+                                <g key={n.val}>
+                                    <circle
+                                        cx={n.cx}
+                                        cy={n.cy}
+                                        r={21}
+                                        fill={fill}
+                                        stroke={stroke}
+                                        strokeWidth={hl ? 2.5 : 1.5}
+                                    />
+                                    <text
+                                        x={n.cx}
+                                        y={n.cy}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize={13}
+                                        fontWeight="500"
+                                        fill={tfill}
+                                        fontFamily="'JetBrains Mono', monospace"
+                                    >
+                                        {n.val}
+                                    </text>
+                                </g>
+                            );
+                        })}
+                    </svg>
+                );
+            }
+
+            function StepVisualization({ stepData }) {
+                const { lo, hi, mid, treeHighlight } = stepData;
+                return (
+                    <div className="mt-3 space-y-4">
+                        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200">
+                            <p className="text-xs text-slate-500 font-semibold mb-2 font-sans">
+                                配列の現在の処理範囲
+                            </p>
+                            <ArrayViz nums={EX_NUMS} lo={lo} hi={hi} mid={mid} />
+                        </div>
+                        <div className="grid grid-cols-2 gap-3">
+                            <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 font-mono text-xs">
+                                <div className="text-slate-500 mb-2 font-sans font-semibold">
+                                    🔍 現在の変数の状態
+                                </div>
+                                <div className="text-sky-700">lo = {lo !== null ? lo : '0'}</div>
+                                <div className="text-sky-700">hi = {hi !== null ? hi : '4'}</div>
+                                <div
+                                    className={
+                                        mid !== null
+                                            ? 'text-emerald-700 font-bold'
+                                            : 'text-slate-400'
+                                    }
+                                >
+                                    mid = {mid !== null ? mid : '（未計算）'}
+                                </div>
+                                <div
+                                    className={mid !== null ? 'text-emerald-700' : 'text-slate-400'}
+                                >
+                                    nums[mid] = {mid !== null ? EX_NUMS[mid] : '—'}
+                                </div>
+                            </div>
+                            <div className="p-3 rounded-xl bg-slate-50 border border-slate-200">
+                                <p className="text-xs text-slate-500 font-semibold mb-2 font-sans">
+                                    構築中の BST
+                                </p>
+                                <MiniTree highlight={treeHighlight} />
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            function StepsSection() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 2200);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                const handlePlay = () => {
+                    if (activeStep === stepsData.length) setActiveStep(1);
+                    setIsPlaying(true);
+                };
+
+                const current = stepsData.find((s) => s.step === activeStep);
+
+                return (
+                    <section id="steps" className="bg-white rounded-2xl p-8 shadow">
+                        <h2 className="outfit text-[1.9rem] font-bold text-cyan-700 mb-5 pb-2 border-b-[3px] border-emerald-200">
+                            ステップバイステップ解説
+                        </h2>
+                        <p className="text-slate-500 text-sm mb-5">
+                            入力例{' '}
+                            <code className="bg-slate-100 px-1 rounded font-mono text-xs">
+                                nums = [-10, -3, 0, 5, 9]
+                            </code>{' '}
+                            を使って、アルゴリズムの各処理を順番に確認できます。
+                        </p>
+
+                        <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-6 mt-2">
+                            <div>
+                                <h3 className="mt-0 mb-3 text-teal-800 text-base 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-sm 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-0.5',
+                                                ].join(' ')}
+                                                onClick={() => {
+                                                    setActiveStep(s.step);
+                                                    setIsPlaying(false);
+                                                }}
+                                            >
+                                                <div
+                                                    className={[
+                                                        'font-semibold text-xs mb-1',
+                                                        isActive
+                                                            ? 'text-emerald-800'
+                                                            : 'text-teal-700',
+                                                    ].join(' ')}
+                                                >
+                                                    Step {s.step}
+                                                </div>
+                                                <div
+                                                    className={[
+                                                        'text-xs',
+                                                        isActive
+                                                            ? 'text-emerald-900 font-medium'
+                                                            : 'text-slate-600',
+                                                    ].join(' ')}
+                                                >
+                                                    {s.title}
+                                                </div>
+                                            </button>
+                                        );
+                                    })}
+                                </div>
+                            </div>
+
+                            <div>
+                                {activeStep > 1 && (
+                                    <div className="mb-3 px-3 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                        ← Step {activeStep - 1}「{stepsData[activeStep - 2].title}
+                                        」の続き
+                                    </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 {current.step}: {current.title}
+                                    </h3>
+                                    <p className="text-slate-600 leading-7 text-sm mt-2">
+                                        {current.desc}
+                                    </p>
+                                </div>
+
+                                <StepVisualization stepData={current} />
+
+                                <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                    <button
+                                        type="button"
+                                        className="px-4 py-2 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={handlePlay}
+                                        disabled={isPlaying}
+                                    >
+                                        ▶ Play
+                                    </button>
+                                    <button
+                                        type="button"
+                                        className="px-4 py-2 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-4 py-2 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-4 py-2 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>
+                    </section>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('steps-react')).render(<StepsSection />);
+        </script>
+
+        <script>
+            document.addEventListener('DOMContentLoaded', function () {
+                Prism.highlightAll();
+            });
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/BinaryTree/claude sonnet 4.6 adaptive/110. Balanced Binary Tree/README_react.html b/public/Algorithm/BinaryTree/claude sonnet 4.6 adaptive/110. Balanced Binary Tree/README_react.html
new file mode 100644
index 0000000..0253a50
--- /dev/null
+++ b/public/Algorithm/BinaryTree/claude sonnet 4.6 adaptive/110. Balanced Binary Tree/README_react.html	
@@ -0,0 +1,1958 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <title>LeetCode 110 · Balanced Binary Tree</title>
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;500;700&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <script src="/vendor/react/react.development.js" crossorigin></script>
+        <script
+            src="/vendor/react-dom/react-dom.development.js"
+            crossorigin
+        ></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"
+        />
+        <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>
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            .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;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            details[open] > summary .arrow {
+                transform: rotate(90deg);
+            }
+            .arrow {
+                display: inline-block;
+                transition: transform 0.2s;
+            }
+        </style>
+    </head>
+    <body class="bg-gradient-to-br from-emerald-50 via-sky-50 to-slate-100 min-h-screen py-8 px-4">
+        <div class="max-w-5xl mx-auto">
+            <!-- ===================== HEADER ===================== -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-lg"
+                style="background: linear-gradient(135deg, #d1fae5, #bfdbfe)"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >LeetCode 110</span
+                    >
+                    <span
+                        class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Easy</span
+                    >
+                    <span
+                        class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Tree · DFS</span
+                    >
+                </div>
+                <h1 class="outfit text-4xl font-extrabold text-teal-900 mb-1">
+                    Balanced Binary Tree
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    ボトムアップDFS（番兵値-1）による O(n) 実装
+                </p>
+                <div
+                    class="mt-4 inline-block bg-white/70 rounded-xl px-5 py-3 text-teal-800 font-semibold text-base"
+                >
+                    💡
+                    一言で言うと：「木のすべてのノードで、左右の枝の深さの差が1以内かどうかを判定する問題」
+                </div>
+                <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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ===================== OVERVIEW ===================== -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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">
+                        💡
+                        この問題を一言で言うと：「木のすべてのノードで、左右の枝の深さの差が1以内かどうかを判定する問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2 leading-7">
+                        高さ均衡二分木（height-balanced binary
+                        tree）とは、全ノードで左右の部分木の高さの差が最大1であるような二分木です。
+                        空の木（root = null）も高さ均衡として扱います。
+                    </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 leading-7">
+                        <li>
+                            「高さ計算」と「均衡チェック」を別々に行うと、同じノードを何度も訪問するためO(n²)になってしまいます（素朴なトップダウン再帰の罠）。
+                        </li>
+                        <li>
+                            不均衡が見つかった瞬間に結果を上位ノードへ伝える仕組みがないと、無駄な計算が増えてしまいます。
+                        </li>
+                    </ul>
+                </div>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-7">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-base 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-base font-mono">O(h)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            Bottom-up DFS
+                        </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">
+                            番兵値 -1
+                        </div>
+                        <div class="text-xs mt-1">エラー伝播</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 1 — true
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+    3
+   / \
+  9  20
+     / \
+    15   7</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            全ノードで左右の高さの差 ≤ 1 →
+                            <span class="text-emerald-600 font-bold">true</span>
+                        </p>
+                    </div>
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 2 — false
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+      1
+    /   \
+   2     2
+  / \
+ 3   3
+/ \
+4   4</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            ルートの左右の高さ差 = 2 →
+                            <span class="text-red-500 font-bold">false</span>
+                        </p>
+                    </div>
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 3 — true
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+（空の木）
+root = null</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            空の木は定義上 均衡 →
+                            <span class="text-emerald-600 font-bold">true</span>
+                        </p>
+                    </div>
+                </div>
+
+                <div class="p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        🧠 解法のアイデア：1パスで高さ計算と均衡チェックを同時に行う
+                    </p>
+                    <p class="text-slate-600 text-sm leading-7">
+                        葉ノード（子のないノード）から根ノードに向かってさかのぼりながら（ボトムアップ）、高さを返しつつ同時に均衡チェックも行います。
+                        不均衡が見つかったら
+                        <span class="font-mono bg-white px-1 rounded text-red-600">-1</span
+                        >（番兵値）を返し、上位ノードへ伝播させます。
+                        これにより各ノードをちょうど1回だけ訪問する O(n) が実現できます。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===================== STEPS (React) ===================== -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-2 pb-2 border-b-4 border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    各ステップをクリックするか ▶ Play で自動再生できます。
+                </p>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ===================== CODE ===================== -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-5 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 leading-7">
+                        <li>
+                            <strong>isBalanced</strong
+                            >：外部に公開するエントリポイント。check_height を呼んで -1 でなければ
+                            True を返す
+                        </li>
+                        <li>
+                            <strong>check_height（ネスト関数）</strong
+                            >：再帰の本体。高さを返しつつ不均衡なら -1 を返す
+                        </li>
+                        <li>ベースケース：node が None なら高さ 0 を返す</li>
+                        <li>左右を再帰し、-1 が返ってきたら即 -1 を伝播（早期リターン）</li>
+                        <li>
+                            左右の高さの差 &gt; 1 なら -1、そうでなければ max(左, 右) + 1 を返す
+                        </li>
+                    </ol>
+                </div>
+
+                <pre class="line-numbers"><code class="language-python">from typing import Optional
+
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+
+        def check_height(node: Optional[TreeNode]) -> int:
+            # ベースケース：空のノードは高さ0
+            # `is None` はPEP 8推奨。None はシングルトンなので is が正確
+            if node is None:
+                return 0
+
+            # 左サブツリーの高さを再帰で取得
+            left_height = check_height(node.left)
+            # 左が -1（不均衡検知済み）なら即座に -1 を返す（早期リターン）
+            if left_height == -1:
+                return -1
+
+            # 右サブツリーの高さを再帰で取得
+            right_height = check_height(node.right)
+            # 右が -1 のときも同様に伝播
+            if right_height == -1:
+                return -1
+
+            # このノードでの均衡チェック
+            # abs() はC実装の組み込み関数で高速
+            if abs(left_height - right_height) > 1:
+                return -1  # 番兵値 -1 を返して不均衡を上位へ知らせる
+
+            # このノードの高さ = max(左, 右) + 自分の1
+            # max() もC実装の組み込み関数で高速
+            return max(left_height, right_height) + 1
+
+        # check_height が -1 でなければ均衡している
+        return check_height(root) != -1</code></pre>
+
+                <div class="mt-5 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"
+                    >
+check_height(3)  開始
+  ├─ check_height(9)   → left=0, right=0, diff=0 ≤ 1  → return 1
+  │   left_height=1 (≠-1、継続)
+  ├─ check_height(20)  開始
+  │   ├─ check_height(15) → return 1
+  │   │   left_height=1 (≠-1、継続)
+  │   ├─ check_height(7)  → return 1
+  │   │   right_height=1 (≠-1、継続)
+  │   └─ abs(1-1)=0 ≤ 1 → return max(1,1)+1 = 2
+  │   right_height=2 (≠-1、継続)
+  └─ abs(1-2)=1 ≤ 1 → return max(1,2)+1 = 3
+
+check_height(root) = 3
+3 != -1  →  isBalanced = True ✅</pre
+                    >
+                </div>
+
+                <div class="mt-4 p-4 rounded-xl bg-red-50 border border-red-200">
+                    <p class="text-red-800 font-semibold text-sm mb-2">
+                        ▶ 不均衡ケース [1,2,2,3,3,null,null,4,4] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-7 overflow-x-auto whitespace-pre"
+                    >
+check_height(4) → 1  (左の4)
+check_height(4) → 1  (右の4)
+check_height(3) [左]  → abs(1-1)=0 → return 2
+check_height(3) [右]  → abs(0-0)=0 → return 1
+check_height(2) [左]  → abs(2-1)=1 ≤ 1 → return 3
+check_height(2) [右]  → return 1
+check_height(1) [ルート]
+  left_height=3, right_height=1
+  abs(3-1) = 2  > 1  → return -1  ← 不均衡！
+
+check_height(root) = -1
+-1 == -1  →  isBalanced = False ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ===================== FLOWCHART ===================== -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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="28" height="18">
+                                <ellipse
+                                    cx="14"
+                                    cy="9"
+                                    rx="13"
+                                    ry="8"
+                                    fill="#d1fae5"
+                                    stroke="#10b981"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <rect
+                                    x="1"
+                                    y="2"
+                                    width="26"
+                                    height="14"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <polygon
+                                    points="14,1 27,9 14,17 1,9"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 col-span-2 md:col-span-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500 mr-1"></span
+                            ><span class="mr-2">緑＝はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-500 mr-1"></span>赤＝いいえ
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-5 overflow-x-auto">
+                    <svg
+                        viewBox="0 0 560 1200"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Balanced Binary Tree DFS 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="#dc2626" />
+                            </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>
+
+                        <!-- N1: START -->
+                        <ellipse
+                            cx="280"
+                            cy="44"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="40"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#065f46"
+                            font-weight="600"
+                        >
+                            isBalanced(root) 開始
+                        </text>
+                        <text
+                            x="280"
+                            y="55"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            check_height(root) を呼ぶ
+                        </text>
+
+                        <!-- Arrow N1→N2 -->
+                        <line
+                            x1="280"
+                            y1="72"
+                            x2="280"
+                            y2="105"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N2: check_height(node) called -->
+                        <rect
+                            x="80"
+                            y="108"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="128"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            check_height(node) を呼ぶ
+                        </text>
+                        <text
+                            x="280"
+                            y="148"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            node = 現在処理中のノード
+                        </text>
+
+                        <!-- Arrow N2→N3 -->
+                        <line
+                            x1="280"
+                            y1="158"
+                            x2="280"
+                            y2="195"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N3: node is None? -->
+                        <polygon
+                            points="280,198 430,248 280,298 130,248"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="243"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            node is None ?
+                        </text>
+                        <text
+                            x="280"
+                            y="260"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （木の末端に到達したか）
+                        </text>
+
+                        <!-- N3 → YES → return 0 -->
+                        <line
+                            x1="430"
+                            y1="248"
+                            x2="500"
+                            y2="248"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="464"
+                            y="240"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="220"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="244"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="262"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            0
+                        </text>
+
+                        <!-- N3 → NO → continue down -->
+                        <line
+                            x1="280"
+                            y1="298"
+                            x2="280"
+                            y2="335"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="293"
+                            y="320"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N4: left_height = check_height(node.left) -->
+                        <rect
+                            x="80"
+                            y="338"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="358"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            left_height = check_height(node.left)
+                        </text>
+                        <text
+                            x="280"
+                            y="378"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            左の部分木の高さを再帰で計算
+                        </text>
+
+                        <!-- Arrow N4→N5 -->
+                        <line
+                            x1="280"
+                            y1="388"
+                            x2="280"
+                            y2="425"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N5: left_height == -1 ? -->
+                        <polygon
+                            points="280,428 430,478 280,528 130,478"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="473"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            left_height == -1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="490"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （左サブツリーで不均衡を検知済みか）
+                        </text>
+
+                        <!-- N5 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="478"
+                            x2="500"
+                            y2="478"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="470"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="450"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="474"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="492"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N5 → NO -->
+                        <line
+                            x1="280"
+                            y1="528"
+                            x2="280"
+                            y2="565"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="550"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N6: right_height = check_height(node.right) -->
+                        <rect
+                            x="80"
+                            y="568"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="588"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            right_height = check_height(node.right)
+                        </text>
+                        <text
+                            x="280"
+                            y="608"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            右の部分木の高さを再帰で計算
+                        </text>
+
+                        <!-- Arrow N6→N7 -->
+                        <line
+                            x1="280"
+                            y1="618"
+                            x2="280"
+                            y2="655"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N7: right_height == -1 ? -->
+                        <polygon
+                            points="280,658 430,708 280,758 130,708"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="703"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            right_height == -1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="720"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （右サブツリーで不均衡を検知済みか）
+                        </text>
+
+                        <!-- N7 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="708"
+                            x2="500"
+                            y2="708"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="700"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="680"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="704"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="722"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N7 → NO -->
+                        <line
+                            x1="280"
+                            y1="758"
+                            x2="280"
+                            y2="795"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="780"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N8: abs(left-right) > 1 ? -->
+                        <polygon
+                            points="280,798 430,858 280,918 130,858"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="848"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            abs(left_height - right_height) &gt; 1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="868"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （このノードで左右の高さの差が大きすぎるか）
+                        </text>
+
+                        <!-- N8 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="858"
+                            x2="500"
+                            y2="858"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="850"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="830"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="854"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="872"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N8 → NO -->
+                        <line
+                            x1="280"
+                            y1="918"
+                            x2="280"
+                            y2="955"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="940"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N9: return max(l,r)+1 -->
+                        <rect
+                            x="80"
+                            y="958"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="978"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            return max(left_height, right_height) + 1
+                        </text>
+                        <text
+                            x="280"
+                            y="998"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            このノードの高さ（均衡OK）を親へ返す
+                        </text>
+
+                        <!-- Arrow N9→N10 -->
+                        <line
+                            x1="280"
+                            y1="1008"
+                            x2="280"
+                            y2="1045"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N10: END -->
+                        <ellipse
+                            cx="280"
+                            cy="1080"
+                            rx="140"
+                            ry="32"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="1074"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#065f46"
+                            font-weight="600"
+                        >
+                            check_height(root) != -1 を返す
+                        </text>
+                        <text
+                            x="280"
+                            y="1092"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            True（均衡）または False（不均衡）
+                        </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-2 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→ check_height(node=3) を呼ぶ。node は None でないので処理継続
+                        </li>
+                        <li>
+                            左サブツリー check_height(9) を計算 → 9の左右はどちらも None
+                            なので高さ1を返す。-1 でないので継続
+                        </li>
+                        <li>
+                            右サブツリー check_height(20) を計算 → 15と7の高さがそれぞれ1 →
+                            abs(1-1)=0 ≤ 1 → 高さ2を返す。-1 でないので継続
+                        </li>
+                        <li>ルート3での均衡チェック：abs(1-2)=1 ≤ 1 → 均衡OK → 高さ3を返す</li>
+                        <li>
+                            「終了」→ 3 != -1 → isBalanced =
+                            <span class="text-emerald-600 font-bold">True</span>
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ===================== COMPLEXITY ===================== -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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(log n)</div>
+                            <div class="leading-5">
+                                log倍に増加<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-5">
+                    <table class="w-full border-collapse text-sm">
+                        <thead>
+                            <tr class="bg-gradient-to-r from-emerald-100 to-sky-100">
+                                <th
+                                    class="p-3 text-left text-slate-700 font-bold border border-slate-200 rounded-tl-lg"
+                                >
+                                    アプローチ
+                                </th>
+                                <th
+                                    class="p-3 text-center text-slate-700 font-bold border border-slate-200"
+                                >
+                                    時間計算量
+                                </th>
+                                <th
+                                    class="p-3 text-center text-slate-700 font-bold border border-slate-200"
+                                >
+                                    空間計算量
+                                </th>
+                                <th
+                                    class="p-3 text-left text-slate-700 font-bold border border-slate-200 rounded-tr-lg"
+                                >
+                                    備考
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="bg-emerald-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-emerald-800"
+                                >
+                                    ✅ ボトムアップDFS（番兵値-1）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-emerald-700"
+                                >
+                                    O(n)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-emerald-700"
+                                >
+                                    O(h)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    各ノードを1回だけ訪問。h=木の高さ（均衡木ではO(log
+                                    n)、最悪O(n)）
+                                </td>
+                            </tr>
+                            <tr class="bg-red-50">
+                                <td class="p-3 border border-slate-200 font-semibold text-red-700">
+                                    ❌ トップダウン再帰（素朴）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-red-600"
+                                >
+                                    O(n²)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono text-red-600"
+                                >
+                                    O(h)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    高さ計算と均衡チェックを分離するため同じノードを繰り返し訪問してしまう
+                                </td>
+                            </tr>
+                            <tr class="bg-amber-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-amber-700"
+                                >
+                                    BFS（幅優先探索）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-amber-600"
+                                >
+                                    O(n)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono text-amber-600"
+                                >
+                                    O(n)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    dequeのメモリ確保コストがある。実装も複雑になりやすい
+                                </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>：check_height
+                        はすべてのノードをちょうど1回だけ訪問します。不均衡が見つかった瞬間に -1
+                        を返す早期リターンにより、無駄な再帰呼び出しを省けています。<br />
+                        <strong>空間計算量 O(h)</strong>：再帰呼び出しのコールスタックが木の高さ h
+                        分だけ積み重なります。均衡木では h = O(log n)、最悪の一直線の木では h = O(n)
+                        になります。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===================== GLOSSARY ===================== -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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="arrow text-emerald-500">▶</span>
+                            高さ均衡二分木（Height-balanced Binary Tree）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            すべてのノードで、左右の部分木の高さの差が最大1である二分木のこと。AVL木がこの代表例です。均衡が保たれていると、検索・挿入・削除などの操作をO(log
+                            n)で行えます。
+                        </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="arrow text-emerald-500">▶</span> 番兵値（Sentinel Value）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            通常の値としてあり得ない特別な値を使ってエラーや特殊状態を表す手法です。この問題では
+                            -1 が番兵値で「不均衡が検知済み」を意味します。高さは常に0以上なので、-1
+                            は安全な番兵値として機能します。
+                        </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="arrow text-emerald-500">▶</span>
+                            ボトムアップ再帰（Bottom-up Recursion）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            葉ノード（末端）から根ノードに向かって結果を積み上げていく再帰の方向です。対義語はトップダウン（根から葉へ）。ボトムアップにすると、計算結果を再利用できるためO(n)が実現できます。
+                        </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="arrow text-emerald-500">▶</span> ネスト関数（Nested
+                            Function）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数の中に定義された関数のこと。外部スコープから直接呼べないため、内部実装を隠蔽できます。Pythonではネスト関数はローカルスコープで名前解決されるため、クラスメソッドより少し高速です。
+                        </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="arrow text-emerald-500">▶</span> DFS（深さ優先探索 /
+                            Depth-First Search）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木やグラフを探索する方法の一つで、できるだけ深く進んでから戻る方式です。迷路を解くとき「行き止まりになるまで進んで、戻って別の道を試す」イメージです。木の問題では再帰で自然に実装できます。
+                        </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="arrow text-emerald-500">▶</span> ベースケース（Base Case）
+                        </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 is None</code
+                            >
+                            がベースケースで、高さ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="arrow text-emerald-500">▶</span> 早期リターン（Early
+                            Return）
+                        </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">return</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="arrow text-emerald-500">▶</span> シングルトン（Singleton）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            プログラム中に1つしか存在しないオブジェクトのことです。Pythonの
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">None</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs">True</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >False</code
+                            >
+                            がこれにあたります。<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >is None</code
+                            >
+                            が
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">== None</code>
+                            より正確で速い理由は、Noneがシングルトンだからです。
+                        </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="arrow text-emerald-500">▶</span> コールスタック（Call
+                            Stack）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数呼び出しが積み重なっていく記録です。「お皿の積み重ね」のように、最後に呼んだ関数が最初に終わります（LIFO）。再帰が深くなるほどコールスタックが大きくなり、空間計算量に影響します。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center text-slate-400 text-sm py-4">
+                LeetCode 110 · Balanced Binary Tree — ボトムアップDFS解説
+            </footer>
+        </div>
+
+        <!-- ===================== REACT COMPONENT ===================== -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: 'isBalanced でエントリポイントを定義',
+                    desc: 'まず外部に公開する関数 isBalanced を定義し、その中でヘルパー関数 check_height を呼び出します。なぜヘルパーをネスト関数にするかというと、「高さを返す / -1 を返す」という内部の詳細を外に見せないためです。外部から見ると isBalanced は「True/False を返す」だけのシンプルなAPIになります。例）isBalanced(root=TreeNode(3)) を呼ぶと、内部で check_height(TreeNode(3)) が実行されます。',
+                    visual: 'entry',
+                },
+                {
+                    step: 2,
+                    title: 'ベースケース：node is None → return 0',
+                    desc: 'check_height が最初に確認するのは「今のノードが None（空）かどうか」です。なぜなら、再帰はいつか木の末端（葉の下）に到達し、そこで処理を止める必要があるからです。None のノードは「高さ0の空の木」なので 0 を返します。`is None` を使う理由：Pythonの None はシングルトン（プログラム中に1つだけ存在）なので、`is` による同一性チェックが正確かつ高速です。',
+                    visual: 'base',
+                },
+                {
+                    step: 3,
+                    title: '左サブツリーを再帰処理',
+                    desc: '現在のノードの左の子 node.left を引数に check_height を再帰呼び出しし、左サブツリーの高さを取得します。なぜ先に左を処理するかは、左右どちらから始めても正解ですが、DFSは慣習的に左から始めます。返り値が -1 なら左サブツリーで不均衡が見つかっているので、即座に -1 を上位ノードへ返します（早期リターン）。例）node=TreeNode(3) で left=TreeNode(9) のとき、check_height(9) を呼ぶ。',
+                    visual: 'left',
+                },
+                {
+                    step: 4,
+                    title: '右サブツリーを再帰処理',
+                    desc: '左サブツリーが均衡していた（left_height ≠ -1）場合のみ、右の子 node.right を引数に check_height を再帰呼び出しします。なぜ左の確認後に右を処理するかというと、左で不均衡が確定しているなら右を調べる必要が全くないからです（早期リターンで効率化）。返り値が -1 なら同様に -1 を伝播します。例）left_height=1 (≠-1) なので right=TreeNode(20) を処理 → check_height(20) を呼ぶ。',
+                    visual: 'right',
+                },
+                {
+                    step: 5,
+                    title: '均衡チェック：abs(left - right) > 1 ?',
+                    desc: '左右両サブツリーが均衡している（どちらも ≠ -1）場合、このノードでの均衡チェックを行います。abs(left_height - right_height) > 1 であれば不均衡なので -1 を返します。abs()（絶対値）を使う理由：左が深い場合も右が深い場合も1行で処理でき、かつCPythonのC実装なので高速です。例）left=1, right=2 → abs(1-2)=1 ≤ 1 → 均衡OK。left=3, right=1 → abs(3-1)=2 > 1 → 不均衡 → return -1。',
+                    visual: 'balance',
+                },
+                {
+                    step: 6,
+                    title: '高さを返す：return max(left, right) + 1',
+                    desc: '均衡チェックを通過したノードは「高さ = max(左の高さ, 右の高さ) + 1」を返します。+1 は「自分自身のノード1段分」を追加しています。max() を使う理由：左右のうち深い方が実際のサブツリーの高さになるからです。max() もCPythonのC実装で高速です。例）left=1, right=2 → max(1,2)+1 = 3 を親ノードへ返す。これが親ノードの left_height または right_height になります。',
+                    visual: 'height',
+                },
+                {
+                    step: 7,
+                    title: '最終判定：check_height(root) != -1',
+                    desc: 'すべての再帰が完了して check_height(root) の結果が返ってきます。-1 でなければ全ノードが均衡していたことを意味し True を返します。-1 であれば不均衡が検知されたので False を返します。この != -1 という単純な比較で全体の判定が完結します。例）Example1 → check_height(3) = 3 → 3 != -1 → True。Example2 → check_height(1) = -1 → -1 == -1 → False。',
+                    visual: 'final',
+                },
+            ];
+
+            const treeNodes = {
+                entry: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#10b981' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '3',
+                    label: 'isBalanced(root=3) を呼び出し中',
+                },
+                base: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: 'N', x: 30, y: 160, c: '#f59e0b' },
+                        { v: 'N', x: 130, y: 160, c: '#f59e0b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 80, y1: 110, x2: 30, y2: 145 },
+                        { x1: 80, y1: 110, x2: 130, y2: 145 },
+                    ],
+                    highlight: 'N',
+                    label: 'None → return 0（高さ0）',
+                },
+                left: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#10b981' },
+                        { v: '20', x: 240, y: 95, c: '#e2e8f0' },
+                        { v: 'N', x: 30, y: 160, c: '#64748b' },
+                        { v: 'N', x: 130, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 80, y1: 110, x2: 30, y2: 145 },
+                        { x1: 80, y1: 110, x2: 130, y2: 145 },
+                    ],
+                    highlight: '9',
+                    label: 'check_height(9) → left_height = 1',
+                },
+                right: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#0ea5e9' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '20',
+                    label: 'check_height(20) → right_height = 2',
+                },
+                balance: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#a855f7' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '3',
+                    label: 'abs(1-2)=1 ≤ 1 → 均衡OK！',
+                },
+                height: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#f59e0b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                    ],
+                    highlight: '3',
+                    label: 'return max(1,2)+1 = 3 を返す',
+                },
+                final: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#10b981' },
+                        { v: '9', x: 80, y: 95, c: '#10b981' },
+                        { v: '20', x: 240, y: 95, c: '#10b981' },
+                        { v: '15', x: 190, y: 160, c: '#10b981' },
+                        { v: '7', x: 290, y: 160, c: '#10b981' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: 'all',
+                    label: '3 != -1 → True ✅ 全ノード均衡！',
+                },
+            };
+
+            const varStates = {
+                entry: { node: '3', left_height: '未計算', right_height: '未計算', result: '—' },
+                base: { node: 'None', left_height: '—', right_height: '—', result: '0 を返す' },
+                left: { node: '3', left_height: '1', right_height: '未計算', result: '—' },
+                right: { node: '3', left_height: '1', right_height: '2', result: '—' },
+                balance: {
+                    node: '3',
+                    left_height: '1',
+                    right_height: '2',
+                    result: 'abs(1-2)=1 ≤ 1 → OK',
+                },
+                height: { node: '3', left_height: '1', right_height: '2', result: 'return 3' },
+                final: {
+                    node: 'root',
+                    left_height: '—',
+                    right_height: '—',
+                    result: '3 != -1 → True',
+                },
+            };
+
+            function TreeViz({ visual }) {
+                const data = treeNodes[visual];
+                if (!data) return null;
+                return (
+                    <div className="mt-3">
+                        <svg
+                            viewBox="0 0 340 200"
+                            style={{
+                                width: '100%',
+                                maxWidth: '340px',
+                                display: 'block',
+                                margin: '0 auto',
+                            }}
+                        >
+                            {data.edges.map((e, i) => (
+                                <line
+                                    key={i}
+                                    x1={e.x1}
+                                    y1={e.y1}
+                                    x2={e.x2}
+                                    y2={e.y2}
+                                    stroke="#cbd5e1"
+                                    strokeWidth="2"
+                                />
+                            ))}
+                            {data.nodes.map((n, i) => (
+                                <g key={i}>
+                                    <circle
+                                        cx={n.x}
+                                        cy={n.y + 15}
+                                        r="22"
+                                        fill={n.c}
+                                        stroke={n.c === '#e2e8f0' ? '#cbd5e1' : 'white'}
+                                        strokeWidth="2.5"
+                                    />
+                                    <text
+                                        x={n.x}
+                                        y={n.y + 20}
+                                        textAnchor="middle"
+                                        fontSize="13"
+                                        fontFamily="JetBrains Mono,monospace"
+                                        fill="white"
+                                        fontWeight="700"
+                                    >
+                                        {n.v}
+                                    </text>
+                                </g>
+                            ))}
+                        </svg>
+                        <p className="text-center text-xs text-slate-500 mt-2 font-mono">
+                            {data.label}
+                        </p>
+                    </div>
+                );
+            }
+
+            function VarPanel({ visual }) {
+                const v = varStates[visual] || {};
+                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>
+                        <div className="grid grid-cols-2 gap-1">
+                            <div>
+                                <span className="text-violet-500">node</span> ={' '}
+                                <span className="text-slate-700">{v.node}</span>
+                            </div>
+                            <div>
+                                <span className="text-emerald-600">left_height</span> ={' '}
+                                <span className="text-slate-700">{v.left_height}</span>
+                            </div>
+                            <div>
+                                <span className="text-sky-600">right_height</span> ={' '}
+                                <span className="text-slate-700">{v.right_height}</span>
+                            </div>
+                            <div>
+                                <span className="text-amber-600">戻り値</span> ={' '}
+                                <span className="text-slate-700">{v.result}</span>
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            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);
+                            }
+                        }, 2000);
+                    }
+                    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((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-sm rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'bg-gradient-to-br from-emerald-50 to-teal-50 border-emerald-400 shadow-md'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-300 hover:translate-x-1',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5',
+                                                    isActive
+                                                        ? 'text-emerald-800'
+                                                        : 'text-slate-700',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}
+                                            </div>
+                                            <div className="text-slate-500 text-xs">
+                                                {step.title}
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        <div className="my-auto">
+                            {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}）：
+                                    {stepsData[activeStep - 2]?.title}
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-gradient-to-br from-emerald-50 to-sky-50">
+                                <h3 className="mt-0 text-teal-800 text-base font-bold mb-1">
+                                    Step {currentStepData.step}: {currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <TreeViz visual={currentStepData.visual} />
+                            <VarPanel visual={currentStepData.visual} />
+
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-emerald-500 to-emerald-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-sky-500 to-sky-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-sky-500 to-sky-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-slate-700 transition bg-white border-2 border-slate-200 text-sm shadow hover:-translate-y-0.5"
+                                    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 />);
+
+            setTimeout(() => {
+                if (window.Prism) Prism.highlightAll();
+            }, 500);
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/README_react.html b/public/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/README_react.html
new file mode 100644
index 0000000..9129625
--- /dev/null
+++ b/public/Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order Traversal/claude sonnet 4.6 extended/README_react.html	
@@ -0,0 +1,1341 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1.0" />
+        <title>LeetCode 102 · Binary Tree Level Order Traversal</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>
+        <script src="https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.min.js"></script>
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;500;700&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/themes/prism-tomorrow.css"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.css"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/plugins/toolbar/prism-toolbar.css"
+            rel="stylesheet"
+        />
+        <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>
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            .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;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            details[open] > summary .arrow {
+                transform: rotate(90deg);
+            }
+            .arrow {
+                display: inline-block;
+                transition: transform 0.2s;
+            }
+
+            /* ── Mermaid カスタムスタイル ── */
+            .mermaid-wrapper {
+                background: linear-gradient(135deg, #f0fdf4 0%, #e0f2fe 100%);
+                border: 2px solid #a7f3d0;
+                border-radius: 20px;
+                padding: 28px 16px;
+                overflow-x: auto;
+            }
+            .mermaid-wrapper .mermaid {
+                display: flex;
+                justify-content: center;
+            }
+            /* ノードラベルの日本語フォント */
+            .mermaid svg text {
+                font-family: 'Noto Sans JP', 'JetBrains Mono', sans-serif !important;
+            }
+        </style>
+    </head>
+    <body
+        class="min-h-screen"
+        style="background: linear-gradient(135deg, #f0fdf4 0%, #e0f2fe 50%, #fdf4ff 100%)"
+    >
+        <div class="max-w-5xl mx-auto px-4 py-8">
+            <!-- ===== HEADER ===== -->
+            <header
+                id="header"
+                class="mb-8 rounded-3xl p-8 shadow-xl"
+                style="background: linear-gradient(135deg, #d1fae5 0%, #bfdbfe 60%, #ede9fe 100%)"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="outfit bg-emerald-600 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >LeetCode #102</span
+                    >
+                    <span
+                        class="outfit bg-sky-500 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >Medium</span
+                    >
+                    <span
+                        class="outfit bg-violet-500 text-white text-sm font-bold px-4 py-1 rounded-full shadow"
+                        >BFS</span
+                    >
+                </div>
+                <h1 class="outfit text-4xl font-black text-teal-900 mb-1 leading-tight">
+                    Binary Tree Level Order Traversal
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold">
+                    BFS + collections.deque による O(n) 実装
+                </p>
+                <div
+                    class="mt-4 inline-block bg-white/70 rounded-2xl px-5 py-3 border border-white/80 shadow"
+                >
+                    <p class="text-teal-800 font-bold text-base">
+                        💡
+                        一言で言うと：「木を上から下へ、同じ高さのノードをまとめてグループ化する問題」
+                    </p>
+                </div>
+                <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-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >概要</a
+                    >
+                    <a
+                        href="#steps"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >ステップ解説</a
+                    >
+                    <a
+                        href="#code"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >コード</a
+                    >
+                    <a
+                        href="#diagram"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >フローチャート</a
+                    >
+                    <a
+                        href="#complexity"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >計算量</a
+                    >
+                    <a
+                        href="#glossary"
+                        class="inline-block px-4 py-2 font-semibold text-slate-700 no-underline rounded-xl border-2 border-white bg-white/80 transition hover:shadow-lg hover:-translate-y-0.5 hover:bg-emerald-50 hover:border-emerald-400 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ===== OVERVIEW ===== -->
+            <section id="overview" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+
+                <div class="mb-5 p-5 rounded-2xl bg-emerald-50 border-l-4 border-emerald-500">
+                    <p class="text-emerald-800 font-bold text-base">💡 この問題を一言で言うと：</p>
+                    <p class="text-slate-700 text-sm mt-2 leading-7">
+                        「木の同じ深さ（階層）にあるノードを全部集めて1つのリストにまとめ、それを深さ順に並べた2次元配列を返す問題」です。<br />
+                        左から右の順番でノードを集める必要があります。
+                    </p>
+                </div>
+
+                <div class="mb-5 p-5 rounded-2xl bg-amber-50 border-l-4 border-amber-400">
+                    <p class="text-amber-800 font-bold text-sm mb-3">
+                        ⚠️ なぜ単純な方法では解けないのか
+                    </p>
+                    <ul class="text-slate-700 text-sm space-y-2 list-disc list-inside leading-7">
+                        <li>
+                            「縦方向（深さ優先）」に探索するだけでは、同じ深さのノードをまとめる境界が分からない
+                        </li>
+                        <li>
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">list.pop(0)</code>
+                            を使うと先頭削除が O(n) になり全体が O(n²) へ悪化する
+                        </li>
+                        <li>
+                            ノードの値が
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">0</code>
+                            のとき、<code class="bg-amber-100 px-1 rounded mono text-xs">or</code>
+                            トリックは
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">0</code
+                            >（falsy）と誤判定して壊れる
+                        </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-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-2xl">O(n)</div>
+                        <div class="text-xs mt-1 font-semibold">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #bfdbfe; color: #1e40af"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-2xl">O(n)</div>
+                        <div class="text-xs mt-1 font-semibold">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-lg mono break-all leading-tight">
+                            deque
+                        </div>
+                        <div class="text-xs mt-1 font-semibold">データ構造</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-2xl p-4 text-center shadow-sm"
+                    >
+                        <div class="outfit font-black text-lg">BFS</div>
+                        <div class="text-xs mt-1 font-semibold">探索手法</div>
+                    </div>
+                </div>
+
+                <div class="rounded-2xl bg-slate-50 border border-slate-200 p-5 mb-4">
+                    <p class="text-slate-600 font-bold text-sm mb-3">📥 入出力例</p>
+                    <div class="grid md:grid-cols-2 gap-4">
+                        <div>
+                            <p class="text-xs text-slate-500 mb-1 font-semibold">入力（ツリー）</p>
+                            <pre
+                                class="mono text-sm bg-slate-800 text-emerald-300 rounded-xl p-4 leading-6"
+                            >
+    3
+   / \
+  9  20
+     / \
+    15   7</pre
+                            >
+                        </div>
+                        <div>
+                            <p class="text-xs text-slate-500 mb-1 font-semibold">出力と理由</p>
+                            <pre
+                                class="mono text-sm bg-slate-800 text-sky-300 rounded-xl p-4 leading-6"
+                            >
+[[3],[9,20],[15,7]]
+
+深さ0 → [3]
+深さ1 → [9, 20]  ← 左から右
+深さ2 → [15, 7]  ← 左から右</pre
+                            >
+                        </div>
+                    </div>
+                </div>
+
+                <div class="rounded-2xl bg-slate-50 border border-slate-200 p-5">
+                    <p class="text-slate-600 font-bold text-sm mb-2">📋 制約</p>
+                    <ul class="text-sm text-slate-600 space-y-1 list-disc list-inside">
+                        <li>ノード数：0 以上 2000 以下</li>
+                        <li>ノードの値：<strong>-1000 以上 1000 以下（0 が含まれる）</strong></li>
+                    </ul>
+                </div>
+            </section>
+
+            <!-- ===== STEPS (React) ===== -->
+            <section id="steps" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-2 pb-3 border-b-4 border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-6">
+                    各ステップをクリックするか、▶ Play ボタンで自動再生できます。
+                </p>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ===== CODE ===== -->
+            <section id="code" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-5 p-5 rounded-2xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-bold text-sm mb-3">
+                        📋 このコードの構造（先に全体像を把握しよう）
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-2 list-decimal list-inside leading-7">
+                        <li>
+                            <strong>空ツリーのチェック</strong>：root が None なら即座に [] を返す
+                        </li>
+                        <li>
+                            <strong>deque の初期化</strong>：root をキューに入れて BFS 開始の準備
+                        </li>
+                        <li>
+                            <strong>while ループ</strong>：キューが空になるまで、階層ごとに処理する
+                        </li>
+                        <li>
+                            <strong>level_size の固定</strong
+                            >：今の階のサイズをここで確定させる（核心）
+                        </li>
+                        <li>
+                            <strong>for ループ</strong>：level_size 個だけ popleft()
+                            し、値収集と子の登録を行う
+                        </li>
+                        <li><strong>結果への追加</strong>：今の階の値リストを result に追加する</li>
+                    </ol>
+                </div>
+
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from collections import deque
+from typing import Optional
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -&gt; list[list[int]]:
+        # 基底条件: root が None（空ツリー）なら即座に空リストを返す
+        # None チェックをしないと後続の node.val アクセスでクラッシュする
+        if root is None:
+            return []
+
+        result: list[list[int]] = []
+
+        # collections.deque をキューとして使う
+        # list.pop(0) は O(n) だが deque.popleft() は O(1)
+        # deque は C言語実装の双方向キューで先頭・末尾への操作が高速
+        queue: deque[TreeNode] = deque([root])
+
+        # キューが空になるまでループ（= 全ノードを処理し終えるまで）
+        while queue:
+            # ── BFS の核心：今の階のサイズをここで固定する ──
+            # ループ中に popleft()/append() で queue の長さが変化するため
+            # 先に変数へ保存しないと「今の階」の範囲がずれて Wrong Answer になる
+            level_size: int = len(queue)
+            level_values: list[int] = []
+
+            for _ in range(level_size):
+                # popleft() でキューの先頭ノードを O(1) で取り出す
+                node: TreeNode = queue.popleft()
+
+                # val を直接 append する（0 も正しく追加される）
+                # `or` トリックは val=0 のとき falsy と判定されて壊れるため使わない
+                level_values.append(node.val)
+
+                # 子が存在する場合のみキューへ追加（次の階の準備）
+                if node.left is not None:
+                    queue.append(node.left)
+                if node.right is not None:
+                    queue.append(node.right)
+
+            result.append(level_values)
+
+        return result</code></pre>
+
+                <div class="mt-5 p-5 rounded-2xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-bold text-sm mb-3">
+                        ▶ 入力例 [3, 9, 20, null, null, 15, 7] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs mono leading-7 overflow-x-auto whitespace-pre"
+                    >
+初期状態: queue = deque([Node(3)]),  result = []
+
+━━ ループ 1回目（深さ0） ━━
+  level_size = 1   ← ここで固定！
+  vals = []
+  i=0: popleft() → Node(3)   queue = deque([])
+       append(3)  → vals = [3]
+       left=Node(9)  → queue = deque([Node(9)])
+       right=Node(20) → queue = deque([Node(9), Node(20)])
+  result = [[3]]
+
+━━ ループ 2回目（深さ1） ━━
+  level_size = 2   ← ここで固定！
+  i=0: Node(9)  → vals=[9]       子なし
+  i=1: Node(20) → vals=[9,20]    left=Node(15), right=Node(7)
+  result = [[3], [9, 20]]
+
+━━ ループ 3回目（深さ2） ━━
+  level_size = 2
+  i=0: Node(15) → vals=[15]      子なし
+  i=1: Node(7)  → vals=[15,7]    子なし
+  result = [[3], [9, 20], [15, 7]]
+
+queue が空 → ループ終了
+戻り値: [[3], [9, 20], [15, 7]] ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ===== FLOWCHART ===== -->
+            <section id="diagram" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+
+                <!-- 凡例 -->
+                <div class="mb-6 p-5 rounded-2xl bg-amber-50 border border-amber-200">
+                    <p class="text-amber-800 font-bold text-sm mb-4">
+                        🗺️ フローチャートの読み方（Mermaid 記法）
+                    </p>
+                    <div
+                        class="grid grid-cols-1 sm:grid-cols-2 md:grid-cols-4 gap-3 text-xs text-slate-700"
+                    >
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded-full bg-emerald-100 border-2 border-emerald-500 text-emerald-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >([…])</span
+                            >
+                            <span>スタジアム形（緑）<br />= 開始・終了</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded-lg bg-sky-100 border-2 border-sky-400 text-sky-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >[…]</span
+                            >
+                            <span>四角形（青）<br />= 処理ステップ</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span
+                                class="inline-flex items-center justify-center rounded bg-amber-100 border-2 border-amber-400 text-amber-800 font-bold px-3 py-1 text-xs mono whitespace-nowrap"
+                                >{…}</span
+                            >
+                            <span>ひし形（黄）<br />= 条件分岐</span>
+                        </div>
+                        <div
+                            class="flex items-center gap-3 bg-white rounded-xl px-3 py-2.5 border border-amber-100 shadow-sm"
+                        >
+                            <span class="flex flex-col gap-1">
+                                <span class="flex items-center gap-1"
+                                    ><span
+                                        class="inline-block w-6 h-0.5 bg-emerald-500 rounded"
+                                    ></span
+                                    ><span class="text-emerald-700 font-semibold"
+                                        >Yes（はい）</span
+                                    ></span
+                                >
+                                <span class="flex items-center gap-1"
+                                    ><span class="inline-block w-6 h-0.5 bg-red-400 rounded"></span
+                                    ><span class="text-red-600 font-semibold"
+                                        >No（いいえ）</span
+                                    ></span
+                                >
+                            </span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Mermaid フローチャート（JS経由でレンダリング・HTMLパーサーを完全回避） -->
+                <div class="mermaid-wrapper">
+                    <div
+                        id="mermaid-render-target"
+                        style="
+                            display: flex;
+                            justify-content: center;
+                            min-height: 120px;
+                            align-items: center;
+                        "
+                    >
+                        <span style="color: #94a3b8; font-size: 13px">読み込み中…</span>
+                    </div>
+                </div>
+
+                <!-- 色の意味の補足 -->
+                <div class="mt-4 flex flex-wrap gap-3 text-xs">
+                    <span
+                        class="inline-flex items-center gap-2 bg-emerald-50 border border-emerald-200 rounded-full px-3 py-1.5 text-emerald-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-emerald-400 inline-block"></span> 緑 =
+                        開始・終了ノード
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-sky-50 border border-sky-200 rounded-full px-3 py-1.5 text-sky-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-blue-400 inline-block"></span> 青 =
+                        通常の処理
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-amber-50 border border-amber-200 rounded-full px-3 py-1.5 text-amber-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-amber-400 inline-block"></span> 黄 =
+                        条件分岐
+                    </span>
+                    <span
+                        class="inline-flex items-center gap-2 bg-violet-50 border border-violet-200 rounded-full px-3 py-1.5 text-violet-800 font-semibold"
+                    >
+                        <span class="w-3 h-3 rounded-full bg-violet-400 inline-block"></span> 紫 =
+                        BFS の核心処理
+                    </span>
+                </div>
+
+                <!-- フロー追跡 -->
+                <div class="mt-6 p-5 rounded-2xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-bold text-sm mb-3">
+                        🔎 入力例 [3, 9, 20, null, null, 15, 7] でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-2 list-decimal list-inside leading-7">
+                        <li>「Start」 → root=Node(3) を受け取る</li>
+                        <li>
+                            「root is None?」 → いいえ → 初期化: result=[], queue=deque([Node(3)])
+                        </li>
+                        <li>
+                            「queue は空?」 → いいえ（Node(3) がある）→
+                            <strong class="text-violet-700">level_size=1</strong>, vals=[]
+                        </li>
+                        <li>
+                            「i &lt; 1?」 → はい → popleft()=Node(3), vals=[3], left=Node(9)→追加,
+                            right=Node(20)→追加
+                        </li>
+                        <li>「i &lt; 1?」 → いいえ → result.append([3]) → ループバック</li>
+                        <li>
+                            （深さ1）<strong class="text-violet-700">level_size=2</strong>,
+                            Node(9)→vals=[9], Node(20)→vals=[9,20], Node(15)&amp;Node(7)追加
+                        </li>
+                        <li>
+                            （深さ2）<strong class="text-violet-700">level_size=2</strong>,
+                            Node(15)→vals=[15], Node(7)→vals=[15,7]
+                        </li>
+                        <li>
+                            「queue は空?」 → はい → 「return result」へ → [[3],[9,20],[15,7]] ✅
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ===== COMPLEXITY ===== -->
+            <section id="complexity" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-5 pb-3 border-b-4 border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <div class="mb-6 p-5 rounded-2xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-600 font-bold text-sm mb-4">
+                        📖 Big-O 記法の読み方（n = ノード数）
+                    </p>
+                    <div class="grid grid-cols-2 md:grid-cols-4 gap-3 text-xs">
+                        <div class="text-center p-4 rounded-xl bg-emerald-100 text-emerald-800">
+                            <div class="outfit font-black text-xl mb-1">O(1)</div>
+                            <div class="leading-5">
+                                常に一定<br /><span class="text-emerald-600"
+                                    >例：辞書の直接引き</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-sky-100 text-sky-800">
+                            <div class="outfit font-black text-xl mb-1">O(n)</div>
+                            <div class="leading-5">
+                                入力に比例<br /><span class="text-sky-600"
+                                    >例：リストを1回走査</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-amber-100 text-amber-800">
+                            <div class="outfit font-black text-xl mb-1">O(n²)</div>
+                            <div class="leading-5">
+                                入力の2乗<br /><span class="text-amber-600"
+                                    >例：二重ループ総当たり</span
+                                >
+                            </div>
+                        </div>
+                        <div class="text-center p-4 rounded-xl bg-red-100 text-red-800">
+                            <div class="outfit font-black text-xl mb-1 mono">list.pop(0)</div>
+                            <div class="leading-5">
+                                先頭削除は O(n)<br /><span class="text-red-600"
+                                    >全体 O(n²) になる</span
+                                >
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto rounded-2xl border border-slate-200 mb-5">
+                    <table class="w-full text-sm text-left">
+                        <thead>
+                            <tr class="bg-gradient-to-r from-emerald-50 to-sky-50">
+                                <th class="px-5 py-3 font-bold text-slate-700">種別</th>
+                                <th class="px-5 py-3 font-bold text-slate-700">計算量</th>
+                                <th class="px-5 py-3 font-bold text-slate-700">理由</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-t border-slate-100">
+                                <td class="px-5 py-3 font-semibold text-emerald-700">時間計算量</td>
+                                <td class="px-5 py-3 mono font-bold text-emerald-800">O(n)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    各ノードを popleft() で1回だけ処理（O(1)×n回）
+                                </td>
+                            </tr>
+                            <tr class="border-t border-slate-100 bg-slate-50/50">
+                                <td class="px-5 py-3 font-semibold text-sky-700">空間計算量</td>
+                                <td class="px-5 py-3 mono font-bold text-sky-800">O(n)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    キューに最大で最下層のノード数（最大 n/2 個）が入る
+                                </td>
+                            </tr>
+                            <tr class="border-t border-slate-100">
+                                <td class="px-5 py-3 font-semibold text-red-600">
+                                    比較：list.pop(0)
+                                </td>
+                                <td class="px-5 py-3 mono font-bold text-red-700">O(n²)</td>
+                                <td class="px-5 py-3 text-slate-600">
+                                    先頭削除のたびに残り全要素をシフト（O(n)×n回）
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <div class="p-5 rounded-2xl bg-emerald-50 border border-emerald-200">
+                    <p class="text-emerald-800 font-bold text-sm mb-2">
+                        🔍 なぜこの計算量になるのか
+                    </p>
+                    <p class="text-slate-700 text-sm leading-7">
+                        全ノード数を n とすると、各ノードはキューへの
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">append()</code
+                        >（O(1)）と
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">popleft()</code
+                        >（O(1)）を1回ずつ行うため、 合計操作回数は 2n =
+                        <strong>O(n)</strong> です。 空間については、完全二分木の最下層に最大 n/2
+                        個のノードが集まるため、 キューの最大サイズは O(n) となります。
+                        これは出力配列 result のサイズも同様で、全ノードの値を格納するため O(n)
+                        です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===== GLOSSARY ===== -->
+            <section id="glossary" class="bg-white rounded-3xl p-8 mb-8 shadow-lg">
+                <h2
+                    class="outfit text-3xl font-bold text-cyan-700 mb-3 pb-3 border-b-4 border-emerald-200"
+                >
+                    📖 用語集
+                </h2>
+                <p class="text-slate-500 text-sm mb-6">
+                    このページで登場した専門用語をまとめました。分からない言葉が出てきたときに参照してください。
+                </p>
+                <div class="space-y-2">
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> BFS（幅優先探索）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Breadth-First Search
+                            の略。グラフや木を「横方向に広がりながら」探索する方法。
+                            同じ深さのノードをすべて処理してから次の深さへ進む。
+                            「エレベーターで同じ階を全部回ってから次の階へ行く」イメージ。
+                            この問題では「同じ階層のノードをまとめる」処理と自然に一致するため選ばれる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> Big-O 記法
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            アルゴリズムの「入力サイズが大きくなるにつれて処理時間やメモリがどう増えるか」を表す記法。
+                            O(1) は常に一定、O(n) は入力に比例、O(n²) は入力の2乗で増加する。
+                            実際の秒数ではなく「増え方の傾向」を表す。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> deque（デック）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            のこと。 Doubly-Ended Queue（両端キュー）の略。前からも後ろからも O(1)
+                            で出し入れできる「両端開きの箱」。 Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list</code>
+                            の先頭削除は O(n) だが、 deque の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">popleft()</code> は
+                            O(1)。 C言語で実装されており高速。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> falsy（フォールシー）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">if</code>
+                            の条件式で
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">False</code>
+                            相当と見なされる値。
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">0</code>、<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >None</code
+                            >、<code class="bg-slate-100 px-1 rounded mono text-xs">[]</code>、<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >""</code
+                            >
+                            などが該当する。 ノードの値
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">val = 0</code> は
+                            falsy なので、
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">0 or 式</code>
+                            という書き方は「0のとき右辺を実行する」という誤動作を引き起こす。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> FIFO（先入れ先出し）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            First In, First Out の略。最初に入れたものを最初に取り出す順序。
+                            銀行の窓口の行列と同じ仕組み。キューはこの性質を持つ。 BFS
+                            はこの性質を利用して「深さが浅いノードから順番に処理する」を実現する。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> キュー（Queue）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            先に入れたものを先に取り出す（FIFO）データ構造。
+                            銀行の窓口の行列と同じ。 BFS
+                            では「処理待ちのノード」をキューに積み、先頭から順番に処理することで
+                            「浅い順」に探索できる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span>
+                            level_size（階層サイズの固定）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            BFS の while ループの各反復の開始時に
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >level_size = len(queue)</code
+                            >
+                            で 「今の階のノード数」を変数に保存するテクニック。 ループ中に子の追加で
+                            queue の長さが変化するため、先に固定しないと
+                            「今の階」と「次の階」の境界が混在して Wrong Answer になる。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> 二分木（Binary Tree）
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            各ノードが「左の子」と「右の子」の最大2つを持つ木構造のデータ。
+                            木の頂点を「根（root）」と呼び、子を持たないノードを「葉（leaf）」と呼ぶ。
+                            根からあるノードまでの辺の数を「深さ（depth）」と呼ぶ。根の深さは 0。
+                        </div>
+                    </details>
+
+                    <details class="rounded-2xl border border-slate-200 overflow-hidden">
+                        <summary
+                            class="font-bold text-teal-800 cursor-pointer px-5 py-4 bg-slate-50 hover:bg-emerald-50 transition flex items-center gap-2"
+                        >
+                            <span class="arrow text-emerald-500">▶</span> popleft()
+                        </summary>
+                        <div
+                            class="px-5 py-4 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">deque</code>
+                            の先頭要素を O(1) で取り出すメソッド。
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list.pop(0)</code>
+                            は残り全要素を前にシフトするため O(n) かかるが、
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >deque.popleft()</code
+                            >
+                            は双方向連結リストの先頭ポインタを1つ進めるだけなので O(1)。 n=2000
+                            のとき、この差は 2000 回 vs 最大 4,000,000 回の操作差になる。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center text-slate-400 text-xs py-4 pb-8">
+                LeetCode #102 · Binary Tree Level Order Traversal · Python BFS 解説
+            </footer>
+        </div>
+
+        <!-- ===== MERMAID プログラマティックレンダリング =====
+  設計方針:
+  ① ダイアグラムを JS テンプレートリテラルで保持
+     → ブラウザの HTML パーサーをバイパスするため、
+       HTML エンティティ(&#40; 等)や `<` のエスケープが不要
+  ② mermaid.render() で SVG に変換 → innerHTML に注入
+     → <div class="mermaid"> の startOnLoad に依存しない
+  ③ htmlLabels:true により <br/> がラベル内で改行として機能
+===== -->
+        <script>
+            mermaid.initialize({
+                startOnLoad: false, // 手動で render() を呼ぶため false
+                theme: 'base',
+                flowchart: {
+                    useMaxWidth: true,
+                    htmlLabels: true, // <br/> を改行として扱う
+                    curve: 'basis',
+                    padding: 20,
+                    nodeSpacing: 50,
+                    rankSpacing: 55,
+                },
+                themeVariables: {
+                    primaryColor: '#dbeafe',
+                    primaryTextColor: '#1e3a5f',
+                    primaryBorderColor: '#2563eb',
+                    lineColor: '#64748b',
+                    secondaryColor: '#d1fae5',
+                    secondaryBorderColor: '#059669',
+                    tertiaryColor: '#fef3c7',
+                    tertiaryBorderColor: '#d97706',
+                    edgeLabelBackground: '#ffffff',
+                },
+            });
+
+            // ──────────────────────────────────────────────
+            // ダイアグラム定義（純粋な JS 文字列）
+            // ・<  →  そのまま書ける（HTML パーサーを経由しない）
+            // ・<br/> → htmlLabels:true でラベル内改行
+            // ・() [] は引用符付きラベル ["..."] 内で安全
+            // ──────────────────────────────────────────────
+            const BFS_DIAGRAM = `flowchart TD
+    S(["Start: levelOrder(root)"])
+    C1{"root is None?"}
+    R1(["return &lbrack;&rbrack;  ✅"])
+    A1["result = &lbrack;&rbrack;<br/>queue = deque(&lbrack;root&rbrack;)"]
+    C2{"queue は空?"}
+    R2(["return result  ✅"])
+    A2["level_size = len(queue)<br/>← 今の階のサイズを固定!<br/>vals = &lbrack;&rbrack;"]
+    C3{"i < level_size ?"}
+    A3["result.append(vals)<br/>→ 今の階が完成！"]
+    A4["node = queue.popleft()"]
+    A5["vals.append(node.val)<br/>※ val=0 も正しく追加"]
+    C4{"node.left あり?"}
+    A6["queue.append(node.left)"]
+    C5{"node.right あり?"}
+    A7["queue.append(node.right)"]
+    A8["i + 1 → for ループへ"]
+
+    S --> C1
+    C1 -- "はい（空ツリー）" --> R1
+    C1 -- "いいえ" --> A1
+    A1 --> C2
+    C2 -- "はい（全処理完了）" --> R2
+    C2 -- "いいえ" --> A2
+    A2 --> C3
+    C3 -- "いいえ（この階終了）" --> A3
+    A3 --> C2
+    C3 -- "はい" --> A4
+    A4 --> A5
+    A5 --> C4
+    C4 -- "あり" --> A6
+    C4 -- "なし" --> C5
+    A6 --> C5
+    C5 -- "あり" --> A7
+    C5 -- "なし" --> A8
+    A7 --> A8
+    A8 --> C3
+
+    classDef startEnd fill:#d1fae5,stroke:#059669,stroke-width:2px,color:#064e3b,font-weight:bold
+    classDef process  fill:#dbeafe,stroke:#2563eb,stroke-width:2px,color:#1e3a5f
+    classDef decision fill:#fef3c7,stroke:#d97706,stroke-width:2px,color:#78350f
+    classDef core     fill:#ede9fe,stroke:#7c3aed,stroke-width:2.5px,color:#3b0764,font-weight:bold
+
+    class S,R1,R2 startEnd
+    class A1,A3,A4,A5,A6,A7,A8 process
+    class C1,C2,C3,C4,C5 decision
+    class A2 core`;
+
+            // DOM 構築後にレンダリング
+            document.addEventListener('DOMContentLoaded', async function () {
+                const target = document.getElementById('mermaid-render-target');
+                try {
+                    const { svg } = await mermaid.render('bfs-flowchart-svg', BFS_DIAGRAM);
+                    target.innerHTML = svg;
+                } catch (err) {
+                    console.error('[Mermaid] render error:', err);
+                    target.innerHTML =
+                        '<p style="color:#dc2626;padding:16px;font-size:13px;">' +
+                        '⚠️ フローチャートの描画に失敗しました。コンソールを確認してください。</p>';
+                }
+            });
+        </script>
+
+        <!-- ===== REACT STEPS ===== -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空ツリーのチェック',
+                    desc:
+                        'root が None（空ツリー）かどうかを確認し、空なら即座に [] を返します。' +
+                        'なぜなら、None に対して .val や .left などにアクセスすると実行時エラーになるためです。' +
+                        '例）root=None → if root is None → return [] でここで終了。',
+                    visual: 'check_none',
+                    queue: [],
+                    result: [],
+                    level: -1,
+                },
+                {
+                    step: 2,
+                    title: 'result と queue を初期化',
+                    desc:
+                        '結果格納用の2次元リスト result=[] と、BFS用のキュー queue=deque([root]) を用意します。' +
+                        'deque を使う理由は popleft() が O(1) のため。list.pop(0) は O(n) になり遅くなります。' +
+                        '例）root=Node(3) → queue = deque([Node(3)])',
+                    visual: 'init',
+                    queue: ['Node(3)'],
+                    result: [],
+                    level: 0,
+                },
+                {
+                    step: 3,
+                    title: 'level_size を固定する（BFS の核心）',
+                    desc:
+                        'while ループの先頭で level_size = len(queue) を変数に保存します。' +
+                        'この値が「今の階のノード数」です。ループ中に queue が変化するため、先に固定しないとズレます。' +
+                        '例）queue = [Node(9), Node(20)] → level_size = 2 に固定',
+                    visual: 'fix_size',
+                    queue: ['Node(9)', 'Node(20)'],
+                    result: [['Node(3).val=3']],
+                    level: 1,
+                },
+                {
+                    step: 4,
+                    title: 'popleft() でノードを取り出す',
+                    desc:
+                        'queue.popleft() でキューの先頭ノードを O(1) で取り出し、その val を vals に追加します。' +
+                        'val が 0 のときも正しく追加されます（or トリックは val=0 で壊れるため使いません）。' +
+                        '例）popleft() → Node(9), vals.append(9) → vals=[9]',
+                    visual: 'popleft',
+                    queue: ['Node(20)'],
+                    result: [['3']],
+                    level: 1,
+                    vals: ['9'],
+                },
+                {
+                    step: 5,
+                    title: '子ノードをキューに追加する',
+                    desc:
+                        '取り出したノードの left / right が None でない場合、キューの末尾に追加します（次の階の準備）。' +
+                        'is not None でチェックすることで、キューに None が混入するのを防ぎます。' +
+                        '例）Node(20).left=Node(15) → queue.append(Node(15))',
+                    visual: 'push_children',
+                    queue: ['Node(20)', 'Node(15)', 'Node(7)'],
+                    result: [['3']],
+                    level: 1,
+                    vals: ['9'],
+                },
+                {
+                    step: 6,
+                    title: '今の階の値リストを result に追加',
+                    desc:
+                        'level_size 個分のノードを処理し終えたら vals を result に追加します。' +
+                        'これで「1つの階層分」の処理が完了し、次の while ループで次の階層へ進みます。' +
+                        '例）vals=[9,20] → result.append([9,20]) → result=[[3],[9,20]]',
+                    visual: 'append_level',
+                    queue: ['Node(15)', 'Node(7)'],
+                    result: [['3'], ['9', '20']],
+                    level: 2,
+                },
+            ];
+
+            function QueueViz({ items, highlight }) {
+                return (
+                    <div className="flex flex-wrap gap-2 items-center">
+                        <span className="text-xs text-slate-500 font-semibold mono">queue:</span>
+                        <span className="text-xs text-slate-400">[</span>
+                        {items.length === 0 && (
+                            <span className="text-xs text-slate-400 italic">空</span>
+                        )}
+                        {items.map((item, i) => (
+                            <span
+                                key={i}
+                                className={[
+                                    'mono text-xs px-2 py-1 rounded-lg font-bold border',
+                                    i === 0 && highlight
+                                        ? 'bg-emerald-200 border-emerald-500 text-emerald-800'
+                                        : 'bg-sky-100 border-sky-300 text-sky-800',
+                                ].join(' ')}
+                            >
+                                {item}
+                            </span>
+                        ))}
+                        <span className="text-xs text-slate-400">]</span>
+                    </div>
+                );
+            }
+
+            function ResultViz({ result }) {
+                return (
+                    <div className="flex flex-wrap gap-2 items-start">
+                        <span className="text-xs text-slate-500 font-semibold mono mt-1">
+                            result:
+                        </span>
+                        <span className="text-xs text-slate-400 mt-1">[</span>
+                        {result.length === 0 && (
+                            <span className="text-xs text-slate-400 italic mt-1">空</span>
+                        )}
+                        {result.map((level, i) => (
+                            <span
+                                key={i}
+                                className="mono text-xs px-2 py-1 rounded-lg bg-violet-100 border border-violet-300 text-violet-800 font-bold"
+                            >
+                                [{level.join(', ')}]
+                            </span>
+                        ))}
+                        <span className="text-xs text-slate-400 mt-1">]</span>
+                    </div>
+                );
+            }
+
+            function TreeViz({ highlightLevel }) {
+                const nodes = [
+                    { id: 0, val: 3, x: 200, y: 30, depth: 0 },
+                    { id: 1, val: 9, x: 100, y: 100, depth: 1 },
+                    { id: 2, val: 20, x: 300, y: 100, depth: 1 },
+                    { id: 3, val: 15, x: 220, y: 170, depth: 2 },
+                    { id: 4, val: 7, x: 380, y: 170, depth: 2 },
+                ];
+                const edges = [
+                    [0, 1],
+                    [0, 2],
+                    [2, 3],
+                    [2, 4],
+                ];
+                const colors = ['#d1fae5', '#bfdbfe', '#ede9fe'];
+                const borders = ['#059669', '#0284c7', '#7c3aed'];
+                return (
+                    <svg
+                        viewBox="0 0 460 210"
+                        style={{ width: '100%', maxWidth: '420px', height: 'auto' }}
+                    >
+                        {edges.map(([a, b], i) => (
+                            <line
+                                key={i}
+                                x1={nodes[a].x}
+                                y1={nodes[a].y + 16}
+                                x2={nodes[b].x}
+                                y2={nodes[b].y - 16}
+                                stroke="#cbd5e1"
+                                strokeWidth="2"
+                            />
+                        ))}
+                        {nodes.map((n) => (
+                            <g key={n.id}>
+                                <circle
+                                    cx={n.x}
+                                    cy={n.y}
+                                    r="22"
+                                    fill={highlightLevel === n.depth ? colors[n.depth] : '#f8fafc'}
+                                    stroke={
+                                        highlightLevel === n.depth ? borders[n.depth] : '#cbd5e1'
+                                    }
+                                    strokeWidth={highlightLevel === n.depth ? '3' : '1.5'}
+                                />
+                                <text
+                                    x={n.x}
+                                    y={n.y + 5}
+                                    textAnchor="middle"
+                                    fontSize="15"
+                                    fill={highlightLevel === n.depth ? '#1e293b' : '#94a3b8'}
+                                    fontWeight={highlightLevel === n.depth ? 'bold' : 'normal'}
+                                    fontFamily="JetBrains Mono"
+                                >
+                                    {n.val}
+                                </text>
+                            </g>
+                        ))}
+                        {[0, 1, 2].map((d) => (
+                            <text
+                                key={d}
+                                x="10"
+                                y={d === 0 ? 35 : d === 1 ? 105 : 175}
+                                fontSize="10"
+                                fill="#94a3b8"
+                                fontFamily="Noto Sans JP"
+                            >
+                                深さ{d}
+                            </text>
+                        ))}
+                    </svg>
+                );
+            }
+
+            function StepVisualization({ stepData }) {
+                if (!stepData) return null;
+                const { visual, queue, result, level, vals } = stepData;
+                return (
+                    <div className="mt-4 space-y-3">
+                        <div className="flex justify-center">
+                            <TreeViz highlightLevel={level} />
+                        </div>
+                        <div className="p-4 rounded-2xl bg-slate-50 border border-slate-200 mono text-xs space-y-2">
+                            <div className="text-slate-500 font-sans text-xs font-bold mb-2">
+                                🔍 現在の変数の状態
+                            </div>
+                            <QueueViz items={queue || []} highlight={visual === 'popleft'} />
+                            {vals && (
+                                <div className="flex flex-wrap gap-2 items-center">
+                                    <span className="text-xs text-slate-500 font-semibold">
+                                        vals:
+                                    </span>
+                                    <span className="text-xs text-amber-700 font-bold">
+                                        [{vals.join(', ')}]
+                                    </span>
+                                </div>
+                            )}
+                            <ResultViz result={result || []} />
+                            {level >= 0 && (
+                                <div className="text-xs text-violet-600 font-semibold">
+                                    現在処理中の深さ: {level === -1 ? '—' : level}
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            function StepsApp() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+                const currentStepData = stepsData[activeStep - 1];
+
+                const handlePlay = () => setIsPlaying(true);
+
+                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-6 mt-2">
+                        <div>
+                            <h3 className="mt-0 mb-3 text-teal-800 text-lg font-bold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-sm rounded-2xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'border-emerald-500 shadow-lg'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-300 hover:translate-x-1',
+                                            ].join(' ')}
+                                            style={
+                                                isActive
+                                                    ? {
+                                                          background:
+                                                              'linear-gradient(135deg,#d1fae5,#a7f3d0)',
+                                                      }
+                                                    : {}
+                                            }
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold text-sm mb-0.5',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}: {step.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs">
+                                                {step.desc.substring(0, 48)}…
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        <div>
+                            {activeStep > 1 && (
+                                <div className="mb-3 px-4 py-2 rounded-xl bg-slate-100 border border-slate-200 text-xs text-slate-500">
+                                    ← 前のステップ（Step {activeStep - 1}）では「
+                                    {stepsData[activeStep - 2]?.title}」を行いました
+                                </div>
+                            )}
+                            <div
+                                className="rounded-2xl p-5 border-2 border-emerald-200"
+                                style={{ background: 'linear-gradient(135deg,#ecfdf5,#f0f9ff)' }}
+                            >
+                                <h3 className="mt-0 text-teal-800 text-lg font-bold">
+                                    Step {currentStepData.step}: {currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+                            <StepVisualization stepData={currentStepData} />
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#10b981,#059669)',
+                                    }}
+                                    onClick={handlePlay}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-5 py-2.5 rounded-xl font-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#0ea5e9,#0284c7)',
+                                    }}
+                                    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-bold text-white transition disabled:opacity-40 shadow hover:-translate-y-0.5 text-sm"
+                                    style={{
+                                        background: 'linear-gradient(135deg,#0ea5e9,#0284c7)',
+                                    }}
+                                    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-bold 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-4 rounded-2xl bg-emerald-50 border border-emerald-300 text-emerald-800 text-sm text-center">
+                                    🎉
+                                    全ステップ完了！下の「コード」セクションで実際の実装を確認してみましょう。
+                                </div>
+                            )}
+                        </div>
+                    </div>
+                );
+            }
+
+            const root = ReactDOM.createRoot(document.getElementById('steps-root'));
+            root.render(<StepsApp />);
+
+            setTimeout(() => {
+                document.querySelectorAll('pre code.language-python').forEach((el) => {
+                    Prism.highlightElement(el);
+                });
+            }, 300);
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/README_React.html b/public/Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/README_React.html
new file mode 100644
index 0000000..2bc4a17
--- /dev/null
+++ b/public/Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order Traversal/claude sonnet 4.6 extended/README_React.html	
@@ -0,0 +1,1809 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>LeetCode 103 – Binary Tree Zigzag Level Order Traversal</title>
+
+        <!-- Google Fonts -->
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;600&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+
+        <!-- Tailwind CSS -->
+        <script src="/vendor/tailwindcss/script.js"></script>
+
+        <!-- React 18 -->
+        <script src="/vendor/react/react.development.js"></script>
+        <script src="/vendor/react-dom/react-dom.development.js"></script>
+
+        <!-- Babel Standalone -->
+        <script src="/vendor/babel/babel.min.js"></script>
+
+        <!-- Prism.js -->
+        <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"
+        />
+        <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>
+
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+
+            /* Prism toolbar */
+            .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;
+            }
+
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+
+            @keyframes fadeInUp {
+                from {
+                    opacity: 0;
+                    transform: translateY(16px);
+                }
+                to {
+                    opacity: 1;
+                    transform: translateY(0);
+                }
+            }
+            .fade-in-up {
+                animation: fadeInUp 0.5s ease both;
+            }
+
+            @keyframes pulse-border {
+                0%,
+                100% {
+                    box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.4);
+                }
+                50% {
+                    box-shadow: 0 0 0 6px rgba(16, 185, 129, 0);
+                }
+            }
+            .active-step {
+                animation: pulse-border 1.8s ease infinite;
+            }
+        </style>
+    </head>
+
+    <body class="bg-[linear-gradient(135deg,#f0fdf4_0%,#e0f2fe_100%)] min-h-screen">
+        <div class="max-w-5xl mx-auto px-4 py-10">
+            <!-- ═══════════════════════════════════════════════════════════
+       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)] fade-in-up"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >LeetCode 103</span
+                    >
+                    <span
+                        class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Medium</span
+                    >
+                    <span
+                        class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >BFS</span
+                    >
+                </div>
+
+                <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Binary Tree Zigzag Level Order Traversal
+                </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"
+                >
+                    💡 一言で言うと：「二分木を階層ごとに、偶数階層は左→右・奇数階層は右→左と
+                    <strong>交互にジグザグ</strong> で値を収集する問題」
+                </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>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       1. OVERVIEW
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow fade-in-up">
+                <h2
+                    class="outfit 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">
+                        💡
+                        この問題を一言で言うと：「二分木を<strong>階層ごと</strong>に読み取り、1階層おきに読む向きを反転させる問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2 leading-6">
+                        木の各階層（レベル）をキュー（待ち行列）で順番に処理し、偶数番目の階層は左→右、奇数番目の階層は右→左の順で値を収集します。
+                        最終的に各階層の値リストを2次元配列として返します。
+                    </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 leading-6">
+                        <li>
+                            「木を階層ごとに読む（BFS）」は典型的な手法ですが、<strong>偶数・奇数階層で読む向きを変える</strong>という追加条件をどこで処理するかがポイントです。
+                        </li>
+                        <li>
+                            階層の境界を正確に管理しないと、「今の階層」と「次の階層」のノードが混在してしまいます。<code
+                                class="bg-amber-100 px-1 rounded mono text-xs"
+                                >level_size</code
+                            >
+                            を事前に固定するのが鍵です。
+                        </li>
+                        <li>
+                            Pythonでは <strong>キューの実装の選び方</strong>（<code
+                                class="bg-amber-100 px-1 rounded mono text-xs"
+                                >list</code
+                            >
+                            か
+                            <code class="bg-amber-100 px-1 rounded mono text-xs">deque</code>
+                            か）がパフォーマンスに直結します。
+                        </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-base 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-base font-mono">O(n)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            collections.deque
+                        </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">
+                            0 ≤ n ≤ 2000
+                        </div>
+                        <div class="text-xs mt-1">ノード数制約</div>
+                    </div>
+                </div>
+
+                <!-- 入出力例 -->
+                <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-5">
+                    <!-- Example 1 -->
+                    <div class="rounded-xl border-2 border-emerald-200 p-4 bg-emerald-50">
+                        <p class="text-emerald-700 font-bold text-sm mb-2">例 1</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[3,9,20,null,null,15,7]</div>
+                            <div>出力：[[3],[20,9],[15,7]]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            階層0→[3]（左→右）、階層1→[20,9]（右→左に反転）、階層2→[15,7]（左→右）
+                        </p>
+                    </div>
+                    <!-- Example 2 -->
+                    <div class="rounded-xl border-2 border-sky-200 p-4 bg-sky-50">
+                        <p class="text-sky-700 font-bold text-sm mb-2">例 2</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[1]</div>
+                            <div>出力：[[1]]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            ノードが1つだけなので、そのまま[[1]]を返す。
+                        </p>
+                    </div>
+                    <!-- Example 3 -->
+                    <div class="rounded-xl border-2 border-slate-200 p-4 bg-slate-50">
+                        <p class="text-slate-600 font-bold text-sm mb-2">例 3</p>
+                        <div class="mono text-xs text-slate-700 leading-6">
+                            <div>入力：[]（空ツリー）</div>
+                            <div>出力：[]</div>
+                        </div>
+                        <p class="text-slate-500 text-xs mt-2 leading-5">
+                            ガード節（root is None）で即座に空リストを返す。
+                        </p>
+                    </div>
+                </div>
+
+                <!-- 制約 -->
+                <div
+                    class="p-4 rounded-xl bg-slate-50 border border-slate-200 text-sm text-slate-700"
+                >
+                    <p class="font-semibold mb-2 text-slate-600">📌 制約</p>
+                    <ul class="list-disc list-inside space-y-1 text-xs leading-6">
+                        <li>ノード数：0 以上 2000 以下</li>
+                        <li>ノードの値：−100 以上 100 以下</li>
+                        <li>
+                            <code class="bg-slate-200 px-1 rounded mono">root</code> は
+                            <code class="bg-slate-200 px-1 rounded mono">None</code>
+                            の場合あり（空ツリー）
+                        </li>
+                    </ul>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       2. STEPS (React)
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit 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>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       3. CODE
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit 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 leading-7">
+                        <li>
+                            空ツリーのガード節 —
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >root is None</code
+                            >
+                            なら即
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs">[]</code> を返す
+                        </li>
+                        <li>
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            にルートノードを入れてキューを初期化する
+                        </li>
+                        <li>
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs"
+                                >while queue:</code
+                            >
+                            で階層ループ —
+                            <code class="bg-emerald-100 px-1 rounded mono text-xs">level_size</code>
+                            を固定してから内側ループへ
+                        </li>
+                        <li>
+                            内側ループで値を収集し、子ノードをキューに追加。ループ後に偶奇判定で逆順にして結果へ追加する
+                        </li>
+                    </ol>
+                </div>
+
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+from collections import deque
+
+if TYPE_CHECKING:
+    class TreeNode:
+        val: int
+        left: Optional[TreeNode]
+        right: Optional[TreeNode]
+        def __init__(self, val=0, left=None, right=None) -&gt; None: ...
+
+
+class Solution:
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -&gt; list[list[int]]:
+        # ── ガード節 ──────────────────────────────────────────────
+        # root が None（空ツリー）なら即座に空リストを返す。
+        # 後続処理で node.val へアクセスして AttributeError が起きるのを防ぐ。
+        if root is None:
+            return []
+
+        result: list[list[int]] = []
+
+        # ── deque（両端キュー）の初期化 ───────────────────────────
+        # list.pop(0) は O(n)、deque.popleft() は O(1)。
+        # 全ノード分繰り返すと list では O(n²) になってしまう。
+        queue: deque[TreeNode] = deque([root])
+
+        # ── BFS メインループ ──────────────────────────────────────
+        while queue:
+            # 「今の階層のノード数」をここで固定する。
+            # ループ中に子ノードをキューへ追加するため、固定しないと
+            # 今の階層と次の階層の境界が崩れてしまう。
+            level_size: int = len(queue)
+            level_values: list[int] = []
+
+            for _ in range(level_size):
+                # deque の先頭から O(1) で取り出す
+                node: TreeNode = queue.popleft()
+                level_values.append(node.val)
+
+                if node.left is not None:
+                    queue.append(node.left)
+                if node.right is not None:
+                    queue.append(node.right)
+
+            # ── ジグザグ処理（偶奇による方向切り替え）──────────────
+            # len(result) == 「完了済み階層数」 == 「現在の階層番号」
+            #   偶数（0,2,4…）→ 左→右（そのまま追加）
+            #   奇数（1,3,5…）→ 右→左（in-place で逆順にする）
+            # list.reverse() は新しいリストを作らない in-place 操作なので
+            # [::-1] よりメモリ効率・速度ともに優れる。
+            if len(result) % 2 == 1:
+                level_values.reverse()
+
+            result.append(level_values)
+
+        return result</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 mono leading-6 overflow-x-auto whitespace-pre"
+                    >
+初期状態:
+  queue  = deque([Node(3)])
+  result = []
+
+─ 階層 0（len(result)=0 → 偶数 → そのまま）─────────────────
+  level_size = 1
+  popleft() → Node(3) → level_values = [3]
+    └ Node(9) と Node(20) をキューへ追加
+  0 % 2 == 0 → reverse しない
+  result = [[3]]   queue = deque([Node(9), Node(20)])
+
+─ 階層 1（len(result)=1 → 奇数 → 逆順）──────────────────────
+  level_size = 2
+  popleft() → Node(9)  → level_values = [9]       （子なし）
+  popleft() → Node(20) → level_values = [9, 20]
+    └ Node(15) と Node(7) をキューへ追加
+  1 % 2 == 1 → reverse() → level_values = [20, 9]
+  result = [[3],[20,9]]   queue = deque([Node(15), Node(7)])
+
+─ 階層 2（len(result)=2 → 偶数 → そのまま）─────────────────
+  level_size = 2
+  popleft() → Node(15) → level_values = [15]      （子なし）
+  popleft() → Node(7)  → level_values = [15, 7]   （子なし）
+  2 % 2 == 0 → reverse しない
+  result = [[3],[20,9],[15,7]]   queue = deque([]) ← 空
+
+while queue: → False → ループ終了
+最終出力: [[3], [20, 9], [15, 7]] ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       4. DIAGRAM (Mermaid)
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit 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">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-full bg-emerald-100 border-2 border-emerald-500 text-[10px] text-emerald-800 font-bold whitespace-nowrap"
+                                >開始</span
+                            >
+                            <span>丸角（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-lg bg-sky-100 border-2 border-sky-400 text-[10px] text-sky-900 whitespace-nowrap"
+                                >処理</span
+                            >
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <span
+                                class="inline-block px-2 py-0.5 rounded-lg bg-amber-100 border-2 border-amber-400 text-[10px] text-amber-900 whitespace-nowrap"
+                                >◆ 条件</span
+                            >
+                            <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 mr-1"></span
+                            ><span class="mr-3">緑＝はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-400 mr-1"></span
+                            ><span>赤＝いいえ</span>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- React-rendered CSS Flowchart -->
+                <div id="diagram-root-fc"></div>
+
+                <!-- フロー追跡 -->
+                <div class="mt-6 p-4 rounded-xl bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 font-semibold text-sm mb-3">
+                        🔎 入力例 [3,9,20,null,null,15,7] でのフロー追跡
+                    </p>
+                    <ol class="text-slate-600 text-sm space-y-2 list-decimal list-inside leading-7">
+                        <li>① 開始 → root は None でないので ② の「いいえ」経路へ</li>
+                        <li>③ 初期化：result=[]、queue=deque([Node(3)]) をセット</li>
+                        <li>④ while queue → キューに Node(3) があるので「はい」へ</li>
+                        <li>⑤ level_size=1 に固定。level_values=[] を用意</li>
+                        <li>
+                            ⑥ for ループ：Node(3) を popleft → level_values=[3]。Node(9)・Node(20)
+                            をキューへ追加。ループ終了
+                        </li>
+                        <li>
+                            ⑧ len(result)=0（偶数）→「いいえ」→ reverse せずそのまま append →
+                            result=[[3]]。④ に戻る
+                        </li>
+                        <li>
+                            ④ while → Node(9)・Node(20) あり。⑤ level_size=2。⑥ 両ノード処理 →
+                            level_values=[9,20]。Node(15)・Node(7) をキューへ
+                        </li>
+                        <li>
+                            ⑧ len(result)=1（奇数）→「はい」→ reverse() → level_values=[20,9] →
+                            append → result=[[3],[20,9]]
+                        </li>
+                        <li>
+                            同様に階層2を処理：level_values=[15,7]、len(result)=2（偶数）→ そのまま
+                            append → result=[[3],[20,9],[15,7]]
+                        </li>
+                        <li>
+                            ④ while → キューが空 →「いいえ」→ ⑨
+                            <code class="bg-slate-200 px-1 rounded mono text-xs"
+                                >return [[3],[20,9],[15,7]]</code
+                            >
+                            ✅
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       5. COMPLEXITY
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <!-- Big-O 早見表 -->
+                <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 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 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 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 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-5">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]">
+                                <th class="text-left p-3 rounded-tl-xl font-bold text-teal-800">
+                                    種別
+                                </th>
+                                <th class="text-left p-3 font-bold text-teal-800">計算量</th>
+                                <th class="text-left p-3 rounded-tr-xl font-bold text-teal-800">
+                                    理由
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-b border-slate-100">
+                                <td class="p-3 font-semibold text-slate-700">時間計算量</td>
+                                <td class="p-3">
+                                    <span
+                                        class="mono font-bold text-emerald-700 bg-emerald-50 px-2 py-1 rounded"
+                                        >O(n)</span
+                                    >
+                                </td>
+                                <td class="p-3 text-slate-600">
+                                    全ノードを一度だけ訪問する。<code
+                                        class="bg-slate-100 px-1 rounded mono text-xs"
+                                        >reverse()</code
+                                    >
+                                    は各階層サイズ k に対して O(k) だが、全階層を合計すると O(n)
+                                </td>
+                            </tr>
+                            <tr class="border-b border-slate-100 bg-slate-50/50">
+                                <td class="p-3 font-semibold text-slate-700">空間計算量</td>
+                                <td class="p-3">
+                                    <span
+                                        class="mono font-bold text-sky-700 bg-sky-50 px-2 py-1 rounded"
+                                        >O(n)</span
+                                    >
+                                </td>
+                                <td class="p-3 text-slate-600">
+                                    deque
+                                    は最大で最も幅の広い階層のノード数を格納する。完全二分木では最大
+                                    n/2 ノード。result リストも最終的に n ノード分を格納する
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <!-- in-place vs Pure 比較 -->
+                <div class="mb-5 overflow-x-auto">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-slate-100">
+                                <th class="text-left p-3 font-bold text-slate-700">操作</th>
+                                <th class="text-left p-3 font-bold text-slate-700">コード</th>
+                                <th class="text-left p-3 font-bold text-slate-700">追加メモリ</th>
+                                <th class="text-left p-3 font-bold text-slate-700">速度</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-b border-slate-100 bg-emerald-50">
+                                <td class="p-3 font-semibold text-emerald-700">
+                                    ✅ in-place（採用）
+                                </td>
+                                <td class="p-3 mono text-xs">level.reverse()</td>
+                                <td class="p-3 text-slate-600">O(1)（なし）</td>
+                                <td class="p-3 text-slate-600">高速（C実装）</td>
+                            </tr>
+                            <tr class="border-b border-slate-100">
+                                <td class="p-3 font-semibold text-slate-500">❌ Pure（不採用）</td>
+                                <td class="p-3 mono text-xs">level[::-1]</td>
+                                <td class="p-3 text-slate-600">O(k)（新リスト生成）</td>
+                                <td class="p-3 text-slate-600">やや低速</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">
+                        BFS
+                        では各ノードをキューから<strong>1回だけ取り出し</strong>、その値を収集して子ノードを追加します。
+                        ノード数を n とすると、popleft・append・level_values.append はすべて O(1)
+                        なので合計 O(n)。
+                        <code class="bg-emerald-100 px-1 rounded mono text-xs">reverse()</code>
+                        は各階層のサイズ k に対して O(k) ですが、
+                        すべての階層のサイズの合計はちょうど n になるため、全体でも O(n)
+                        に収まります。 空間については、deque
+                        に同時に入るノードは「最も幅の広い階層」だけなので最大 O(n/2) = O(n) です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════
+       6. GLOSSARY
+  ══════════════════════════════════════════════════════════════ -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit 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"
+                        >
+                            木やグラフを「階層ごと・横方向に」順番に訪問する探索手法。キュー（待ち行列）を使って実装する。<br />
+                            <span class="text-slate-500">例え話：</span
+                            >マンションの1階を全室確認してから2階へ、2階を全室確認してから3階へ……と進むイメージ。深さ優先（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"
+                        >
+                            Python の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >collections.deque</code
+                            >
+                            が提供するデータ構造。先頭・末尾への追加・取り出しがどちらも
+                            O(1)（一定時間）で行える。<br />
+                            通常の
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">list</code> で
+                            <code class="bg-slate-100 px-1 rounded 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 mono text-xs">return</code>
+                            する書き方。<br />
+                            後続の処理をネストさせずに済み、コードをシンプルに保てる。この問題では
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >if root is None: return []</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> in-place 操作
+                        </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 mono text-xs"
+                                >list.reverse()</code
+                            >
+                            がその代表例。<br />
+                            対比：<code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >list[::-1]</code
+                            >
+                            は新しいリストを生成する（Pure 操作）。in-place
+                            の方が追加メモリを消費しない分、効率的。
+                        </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"
+                        >
+                            アルゴリズムが正しく動くために、処理中ずっと成り立ち続けるべき条件のこと。<br />
+                            この問題では「while ループの先頭で queue
+                            に現在の階層のノードだけが格納されている」ことが不変条件。<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >level_size</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"
+                        >
+                            全ての葉（子を持たないノード）が同じ深さにある最もバランスの取れた二分木。最下層の幅（ノード数）は全ノード数
+                            n の約半分（n/2）になる。<br />
+                            この問題の空間計算量 O(n) を考えるときに参考になる最悪ケース。
+                        </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> キュー（Queue）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            「先に入れたものを先に取り出す」データ構造（FIFO: First In First
+                            Out）。<br />
+                            <span class="text-slate-500">例え話：</span
+                            >コンビニのレジの行列と同じ。先に並んだ人が先に処理される。BFS
+                            では「次に訪問すべきノード」をキューで管理する。
+                        </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"
+                        >
+                            木の最上位にある起点ノード（頂点）。木全体の出発点で、親を持たない唯一のノード。<br />
+                            BFS ではルートノードをキューに入れることで探索を開始する。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <!-- Footer -->
+            <footer class="text-center text-slate-400 text-xs pb-10">
+                LeetCode 103 · Binary Tree Zigzag Level Order Traversal · BFS + 偶奇反転
+            </footer>
+        </div>
+        <!-- /max-w-5xl -->
+
+        <!-- ═══════════════════════════════════════════════════════════
+     REACT STEPS COMPONENT
+══════════════════════════════════════════════════════════════ -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空ツリーのガード節',
+                    desc:
+                        '関数の先頭で root が None かどうかを確認し、空ツリーなら即座に [] を返します。' +
+                        'なぜなら、後続の処理では node.val や node.left などのノード属性にアクセスするため、None のまま進むと AttributeError が発生してしまうからです。' +
+                        '例）root = None のとき → if root is None: return [] でここで処理が終わる。',
+                    visual: 'guard',
+                    queue: '—（処理なし）',
+                    result: '[]',
+                },
+                {
+                    step: 2,
+                    title: 'deque の初期化',
+                    desc:
+                        'collections.deque にルートノードを入れて BFS キューを初期化します。' +
+                        'list.pop(0) は O(n) コストがかかるのに対し、deque.popleft() は常に O(1) で取り出せるため、全ノード数 n 分繰り返すと速度差が大きくなります。' +
+                        '例）root = Node(3) → queue = deque([Node(3)])、result = []',
+                    visual: 'init',
+                    queue: 'deque([Node(3)])',
+                    result: '[]',
+                },
+                {
+                    step: 3,
+                    title: 'level_size を固定する',
+                    desc:
+                        'while ループの先頭で level_size = len(queue) と書き、今の階層にいるノード数を変数に保存します。' +
+                        'ループ中に子ノードをキューへ追加していくため、固定しないと len(queue) が増え続けて「今の階層」と「次の階層」が混在してしまいます。' +
+                        '例）queue = deque([Node(9), Node(20)]) のとき → level_size = 2 で固定。',
+                    visual: 'fix_size',
+                    queue: 'deque([Node(9), Node(20)])',
+                    result: '[[3]]',
+                },
+                {
+                    step: 4,
+                    title: 'popleft() で値を収集',
+                    desc:
+                        'for _ in range(level_size): のループ内で queue.popleft() を呼び、今の階層のノードを順番に取り出して値を収集します。' +
+                        '左・右の子ノードが存在する場合は queue.append() でキューの末尾に追加します（次の階層の処理のため）。' +
+                        '例）popleft() → Node(9)、level_values=[9]。子なし。popleft() → Node(20)、level_values=[9,20]。Node(15)・Node(7) を追加。',
+                    visual: 'collect',
+                    queue: 'deque([Node(15), Node(7)])',
+                    result: '[[3]]（処理中）',
+                },
+                {
+                    step: 5,
+                    title: '偶奇判定でジグザグ反転',
+                    desc:
+                        'len(result) % 2 が 1（奇数）なら level_values.reverse() を呼んで値リストを逆順にします。' +
+                        'len(result) は「すでに完了した階層数」＝「現在処理中の階層番号」と一致するため、別途カウンタ変数を用意する必要がありません。' +
+                        '例）len(result)=1 → 1%2==1 → reverse() → [9,20] が [20,9] に変わる。',
+                    visual: 'reverse',
+                    queue: 'deque([Node(15), Node(7)])',
+                    result: '[[3],[20,9]]',
+                },
+                {
+                    step: 6,
+                    title: 'result.append して次の階層へ',
+                    desc:
+                        '処理済みの level_values を result.append() で追加し、while ループの先頭に戻って次の階層を処理します。' +
+                        'queue が空になったとき（全ノードを処理し終えたとき）while ループを抜け、result を返して終了します。' +
+                        '例）全階層処理後 → result = [[3],[20,9],[15,7]] を return する。',
+                    visual: 'done',
+                    queue: 'deque([])',
+                    result: '[[3],[20,9],[15,7]]',
+                },
+            ];
+
+            // ── 各ステップのビジュアル ─────────────────────────────────────────
+            function StepVisualization({ visual, step }) {
+                const nodeStyle = (color) => ({
+                    display: 'inline-flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: 40,
+                    height: 40,
+                    borderRadius: '50%',
+                    background: color,
+                    color: 'white',
+                    fontWeight: 'bold',
+                    fontSize: 14,
+                    margin: '0 6px',
+                    boxShadow: '0 2px 8px rgba(0,0,0,0.15)',
+                });
+
+                const queueNodes = (labels, colors) => (
+                    <div
+                        style={{ display: 'flex', alignItems: 'center', flexWrap: 'wrap', gap: 4 }}
+                    >
+                        {labels.map((l, i) => (
+                            <div key={i} style={nodeStyle(colors[i] || '#94a3b8')}>
+                                {l}
+                            </div>
+                        ))}
+                        {labels.length === 0 && (
+                            <span style={{ color: '#94a3b8', fontSize: 13 }}>（空）</span>
+                        )}
+                    </div>
+                );
+
+                const panels = {
+                    guard: (
+                        <div>
+                            <svg viewBox="0 0 320 90" style={{ width: '100%', maxWidth: 320 }}>
+                                <rect
+                                    x="10"
+                                    y="10"
+                                    width="140"
+                                    height="70"
+                                    rx="10"
+                                    fill="#fee2e2"
+                                    stroke="#ef4444"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="80"
+                                    y="38"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="13"
+                                    fill="#991b1b"
+                                    fontWeight="bold"
+                                >
+                                    root = None
+                                </text>
+                                <text
+                                    x="80"
+                                    y="60"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#b91c1c"
+                                >
+                                    空ツリー
+                                </text>
+                                <line
+                                    x1="155"
+                                    y1="45"
+                                    x2="195"
+                                    y2="45"
+                                    stroke="#64748b"
+                                    strokeWidth="1.8"
+                                    markerEnd="url(#sv-arrow)"
+                                />
+                                <defs>
+                                    <marker
+                                        id="sv-arrow"
+                                        markerWidth="8"
+                                        markerHeight="8"
+                                        refX="7"
+                                        refY="3"
+                                        orient="auto"
+                                        markerUnits="strokeWidth"
+                                    >
+                                        <path d="M0,0 L0,6 L7,3 z" fill="#64748b" />
+                                    </marker>
+                                </defs>
+                                <rect
+                                    x="198"
+                                    y="25"
+                                    width="105"
+                                    height="40"
+                                    rx="8"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="250"
+                                    y="43"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#065f46"
+                                    fontWeight="bold"
+                                >
+                                    return []
+                                </text>
+                            </svg>
+                        </div>
+                    ),
+                    init: (
+                        <div>
+                            <svg viewBox="0 0 320 100" style={{ width: '100%', maxWidth: 320 }}>
+                                <rect
+                                    x="10"
+                                    y="15"
+                                    width="120"
+                                    height="70"
+                                    rx="10"
+                                    fill="#d1fae5"
+                                    stroke="#059669"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="70"
+                                    y="40"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#065f46"
+                                    fontWeight="bold"
+                                >
+                                    Node(3)
+                                </text>
+                                <text
+                                    x="70"
+                                    y="62"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="11"
+                                    fill="#047857"
+                                >
+                                    ルートノード
+                                </text>
+                                <line
+                                    x1="135"
+                                    y1="50"
+                                    x2="168"
+                                    y2="50"
+                                    stroke="#64748b"
+                                    strokeWidth="1.8"
+                                    markerEnd="url(#sv-arrow2)"
+                                />
+                                <defs>
+                                    <marker
+                                        id="sv-arrow2"
+                                        markerWidth="8"
+                                        markerHeight="8"
+                                        refX="7"
+                                        refY="3"
+                                        orient="auto"
+                                        markerUnits="strokeWidth"
+                                    >
+                                        <path d="M0,0 L0,6 L7,3 z" fill="#64748b" />
+                                    </marker>
+                                </defs>
+                                <rect
+                                    x="170"
+                                    y="15"
+                                    width="140"
+                                    height="70"
+                                    rx="10"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    strokeWidth="2"
+                                />
+                                <text
+                                    x="240"
+                                    y="38"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="12"
+                                    fill="#1e3a5f"
+                                    fontWeight="bold"
+                                >
+                                    deque
+                                </text>
+                                <text
+                                    x="240"
+                                    y="60"
+                                    textAnchor="middle"
+                                    dominantBaseline="middle"
+                                    fontSize="11"
+                                    fill="#1e40af"
+                                >
+                                    [Node(3)]
+                                </text>
+                            </svg>
+                        </div>
+                    ),
+                    fix_size: (
+                        <div>
+                            <div
+                                style={{
+                                    display: 'flex',
+                                    gap: 8,
+                                    flexWrap: 'wrap',
+                                    marginBottom: 8,
+                                }}
+                            >
+                                <span
+                                    style={{
+                                        background: '#e0f2fe',
+                                        color: '#0369a1',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 13,
+                                        fontWeight: 'bold',
+                                        fontFamily: 'monospace',
+                                    }}
+                                >
+                                    level_size = 2
+                                </span>
+                                <span
+                                    style={{
+                                        background: '#f1f5f9',
+                                        color: '#475569',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 13,
+                                        fontFamily: 'monospace',
+                                    }}
+                                >
+                                    level_values = []
+                                </span>
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+                                <span style={{ fontSize: 12, color: '#64748b' }}>queue:</span>
+                                {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                            </div>
+                        </div>
+                    ),
+                    collect: (
+                        <div>
+                            <div style={{ marginBottom: 6, fontSize: 12, color: '#475569' }}>
+                                popleft() 順に値を収集中…
+                            </div>
+                            <div
+                                style={{
+                                    display: 'flex',
+                                    alignItems: 'center',
+                                    gap: 6,
+                                    marginBottom: 6,
+                                }}
+                            >
+                                <span style={{ fontSize: 12, color: '#64748b' }}>
+                                    level_values:
+                                </span>
+                                {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
+                                <span style={{ fontSize: 12, color: '#64748b' }}>次の階層:</span>
+                                {queueNodes([15, 7], ['#10b981', '#0ea5e9'])}
+                            </div>
+                        </div>
+                    ),
+                    reverse: (
+                        <div>
+                            <div style={{ marginBottom: 6 }}>
+                                <span
+                                    style={{
+                                        background: '#fef3c7',
+                                        color: '#92400e',
+                                        borderRadius: 8,
+                                        padding: '3px 10px',
+                                        fontSize: 12,
+                                        fontWeight: 'bold',
+                                    }}
+                                >
+                                    len(result) = 1 → 奇数 → reverse()
+                                </span>
+                            </div>
+                            <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+                                <div style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
+                                    {queueNodes([9, 20], ['#f97316', '#8b5cf6'])}
+                                </div>
+                                <span style={{ fontSize: 18, color: '#10b981' }}>→</span>
+                                <div style={{ display: 'flex', alignItems: 'center', gap: 4 }}>
+                                    {queueNodes([20, 9], ['#8b5cf6', '#f97316'])}
+                                </div>
+                            </div>
+                        </div>
+                    ),
+                    done: (
+                        <div>
+                            <div
+                                style={{
+                                    marginBottom: 6,
+                                    fontSize: 13,
+                                    color: '#065f46',
+                                    fontWeight: 'bold',
+                                }}
+                            >
+                                🎉 全ノード処理完了！
+                            </div>
+                            <div
+                                style={{
+                                    fontFamily: 'monospace',
+                                    fontSize: 12,
+                                    background: '#d1fae5',
+                                    borderRadius: 8,
+                                    padding: '8px 12px',
+                                    color: '#065f46',
+                                }}
+                            >
+                                result = [[3], [20, 9], [15, 7]]
+                            </div>
+                        </div>
+                    ),
+                };
+
+                const info = stepsData[step - 1];
+                return (
+                    <div className="mt-4">
+                        <div className="rounded-xl bg-white border border-emerald-200 p-4">
+                            {panels[visual] || (
+                                <div className="text-slate-400 text-sm">ビジュアルを準備中…</div>
+                            )}
+                        </div>
+                        {/* 変数の状態パネル */}
+                        <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>
+                            <div className="text-sky-700">queue = {info.queue}</div>
+                            <div className="text-emerald-700">result = {info.result}</div>
+                        </div>
+                    </div>
+                );
+            }
+
+            // ── メイン Steps コンポーネント ────────────────────────────────────
+            function StepsSection() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+
+                useEffect(() => {
+                    if (isPlaying) {
+                        timerRef.current = setTimeout(() => {
+                            if (activeStep === stepsData.length) {
+                                setActiveStep(1);
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 2000);
+                    }
+                    return () => {
+                        if (timerRef.current) clearTimeout(timerRef.current);
+                    };
+                }, [isPlaying, activeStep]);
+
+                const currentStepData = stepsData[activeStep - 1];
+
+                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((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-[0.95rem] rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)] active-step'
+                                                    : '',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                            aria-label={`ステップ${step.step}: ${step.title}`}
+                                            aria-current={isActive ? 'step' : undefined}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5 text-sm',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}：{step.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs leading-5">
+                                                {step.desc.substring(0, 48)}…
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* 詳細パネル */}
+                        <div className="my-auto">
+                            {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}（{stepsData[activeStep - 2].title}
+                                    ）の続き
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-6 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)]">
+                                <h3 className="mt-0 text-teal-800 text-lg font-bold">
+                                    Step {currentStepData.step}：{currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <StepVisualization visual={currentStepData.visual} step={activeStep} />
+
+                            {/* コントロール */}
+                            <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-50 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-50 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-50 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(<StepsSection />);
+        </script>
+
+        <script>
+            // Prism re-highlight after page load
+            document.addEventListener('DOMContentLoaded', () => {
+                if (window.Prism) Prism.highlightAll();
+            });
+            setTimeout(() => {
+                if (window.Prism) Prism.highlightAll();
+            }, 800);
+        </script>
+        <script type="text/babel">
+            // ─── Flowchart Component ───────────────────────────────────────────────────
+            const FC = {
+                terminal: {
+                    background: '#d1fae5',
+                    border: '2px solid #059669',
+                    borderRadius: 999,
+                    color: '#065f46',
+                    fontWeight: 'bold',
+                },
+                process: {
+                    background: '#e0f2fe',
+                    border: '2px solid #0284c7',
+                    borderRadius: 12,
+                    color: '#1e3a5f',
+                },
+                decision: {
+                    background: '#fef3c7',
+                    border: '2px solid #d97706',
+                    borderRadius: 12,
+                    color: '#78350f',
+                    fontWeight: '600',
+                },
+                reverse: {
+                    background: '#ede9fe',
+                    border: '2px solid #7c3aed',
+                    borderRadius: 12,
+                    color: '#4c1d95',
+                },
+            };
+
+            const BASE = {
+                padding: '10px 18px',
+                fontSize: 13,
+                textAlign: 'center',
+                lineHeight: 1.7,
+                boxSizing: 'border-box',
+                width: '100%',
+            };
+
+            function Node({ type, children }) {
+                return <div style={{ ...FC[type], ...BASE }}>{children}</div>;
+            }
+
+            function VArr({ label, color = '#64748b' }) {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            flexDirection: 'column',
+                            alignItems: 'center',
+                            margin: '3px 0',
+                        }}
+                    >
+                        {label && (
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color,
+                                    fontWeight: 'bold',
+                                    margin: '2px 0',
+                                    whiteSpace: 'nowrap',
+                                }}
+                            >
+                                {label}
+                            </div>
+                        )}
+                        <div style={{ width: 2, height: 18, background: color }} />
+                        <div
+                            style={{
+                                width: 0,
+                                height: 0,
+                                borderLeft: '6px solid transparent',
+                                borderRight: '6px solid transparent',
+                                borderTop: `8px solid ${color}`,
+                            }}
+                        />
+                    </div>
+                );
+            }
+
+            function HArr({ label, color = '#059669' }) {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            alignItems: 'center',
+                            flexShrink: 0,
+                            margin: '0 4px',
+                        }}
+                    >
+                        <div style={{ height: 2, width: 18, background: color }} />
+                        {label && (
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color,
+                                    fontWeight: 'bold',
+                                    padding: '0 4px',
+                                    whiteSpace: 'nowrap',
+                                }}
+                            >
+                                {label}
+                            </div>
+                        )}
+                        <div style={{ height: 2, width: 10, background: color }} />
+                        <div
+                            style={{
+                                width: 0,
+                                height: 0,
+                                borderTop: '5px solid transparent',
+                                borderBottom: '5px solid transparent',
+                                borderLeft: `7px solid ${color}`,
+                            }}
+                        />
+                    </div>
+                );
+            }
+
+            function FlowChart() {
+                return (
+                    <div
+                        style={{
+                            display: 'flex',
+                            flexDirection: 'column',
+                            alignItems: 'center',
+                            padding: '28px 8px',
+                            gap: 0,
+                            fontFamily: "'Noto Sans JP', sans-serif",
+                        }}
+                    >
+                        {/* ① 開始 */}
+                        <div style={{ width: '100%', maxWidth: 280 }}>
+                            <Node type="terminal">① 開始</Node>
+                        </div>
+                        <VArr />
+
+                        {/* ② root is None? ──はい──> return [] */}
+                        <div
+                            style={{
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                width: '100%',
+                                maxWidth: 560,
+                                gap: 0,
+                            }}
+                        >
+                            <div style={{ flex: '0 0 auto', minWidth: 220, maxWidth: 300 }}>
+                                <Node type="decision">
+                                    ◆ ② <code style={{ fontSize: 12 }}>root is None</code>？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        空ツリーのチェック
+                                    </span>
+                                </Node>
+                            </div>
+                            <HArr label="はい" />
+                            <div style={{ flex: '0 0 auto', minWidth: 90, maxWidth: 130 }}>
+                                <Node type="terminal" style={{ borderRadius: 999 }}>
+                                    <code style={{ fontSize: 12 }}>return []</code>
+                                </Node>
+                            </div>
+                        </div>
+                        <VArr label="いいえ" color="#dc2626" />
+
+                        {/* ③ 初期化 */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="process">
+                                ③ 初期化
+                                <br />
+                                <code style={{ fontSize: 11 }}>result = []</code>
+                                <br />
+                                <code style={{ fontSize: 11 }}>queue = deque([root])</code>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ④ while queue? ──いいえ──> return result */}
+                        <div
+                            style={{
+                                display: 'flex',
+                                alignItems: 'center',
+                                justifyContent: 'center',
+                                width: '100%',
+                                maxWidth: 560,
+                                gap: 0,
+                            }}
+                        >
+                            <div style={{ flex: '0 0 auto', minWidth: 220, maxWidth: 300 }}>
+                                <Node type="decision">
+                                    ◆ ④ <code style={{ fontSize: 12 }}>while queue</code>？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        未処理ノードあり？
+                                    </span>
+                                </Node>
+                            </div>
+                            <HArr label="いいえ" color="#dc2626" />
+                            <div style={{ flex: '0 0 auto', minWidth: 110, maxWidth: 160 }}>
+                                <Node type="terminal">
+                                    ⑨ <code style={{ fontSize: 12 }}>return result</code>
+                                </Node>
+                            </div>
+                        </div>
+                        <VArr label="はい" color="#059669" />
+
+                        {/* ⑤ */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="process">
+                                ⑤ 階層サイズを固定
+                                <br />
+                                <code style={{ fontSize: 11 }}>level_size = len(queue)</code>
+                                <br />
+                                <code style={{ fontSize: 11 }}>level_values = []</code>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ⑥⑦ 内側ループ */}
+                        <div
+                            style={{
+                                border: '2px dashed #a855f7',
+                                borderRadius: 14,
+                                background: '#faf5ff',
+                                padding: '14px 16px',
+                                display: 'flex',
+                                flexDirection: 'column',
+                                alignItems: 'center',
+                                gap: 0,
+                                width: '100%',
+                                maxWidth: 400,
+                                boxSizing: 'border-box',
+                            }}
+                        >
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color: '#7c3aed',
+                                    fontWeight: 'bold',
+                                    marginBottom: 10,
+                                }}
+                            >
+                                🔁 内側ループ（ノードを1つずつ処理）
+                            </div>
+                            <div style={{ width: '100%' }}>
+                                <Node type="decision">
+                                    ◆ ⑥{' '}
+                                    <code style={{ fontSize: 11 }}>for _ in range(level_size)</code>
+                                    ？<br />
+                                    <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                        今の階層にノードが残っている？
+                                    </span>
+                                </Node>
+                            </div>
+                            <VArr label="はい" color="#059669" />
+                            <div style={{ width: '100%' }}>
+                                <Node type="process">
+                                    ⑦ <code style={{ fontSize: 11 }}>node = queue.popleft()</code>
+                                    <br />
+                                    <code style={{ fontSize: 11 }}>
+                                        level_values.append(node.val)
+                                    </code>
+                                    <br />
+                                    <span style={{ fontSize: 11 }}>左・右の子を queue に追加</span>
+                                </Node>
+                            </div>
+                            <div
+                                style={{
+                                    fontSize: 11,
+                                    color: '#a855f7',
+                                    fontWeight: 'bold',
+                                    marginTop: 8,
+                                }}
+                            >
+                                ↩ ⑥ に戻る
+                            </div>
+                        </div>
+                        <VArr label="いいえ（この階層を処理し終えた）" color="#dc2626" />
+
+                        {/* ⑧ */}
+                        <div style={{ width: '100%', maxWidth: 360 }}>
+                            <Node type="decision">
+                                ◆ ⑧ <code style={{ fontSize: 11 }}>len(result) % 2 == 1</code>？
+                                <br />
+                                <span style={{ fontSize: 11, fontWeight: 'normal' }}>
+                                    奇数階層（右→左）？
+                                </span>
+                            </Node>
+                        </div>
+                        <VArr />
+
+                        {/* ⑧ 結果サマリ */}
+                        <div
+                            style={{
+                                background: '#f8fafc',
+                                border: '1px solid #e2e8f0',
+                                borderRadius: 10,
+                                padding: '10px 20px',
+                                fontSize: 12,
+                                color: '#475569',
+                                textAlign: 'center',
+                                lineHeight: 1.9,
+                                width: '100%',
+                                maxWidth: 400,
+                                boxSizing: 'border-box',
+                            }}
+                        >
+                            <span style={{ color: '#059669', fontWeight: 'bold' }}>はい</span>：
+                            <code
+                                style={{
+                                    background: '#ede9fe',
+                                    padding: '1px 6px',
+                                    borderRadius: 4,
+                                    fontSize: 11,
+                                    color: '#4c1d95',
+                                }}
+                            >
+                                level_values.reverse()
+                            </code>
+                            　右→左に反転
+                            <br />
+                            <span style={{ color: '#dc2626', fontWeight: 'bold' }}>いいえ</span>：
+                            そのまま（左→右で OK）
+                        </div>
+                        <VArr />
+
+                        {/* APPEND */}
+                        <div style={{ width: '100%', maxWidth: 320 }}>
+                            <Node type="process">
+                                <code style={{ fontSize: 12 }}>result.append(level_values)</code>
+                                <br />
+                                <span style={{ fontSize: 11 }}>この階層の結果を追記</span>
+                            </Node>
+                        </div>
+                        <div
+                            style={{
+                                fontSize: 11,
+                                color: '#a855f7',
+                                fontWeight: 'bold',
+                                margin: '8px 0',
+                            }}
+                        >
+                            ↩ ④ に戻る（while ループの先頭へ）
+                        </div>
+                    </div>
+                );
+            }
+
+            ReactDOM.createRoot(document.getElementById('diagram-root-fc')).render(<FlowChart />);
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README_React.html b/public/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README_React.html
new file mode 100644
index 0000000..5825193
--- /dev/null
+++ b/public/Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README_React.html	
@@ -0,0 +1,1552 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1.0" />
+        <title>LeetCode 104 · Maximum Depth of Binary Tree</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 rel="preconnect" href="https://fonts.googleapis.com" />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;500;700&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            .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;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            .tree-node {
+                transition: all 0.3s ease;
+            }
+            @keyframes pulse-green {
+                0%,
+                100% {
+                    filter: drop-shadow(0 0 0 rgba(16, 185, 129, 0));
+                }
+                50% {
+                    filter: drop-shadow(0 0 8px rgba(16, 185, 129, 0.6));
+                }
+            }
+            .node-active {
+                animation: pulse-green 1.2s ease-in-out infinite;
+            }
+        </style>
+    </head>
+    <body class="bg-[linear-gradient(135deg,#f0fdf4_0%,#e0f2fe_100%)] min-h-screen">
+        <div class="max-w-5xl mx-auto px-4 py-8">
+            <!-- ═══════════════════════════════════════════════════════════ HEADER -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.14)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]"
+            >
+                <div class="flex items-center gap-3 mb-3">
+                    <span
+                        class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >LeetCode 104</span
+                    >
+                    <span
+                        class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Easy</span
+                    >
+                </div>
+                <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Maximum Depth of Binary Tree
+                </h1>
+                <p class="text-base text-cyan-700 font-semibold mt-1">
+                    再帰 DFS &amp; 反復 BFS による O(n) 実装
+                </p>
+                <p class="mt-3 text-sm 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="outfit 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 leading-7">
+                        二分木（＝各ノードが最大2つの子「左・右」を持つ木構造データ）の根（root）から、
+                        一番遠い葉ノード（＝子を持たない末端ノード）までのノード数を返します。
+                        すべてのノードを1回ずつ訪問しなければならないため、時間計算量の理論限界はO(n)です。
+                    </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-1 list-disc list-inside leading-7">
+                        <li>
+                            木の深さを知るには左右<strong>両方の部分木</strong>をすべて探索しないと「どちらが深いか」が分からない
+                        </li>
+                        <li>
+                            CPython
+                            のデフォルト再帰深度制限（約1000）があるため、一本道の木では単純な再帰が失敗する
+                        </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 break-all leading-tight">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 break-all leading-tight">O(h)</div>
+                        <div class="text-xs mt-1">空間計算量（DFS）</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono break-all leading-tight">O(w)</div>
+                        <div class="text-xs mt-1">空間計算量（BFS）</div>
+                    </div>
+                    <div
+                        style="background: #ede9fe; color: #5b21b6"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-sm font-mono break-all leading-tight">
+                            0〜10,000
+                        </div>
+                        <div class="text-xs mt-1">ノード数</div>
+                    </div>
+                </div>
+
+                <!-- 入出力例 -->
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-4">
+                    <div class="p-4 rounded-xl border border-slate-200 bg-slate-50">
+                        <p class="text-slate-600 text-xs font-bold mb-2 uppercase tracking-wide">
+                            入力例 1
+                        </p>
+                        <pre class="text-xs font-mono text-slate-700 leading-6">
+    3          ← 深さ 1
+   / \
+  9  20        ← 深さ 2
+    /  \
+   15   7      ← 深さ 3 (葉)</pre
+                        >
+                        <p class="mt-2 text-emerald-700 font-semibold text-sm">出力: 3</p>
+                        <p class="text-slate-500 text-xs mt-1">
+                            深さ3まで葉ノードが存在するため、最大深さ=3
+                        </p>
+                    </div>
+                    <div class="p-4 rounded-xl border border-slate-200 bg-slate-50">
+                        <p class="text-slate-600 text-xs font-bold mb-2 uppercase tracking-wide">
+                            入力例 2
+                        </p>
+                        <pre class="text-xs font-mono text-slate-700 leading-6">
+  1            ← 深さ 1
+   \
+    2          ← 深さ 2 (葉)</pre
+                        >
+                        <p class="mt-2 text-emerald-700 font-semibold text-sm">出力: 2</p>
+                        <p class="text-slate-500 text-xs mt-1">
+                            右の子だけが存在し、葉は深さ2にあるため、最大深さ=2
+                        </p>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════ STEPS (React) -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-2 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    入力例1（root=[3,9,20,null,null,15,7]）を使って、BFS反復版の動きを追います。
+                </p>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════ CODE -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <p class="text-slate-600 text-sm mb-4 leading-7">
+                    2つの実装パターンを提供します。
+                    <strong class="text-emerald-700">業務開発版（BFS）</strong
+                    >は再帰深度制限を回避するため本番環境に適しており、
+                    <strong class="text-sky-700">競技プログラミング版（再帰DFS）</strong
+                    >は最もシンプルでコードが短い実装です。
+                </p>
+
+                <!-- 骨格パネル -->
+                <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">
+                        📋 業務開発版（BFS）のコード構造
+                    </p>
+                    <ol class="text-slate-700 text-sm space-y-1 list-decimal list-inside">
+                        <li>root が None（空の木）の場合はすぐ 0 を返す（エッジケース処理）</li>
+                        <li>deque([root]) でキューを初期化し、depth = 0 を設定する</li>
+                        <li>while queue: でキューが空になるまでループする</li>
+                        <li>level_size = len(queue) で現在レベルのノード数を事前記録する</li>
+                        <li>
+                            level_size 回 popleft() を行い、左右の子が存在すればキューへ追加する
+                        </li>
+                        <li>1レベル処理完了ごとに depth += 1 して最終的に depth を返す</li>
+                    </ol>
+                </div>
+
+                <pre
+                    class="line-numbers"
+                ><code class="language-python">from __future__ import annotations
+from typing import Optional
+from collections import deque
+
+# ════════════════════════════════════════════════
+# 業務開発版：反復 BFS（CPython 再帰制限を回避）
+# ════════════════════════════════════════════════
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -&gt; int:
+        # エッジケース：空の木（ノードが1つもない）→ 深さ 0
+        # 後続の deque 処理に None を入れないための早期リターン
+        if root is None:
+            return 0
+
+        # deque を使う理由：
+        #   list.pop(0) は先頭削除が O(n) だが
+        #   deque.popleft() は O(1) で済む
+        queue: deque[TreeNode] = deque([root])
+        depth: int = 0  # 処理したレベルの数 = 深さ
+
+        while queue:
+            # この時点の len(queue) = 今のレベルのノード数
+            # ループ前に固定することで「次のレベルのノードが
+            # append されても影響を受けない」ようにする
+            level_size: int = len(queue)
+
+            for _ in range(level_size):
+                node: TreeNode = queue.popleft()  # O(1)
+
+                # 左・右の子が存在すれば次のレベルとしてキューへ
+                if node.left is not None:
+                    queue.append(node.left)
+                if node.right is not None:
+                    queue.append(node.right)
+
+            # 今のレベルを全部処理し終えた = 1段降りた
+            depth += 1
+
+        return depth
+
+
+# ════════════════════════════════════════════════
+# 競技プログラミング版：再帰 DFS（最もシンプル）
+# ════════════════════════════════════════════════
+class Solution2:
+    def maxDepth(self, root: Optional[TreeNode]) -&gt; int:
+        # ベースケース：None = 存在しないノードの深さは 0
+        # "is None" を使う理由：
+        #   通常のノードオブジェクトはvalの値にかかわらずtruthyですが、
+        #   ノードが存在しない(None)ことを真偽値ではなく明示的に判定するためです。
+        if root is None:
+            return 0
+
+        # max() は C実装の組み込み関数なので if文より高速
+        # 「左の深さ」と「右の深さ」の大きい方 + 現在ノード分(+1)
+        return 1 + max(
+            self.maxDepth(root.left),
+            self.maxDepth(root.right),
+        )</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">
+                        ▶ 入力例1 [3,9,20,null,null,15,7] での動作トレース（BFS版）
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-6 overflow-x-auto whitespace-pre"
+                    >
+初期状態: queue=deque([Node(3)]), depth=0
+
+【レベル1】level_size=1
+  popleft() → Node(3)
+    left=Node(9)   → append → queue=[Node(9)]
+    right=Node(20) → append → queue=[Node(9),Node(20)]
+  depth=1
+
+【レベル2】level_size=2
+  popleft() → Node(9)
+    left=None, right=None → 追加なし
+  popleft() → Node(20)
+    left=Node(15) → append → queue=[Node(15)]
+    right=Node(7) → append → queue=[Node(15),Node(7)]
+  depth=2
+
+【レベル3】level_size=2
+  popleft() → Node(15) → 子なし
+  popleft() → Node(7)  → 子なし
+  depth=3
+
+queue=deque([]) → 空 → ループ終了
+return 3 ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════ DIAGRAM -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit 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="28" height="18">
+                                <ellipse
+                                    cx="14"
+                                    cy="9"
+                                    rx="13"
+                                    ry="8"
+                                    fill="#d1fae5"
+                                    stroke="#10b981"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <rect
+                                    x="1"
+                                    y="2"
+                                    width="26"
+                                    height="14"
+                                    rx="2"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <polygon
+                                    points="14,1 27,9 14,17 1,9"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 col-span-2 md:col-span-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500 mr-1"></span>緑＝はい
+                            <span class="inline-block w-5 h-0.5 bg-red-500 mx-1"></span>赤＝いいえ
+                            <span class="inline-block w-5 h-0.5 bg-purple-500 mx-1"></span
+                            >紫＝ループ
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-5 overflow-x-auto">
+                    <!--
+      SVG設計:
+        viewBox: 0 0 560 610
+        全ボックス: x=60, width=440, center x=280
+        全テキスト: x=280, text-anchor="middle"
+        静的HTML SVG → ケバブケース属性
+    -->
+                    <svg
+                        viewBox="0 0 560 610"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Maximum Depth of Binary Tree 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="#dc2626" />
+                            </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>
+
+                        <!-- ① 開始 -->
+                        <ellipse
+                            cx="280"
+                            cy="44"
+                            rx="100"
+                            ry="26"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="44"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="14"
+                            font-weight="700"
+                            fill="#065f46"
+                        >
+                            開始: maxDepth(root)
+                        </text>
+
+                        <!-- arrow ①→② -->
+                        <line
+                            x1="280"
+                            y1="70"
+                            x2="280"
+                            y2="90"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ② root is None? ひし形 -->
+                        <polygon
+                            points="280,90 395,128 280,166 165,128"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="122"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#92400e"
+                        >
+                            root is None ?
+                        </text>
+                        <text
+                            x="280"
+                            y="140"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#78350f"
+                        >
+                            （空の木チェック）
+                        </text>
+
+                        <!-- はい →右 return 0 -->
+                        <line
+                            x1="395"
+                            y1="128"
+                            x2="440"
+                            y2="128"
+                            stroke="#059669"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="415"
+                            y="120"
+                            text-anchor="middle"
+                            font-size="11"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <ellipse
+                            cx="490"
+                            cy="128"
+                            rx="50"
+                            ry="22"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="490"
+                            y="128"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="700"
+                            fill="#065f46"
+                        >
+                            return 0
+                        </text>
+
+                        <!-- いいえ →下 -->
+                        <line
+                            x1="280"
+                            y1="166"
+                            x2="280"
+                            y2="186"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="258"
+                            y="180"
+                            text-anchor="middle"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- ③ キュー初期化 -->
+                        <rect
+                            x="60"
+                            y="186"
+                            width="440"
+                            height="60"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="208"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#1e40af"
+                        >
+                            queue = deque([root])
+                        </text>
+                        <text
+                            x="280"
+                            y="230"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#1e40af"
+                        >
+                            depth = 0
+                        </text>
+
+                        <!-- arrow ③→④ -->
+                        <line
+                            x1="280"
+                            y1="246"
+                            x2="280"
+                            y2="266"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ④ queue が空? ひし形 -->
+                        <polygon
+                            points="280,266 395,306 280,346 165,306"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="298"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#92400e"
+                        >
+                            queue が空?
+                        </text>
+                        <text
+                            x="280"
+                            y="316"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#78350f"
+                        >
+                            （while ループ判定）
+                        </text>
+
+                        <!-- はい →右 return depth -->
+                        <line
+                            x1="395"
+                            y1="306"
+                            x2="440"
+                            y2="306"
+                            stroke="#059669"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="415"
+                            y="298"
+                            text-anchor="middle"
+                            font-size="11"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <ellipse
+                            cx="493"
+                            cy="306"
+                            rx="57"
+                            ry="22"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="493"
+                            y="306"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="700"
+                            fill="#065f46"
+                        >
+                            return depth
+                        </text>
+
+                        <!-- いいえ →下 -->
+                        <line
+                            x1="280"
+                            y1="346"
+                            x2="280"
+                            y2="366"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="258"
+                            y="360"
+                            text-anchor="middle"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- ⑤ level_size 記録 -->
+                        <rect
+                            x="60"
+                            y="366"
+                            width="440"
+                            height="46"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="389"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#1e40af"
+                        >
+                            level_size = len(queue)
+                        </text>
+
+                        <!-- arrow ⑤→⑥ -->
+                        <line
+                            x1="280"
+                            y1="412"
+                            x2="280"
+                            y2="432"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ⑥ ノード処理 -->
+                        <rect
+                            x="60"
+                            y="432"
+                            width="440"
+                            height="62"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="454"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#1e40af"
+                        >
+                            level_size 回: node = queue.popleft()
+                        </text>
+                        <text
+                            x="280"
+                            y="476"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#1e40af"
+                        >
+                            左右の子が存在すれば queue.append()
+                        </text>
+
+                        <!-- arrow ⑥→⑦ -->
+                        <line
+                            x1="280"
+                            y1="494"
+                            x2="280"
+                            y2="514"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ⑦ depth += 1 -->
+                        <rect
+                            x="60"
+                            y="514"
+                            width="440"
+                            height="46"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="537"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="600"
+                            fill="#1e40af"
+                        >
+                            depth += 1
+                        </text>
+
+                        <!-- ループバック（紫）: bottom of ⑦ → left → up → join ④ left vertex -->
+                        <polyline
+                            points="280,560 280,578 35,578 35,306 165,306"
+                            fill="none"
+                            stroke="#a855f7"
+                            stroke-width="2"
+                            stroke-dasharray="6,3"
+                            marker-end="url(#fc-arrowPurple)"
+                        />
+                        <text
+                            x="90"
+                            y="595"
+                            text-anchor="middle"
+                            font-size="10"
+                            fill="#a855f7"
+                            font-weight="600"
+                        >
+                            ループ継続
+                        </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">
+                        🔎 入力例1 [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=Node(3) を受け取る</li>
+                        <li>
+                            「root is None?」→ Node(3) は None ではない →
+                            <strong class="text-red-600">いいえ</strong> の経路へ
+                        </li>
+                        <li>「キュー初期化」→ queue=deque([Node(3)]), depth=0</li>
+                        <li>
+                            「queue が空?」→ [Node(3)] は空でない →
+                            <strong class="text-red-600">いいえ</strong>
+                        </li>
+                        <li>
+                            level_size=1 → Node(3) をpopleft → 子 Node(9),Node(20) をappend →
+                            depth=1
+                        </li>
+                        <li>
+                            「queue が空?」→ [Node(9),Node(20)] は空でない → level_size=2 → 処理 →
+                            depth=2
+                        </li>
+                        <li>
+                            「queue が空?」→ [Node(15),Node(7)] は空でない → level_size=2 → 処理 →
+                            depth=3
+                        </li>
+                        <li>
+                            「queue が空?」→ [] は空 →
+                            <strong class="text-emerald-600">はい</strong> → 「return depth」→
+                            <strong>3</strong> を返す ✅
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════ COMPLEXITY -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <!-- Big-O 早見表 -->
+                <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(log n)</div>
+                            <div class="leading-5">
+                                半分ずつ絞る<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 text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-emerald-50">
+                                <th
+                                    class="text-left px-4 py-3 font-semibold text-teal-800 border-b-2 border-emerald-200"
+                                >
+                                    実装
+                                </th>
+                                <th
+                                    class="text-center px-4 py-3 font-semibold text-teal-800 border-b-2 border-emerald-200"
+                                >
+                                    時間計算量
+                                </th>
+                                <th
+                                    class="text-center px-4 py-3 font-semibold text-teal-800 border-b-2 border-emerald-200"
+                                >
+                                    空間計算量
+                                </th>
+                                <th
+                                    class="text-left px-4 py-3 font-semibold text-teal-800 border-b-2 border-emerald-200"
+                                >
+                                    空間の詳細
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="border-b border-slate-100">
+                                <td class="px-4 py-3 font-semibold text-emerald-700">
+                                    業務版（BFS）
+                                </td>
+                                <td class="px-4 py-3 text-center font-mono font-bold text-sky-700">
+                                    O(n)
+                                </td>
+                                <td
+                                    class="px-4 py-3 text-center font-mono font-bold text-amber-700"
+                                >
+                                    O(w)
+                                </td>
+                                <td class="px-4 py-3 text-slate-600 text-xs">
+                                    w = 木の最大幅。完全二分木では最下段≈n/2
+                                </td>
+                            </tr>
+                            <tr class="border-b border-slate-100 bg-slate-50/40">
+                                <td class="px-4 py-3 font-semibold text-sky-700">
+                                    競技版（再帰DFS）
+                                </td>
+                                <td class="px-4 py-3 text-center font-mono font-bold text-sky-700">
+                                    O(n)
+                                </td>
+                                <td
+                                    class="px-4 py-3 text-center font-mono font-bold text-amber-700"
+                                >
+                                    O(h)
+                                </td>
+                                <td class="px-4 py-3 text-slate-600 text-xs">
+                                    h = 木の高さ。平衡木でO(log n)、一本道でO(n)
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                </div>
+
+                <!-- なぜこの計算量か -->
+                <div class="mt-5 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回は訪問しなければなりません（どの葉が一番深いか分からないため）。BFS版・DFS版どちらも全n個のノードを正確に1回ずつ処理するので
+                        O(n) です。<br />
+                        <strong>空間計算量（BFS）O(w)</strong
+                        >：キューには「現在のレベルのノード」と「次のレベルのノード」が同時に入ります。同じ深さのノード数の最大値
+                        w が最大キューサイズになります。<br />
+                        <strong>空間計算量（DFS）O(h)</strong
+                        >：再帰呼び出しのたびにコールスタックに1段積まれます。最大で「木の高さ
+                        h」段まで積まれるため O(h) です。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════ GLOSSARY -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit 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
+                            の略。木やグラフを「同じ深さ（レベル）のノードを全部見てから次の深さへ」進む方式で探索する手法。階数が同じ場所を先に全部確認してから次の階へ進むエレベーターのイメージ。Pythonでは
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >collections.deque</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> DFS（深さ優先探索）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            Depth-First Search
+                            の略。木の一本道を葉（末端）まで進み切ってから戻り、次の道を探す方式。迷路で「行き止まりまで進んでから引き返す」探索法に似ている。再帰（関数が自分自身を呼び出す仕組み）と相性が良い。
+                        </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> O(n)
+                            記法（ビッグオー記法）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            アルゴリズムの速さやメモリ使用量が「入力の大きさ n
+                            が増えるにつれてどう増えるか」を表す記法。O(n) は「n
+                            が2倍になると処理も約2倍になる」こと、O(1) は「n
+                            に関わらず常に一定」を意味する。
+                        </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"
+                        >
+                            関数が呼び出されるたびに「この関数に戻ってくる場所」の記録が積み上がる高速なメモリ領域。お皿の積み重ねのように、最後に置いたものが最初に取り出される（LIFO）。再帰が深くなりすぎるとこれが溢れて
+                            <code class="bg-slate-100 px-1 rounded mono text-xs"
+                                >RecursionError</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>
+                            collections.deque（両端キュー）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            前後どちらからも O(1)
+                            で要素を追加・削除できるデータ構造。「両端開きの箱」のイメージ。<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >list.pop(0)</code
+                            >（先頭削除）は全要素をずらすため O(n) かかるが、<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >deque.popleft()</code
+                            >
+                            は O(1) で済む。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> 再帰（Recursion）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数が自分自身を呼び出す手法。「問題を同じ形の小さな問題に分割して解く」のに最適。必ず「ベースケース（終了条件）」が必要で、ないと無限に呼び出しが続いてエラーになる。木の探索と非常に相性が良い。
+                        </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> 二分木（Binary Tree）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            各ノード（節）が最大2つの子（左・右）を持つ木構造のデータ形式。家系図のように根（root）を頂点として下に枝分かれしていく。子を持たないノードを「葉（leaf）」と呼ぶ。
+                        </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> Optional[T]（型ヒント）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            「T 型またはNone」のどちらかであることを表すPythonの型ヒント。<code
+                                class="bg-slate-100 px-1 rounded mono text-xs"
+                                >Optional[TreeNode]</code
+                            >
+                            と書くと、pylance（型チェッカー）が「None
+                            かもしれない」ことを理解し、None チェックなしに
+                            <code class="bg-slate-100 px-1 rounded mono text-xs">root.left</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> ベースケース（Base
+                            Case）
+                        </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 mono text-xs">root is None</code>
+                            がベースケースで、「存在しないノードの深さは0」を意味する。ベースケースがないと再帰が無限に続いてエラーになる。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <!-- ═══════════════════════════════════════════════════════════ FOOTER -->
+            <footer class="text-center text-slate-400 text-xs py-6">
+                LeetCode 104 · Maximum Depth of Binary Tree · Python 解説ページ
+            </footer>
+        </div>
+        <!-- /max-w-5xl -->
+
+        <!-- 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;
+
+            // ── ツリーミニ図（各ステップで異なるノードをハイライト）
+            function MiniTree({ highlightLevel }) {
+                const nodes = [
+                    { id: 'n3', cx: 140, cy: 30, label: '3', level: 1 },
+                    { id: 'n9', cx: 70, cy: 90, label: '9', level: 2 },
+                    { id: 'n20', cx: 210, cy: 90, label: '20', level: 2 },
+                    { id: 'n15', cx: 168, cy: 150, label: '15', level: 3 },
+                    { id: 'n7', cx: 252, cy: 150, label: '7', level: 3 },
+                ];
+                const edges = [
+                    { x1: 140, y1: 30, x2: 70, y2: 90 },
+                    { x1: 140, y1: 30, x2: 210, y2: 90 },
+                    { x1: 210, y1: 90, x2: 168, y2: 150 },
+                    { x1: 210, y1: 90, x2: 252, y2: 150 },
+                ];
+                return (
+                    <svg
+                        viewBox="0 0 300 185"
+                        style={{
+                            width: '100%',
+                            maxWidth: '280px',
+                            display: 'block',
+                            margin: '0 auto',
+                        }}
+                    >
+                        {edges.map((e, i) => (
+                            <line
+                                key={i}
+                                x1={e.x1}
+                                y1={e.y1}
+                                x2={e.x2}
+                                y2={e.y2}
+                                stroke="#cbd5e1"
+                                strokeWidth="2"
+                            />
+                        ))}
+                        {nodes.map((n) => {
+                            const isActive = n.level === highlightLevel;
+                            return (
+                                <g key={n.id} className={isActive ? 'node-active' : ''}>
+                                    <circle
+                                        cx={n.cx}
+                                        cy={n.cy}
+                                        r="22"
+                                        fill={isActive ? '#d1fae5' : '#f8fafc'}
+                                        stroke={isActive ? '#059669' : '#94a3b8'}
+                                        strokeWidth={isActive ? '2.5' : '1.5'}
+                                    />
+                                    <text
+                                        x={n.cx}
+                                        y={n.cy}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="14"
+                                        fontWeight={isActive ? '700' : '500'}
+                                        fill={isActive ? '#065f46' : '#475569'}
+                                    >
+                                        {n.label}
+                                    </text>
+                                </g>
+                            );
+                        })}
+                    </svg>
+                );
+            }
+
+            // ── 各ステップのデータ
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '空の木チェック（エッジケース処理）',
+                    desc:
+                        '最初に root が None かどうかを確認します。' +
+                        'なぜなら、後続のキュー操作に None を渡すと AttributeError（存在しない属性へのアクセスエラー）が発生するためです。' +
+                        '例）root=None → 即座に return 0。今回の入力 root=Node(3) は None ではないので次へ進みます。',
+                    highlightLevel: 0,
+                    queueState: '（まだ初期化していない）',
+                    depth: '（まだ初期化していない）',
+                    note: 'root=Node(3) → None ではない → 次へ進む',
+                },
+                {
+                    step: 2,
+                    title: 'キューの初期化（BFS の準備）',
+                    desc:
+                        'queue = deque([root]) でキューを初期化し、depth = 0 をセットします。' +
+                        'deque を使う理由は、popleft()（先頭削除）が O(1) で済むためです。list.pop(0) は全要素をずらすため O(n) かかります。' +
+                        '例）queue=deque([Node(3)]), depth=0。これで BFS の準備完了です。',
+                    highlightLevel: 1,
+                    queueState: '[Node(3)]',
+                    depth: '0',
+                    note: 'deque.popleft() = O(1) vs list.pop(0) = O(n)',
+                },
+                {
+                    step: 3,
+                    title: 'while ループ：queue が空か確認',
+                    desc:
+                        'while queue: でキューが空になるまでループを続けます。' +
+                        'キューが空になった時点で「全ノードの処理が完了した」ことを意味し、depth を返します。' +
+                        '例）queue=[Node(3)] → 空でない → ループ継続。',
+                    highlightLevel: 1,
+                    queueState: '[Node(3)]',
+                    depth: '0',
+                    note: 'queue が空でない → ループ継続',
+                },
+                {
+                    step: 4,
+                    title: 'level_size の記録（1段分のノード数を固定）',
+                    desc:
+                        'level_size = len(queue) で「今のレベルにいるノードの数」を記録します。' +
+                        'ループ前に固定する理由は、ループ内で子ノードを append するとキューの長さが変わり、次のレベルのノードまで処理してしまうためです。' +
+                        '例）level_size=1（Node(3)だけが今のレベル）。',
+                    highlightLevel: 1,
+                    queueState: '[Node(3)]',
+                    depth: '0',
+                    note: 'level_size=1（Node(3)のレベル）',
+                },
+                {
+                    step: 5,
+                    title: 'ノードを取り出し・子をキューへ追加',
+                    desc:
+                        'popleft() でキュー先頭のノードを取り出し、左右の子が存在すれば次のレベルとしてキューへ追加します。' +
+                        'O(1) の popleft() を使うのは、list.pop(0) の O(n) を避けるためです。' +
+                        '例）Node(3)を取り出し → left=Node(9), right=Node(20) をappend → queue=[Node(9),Node(20)]。',
+                    highlightLevel: 2,
+                    queueState: '[Node(9), Node(20)]',
+                    depth: '0（まだ+1前）',
+                    note: 'Node(3) → children: Node(9), Node(20)',
+                },
+                {
+                    step: 6,
+                    title: 'depth += 1 で深さをカウントアップ',
+                    desc:
+                        '1レベル分のノードを全て処理し終えたら depth += 1 します。' +
+                        'この時点で「根から1段下りた」ことが確定したため深さを+1します。ループの最後にまとめて+1するのがポイントです。' +
+                        '例）depth=0 → depth=1。続けてレベル2・3を処理し、最終的に depth=3 を返します。',
+                    highlightLevel: 3,
+                    queueState: '[Node(15), Node(7)]（最終レベル）',
+                    depth: '3（最終値）',
+                    note: 'depth=3 → queue が空 → return 3 ✅',
+                },
+            ];
+
+            function StepVisualization({ step }) {
+                const s = stepsData[step - 1];
+                return (
+                    <div className="mt-4 space-y-3">
+                        <MiniTree highlightLevel={s.highlightLevel} />
+                        <div className="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>
+                            <div className="text-sky-700 mb-1">
+                                <span className="text-slate-400">queue = </span>
+                                {s.queueState}
+                            </div>
+                            <div className="text-emerald-700 mb-1">
+                                <span className="text-slate-400">depth = </span>
+                                {s.depth}
+                            </div>
+                            <div className="text-amber-700">
+                                <span className="text-slate-400">memo : </span>
+                                {s.note}
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            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) {
+                                setIsPlaying(false);
+                            } else {
+                                setActiveStep((prev) => prev + 1);
+                            }
+                        }, 2000);
+                    }
+                    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-base font-semibold">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-sm rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)]'
+                                                    : '',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                            aria-label={'ステップ' + step.step + ': ' + step.title}
+                                            aria-current={isActive ? 'step' : undefined}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold text-sm mb-0.5',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}: {step.title}
+                                            </div>
+                                            <div className="text-slate-400 text-xs">
+                                                {step.desc.substring(0, 40)}…
+                                            </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}）では「
+                                    {stepsData[activeStep - 2].title}」を行いました
+                                </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">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <StepVisualization step={activeStep} />
+
+                            {/* コントロールボタン */}
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 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-4 py-2 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-4 py-2 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-4 py-2 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/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/README_React.html b/public/Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/README_React.html
new file mode 100644
index 0000000..efc7cef
--- /dev/null
+++ b/public/Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder Traversal/claude sonnet 4.6 extended/README_React.html	
@@ -0,0 +1,1081 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>LeetCode 105 – Construct Binary Tree from Preorder and Inorder Traversal</title>
+
+  <!-- Google Fonts -->
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;700&family=Noto+Sans+JP:wght@400;500;700&display=swap" rel="stylesheet" />
+
+  <!-- Tailwind CSS -->
+  <script src="/vendor/tailwindcss/script.js"></script>
+
+  <!-- Prism.js -->
+  <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" />
+  <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 18 + Babel -->
+  <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>
+
+  <style>
+    html { scroll-behavior: smooth; }
+    body { font-family: 'Noto Sans JP', sans-serif; }
+    .outfit { font-family: 'Outfit', sans-serif; }
+    .mono  { font-family: 'JetBrains Mono', monospace; }
+
+    /* Prism toolbar */
+    .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 open arrow */
+    details > summary { list-style: none; }
+    details > summary::-webkit-details-marker { display: none; }
+    details[open] > summary .arrow { transform: rotate(90deg); }
+    .arrow { transition: transform 0.2s; display: inline-block; }
+
+    /* Tree node animation */
+    @keyframes popIn {
+      0%   { transform: scale(0.4); opacity: 0; }
+      70%  { transform: scale(1.1); }
+      100% { transform: scale(1); opacity: 1; }
+    }
+    .node-pop { animation: popIn 0.35s ease forwards; }
+
+    @keyframes fadeSlide {
+      from { opacity: 0; transform: translateY(6px); }
+      to   { opacity: 1; transform: translateY(0); }
+    }
+    .fade-slide { animation: fadeSlide 0.4s ease forwards; }
+
+    /* Step button active glow */
+    .step-active { box-shadow: 0 4px 16px rgba(16,185,129,0.30); }
+  </style>
+</head>
+<body class="bg-[linear-gradient(135deg,#f0fdf4_0%,#e0f2fe_100%)] min-h-screen py-8 px-4">
+<div class="max-w-5xl mx-auto">
+
+  <!-- ============================================================ HEADER -->
+  <header id="header" class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.14)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]">
+    <div class="flex flex-wrap items-center gap-3 mb-2">
+      <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit">LeetCode 105</span>
+      <span class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit">Medium</span>
+      <span class="bg-purple-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit">再帰 / 分割統治</span>
+    </div>
+    <h1 class="outfit text-[2.1rem] md:text-[2.6rem] font-extrabold text-teal-900 mb-1 leading-tight">
+      Construct Binary Tree<br class="hidden sm:block"/>from Preorder &amp; Inorder Traversal
+    </h1>
+    <p class="text-lg text-cyan-700 font-semibold mt-1 outfit">
+      dict前処理 + 再帰分割 による O(n) 実装
+    </p>
+    <div class="mt-3 text-base text-teal-800 bg-white/70 rounded-xl px-4 py-2 inline-block">
+      💡 一言で言うと：「2種類の探索順リストを手がかりに、元の二分木を Python インスタンスとして<strong>復元する</strong>問題」
+    </div>
+
+    <!-- nav（純粋HTML） -->
+    <nav class="flex flex-wrap gap-2 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="outfit 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-700 mt-1 leading-7">「<strong>前順探索（preorder）</strong>と<strong>中順探索（inorder）</strong>という2種類の配列をもとに、それを生成した元の二分木を Python のノードオブジェクトとして再構築する問題」です。<br/>
+      preorder の先頭は必ずルートになり、inorder でのルート位置が左右の分割点を教えてくれます。この2つの性質を組み合わせることで木を一意に復元できます。</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 leading-7">
+        <li><strong>片方の配列だけでは木が一意に決まらない</strong>：例えば preorder <code class="bg-slate-100 px-1 rounded font-mono text-xs">[1,2,3]</code> に対して複数の異なる二分木が存在します。左右どちらの子かが不明なためです。</li>
+        <li><strong>毎回 list.index() を使うと O(n²)</strong>：n 個のノードそれぞれで線形探索すると合計 O(n²) になり n=3000 では約450万回の比較が発生します。dict の前処理（O(n)）が不可欠です。</li>
+        <li><strong>カーソル変数の共有が難しい</strong>：preorder の消費位置を再帰呼び出し間で正確に共有するために <code class="bg-slate-100 px-1 rounded font-mono text-xs">nonlocal</code> の理解が必要です。</li>
+      </ul>
+    </div>
+
+    <!-- 指標カード（純粋HTML） -->
+    <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-base font-mono break-all leading-tight">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-base font-mono break-all leading-tight">O(n)</div>
+        <div class="text-xs mt-1">空間計算量</div>
+      </div>
+      <div style="background:#fef3c7;color:#92400e" class="rounded-xl p-3 text-center">
+        <div class="font-bold text-xs font-mono break-all leading-tight">再帰 + dict</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">n ≤ 3000</div>
+        <div class="text-xs mt-1">制約</div>
+      </div>
+    </div>
+
+    <!-- 入出力例 -->
+    <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-5">
+      <div class="p-4 rounded-xl bg-slate-50 border border-slate-200">
+        <p class="font-semibold text-teal-800 text-sm mb-2">📥 入力例 1</p>
+        <pre class="text-xs font-mono text-slate-700 leading-6">preorder = [3, 9, 20, 15, 7]
+inorder  = [9, 3, 15, 20,  7]</pre>
+        <p class="text-xs text-slate-500 mt-2">→ <span class="font-mono text-emerald-700">[3,9,20,null,null,15,7]</span><br/>
+        <span class="text-slate-500">preorder先頭の3がルート。inorderでルート3の左は[9]、右は[15,20,7]と分かる。</span></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-2">📥 入力例 2</p>
+        <pre class="text-xs font-mono text-slate-700 leading-6">preorder = [-1]
+inorder  = [-1]</pre>
+        <p class="text-xs text-slate-500 mt-2">→ <span class="font-mono text-emerald-700">TreeNode(-1)</span><br/>
+        <span class="text-slate-500">ノードが1つだけ。左右の子ともNone。</span></p>
+      </div>
+    </div>
+
+    <!-- 2配列が持つ情報 -->
+    <div class="p-4 rounded-xl bg-sky-50 border border-sky-200">
+      <p class="text-sky-800 font-semibold text-sm mb-3">🔑 2つの配列が持つ情報</p>
+      <div class="grid grid-cols-1 md:grid-cols-2 gap-3 text-xs font-mono">
+        <div class="p-3 rounded-lg bg-white border border-emerald-200">
+          <div class="text-emerald-700 font-bold mb-1">preorder = [3, 9, 20, 15, 7]</div>
+          <div class="text-slate-500">↑先頭 = 必ずルート！<br/>「ルート→左→右」の順に並ぶ</div>
+        </div>
+        <div class="p-3 rounded-lg bg-white border border-sky-200">
+          <div class="text-sky-700 font-bold mb-1">inorder  = [9, 3, 15, 20, 7]</div>
+          <div class="text-slate-500">ルート「3」の位置が境界線！<br/>左[9] → ルート3 → 右[15,20,7]</div>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <!-- ============================================================ STEPS (React) -->
+  <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+    <h2 class="outfit 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="outfit 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 leading-7">
+        <li><strong>sys.setrecursionlimit</strong>：最悪3000段の再帰に備えて上限を緩和する</li>
+        <li><strong>入力検証</strong>：型チェック・長さ不一致・空リストを早期検出する</li>
+        <li><strong>前処理</strong>：inorder の「値→インデックス」を dict 内包表記で O(n) 構築する</li>
+        <li><strong>再帰関数 build(lo, hi)</strong>：preorder カーソルを進めながら左→右の順で部分木を再帰構築して返す</li>
+      </ol>
+    </div>
+
+    <pre class="line-numbers"><code class="language-python">import sys
+from typing import Optional
+
+sys.setrecursionlimit(10_000)  # 偏った木(n=3000)の深い再帰に備えて上限を緩和
+
+
+class TreeNode:
+    __slots__ = ("val", "left", "right")
+    def __init__(self, val=0, left=None, right=None):
+        self.val   = val
+        self.left  = left
+        self.right = right
+
+
+class Solution:
+    def buildTree(
+        self,
+        preorder: list[int],
+        inorder:  list[int],
+    ) -&gt; Optional[TreeNode]:
+        """
+        preorder（前順）と inorder（中順）から二分木を復元する。
+        Time:  O(n) - 各ノードをちょうど1回処理
+        Space: O(n) - dict(n エントリ) + 再帰スタック(高さ h)
+        """
+        # ① 型チェック: list 以外が渡された場合に分かりやすいエラーを出す
+        if not isinstance(preorder, list) or not isinstance(inorder, list):
+            raise TypeError("Both preorder and inorder must be lists")
+
+        # ② 長さ不一致チェック: 同じ木でなければ復元不可
+        if len(preorder) != len(inorder):
+            raise ValueError(
+                f"Length mismatch: preorder={len(preorder)}, inorder={len(inorder)}"
+            )
+
+        # ③ 空リストチェック: ノード0個 → Noneを返す
+        if not preorder:
+            return None
+
+        n = len(inorder)
+
+        # ④ 前処理: inorder の「値→インデックス」を dict 内包表記で O(n) 構築
+        #    ★毎回 list.index() を使うと全体 O(n²) → dict なら O(1) ルックアップ
+        inorder_index: dict[int, int] = {val: i for i, val in enumerate(inorder)}
+
+        # ⑤ preorder を先頭から消費するカーソル
+        #    int はイミュータブル(変更不可)なので nonlocal で外側変数を共有する
+        preorder_idx: int = 0
+
+        def build(lo: int, hi: int) -&gt; Optional[TreeNode]:
+            """inorder の [lo, hi] 範囲に対応する部分木を再帰構築する"""
+            nonlocal preorder_idx
+
+            # ⑥ 再帰の終了条件: 範囲が空(lo &gt; hi) → 部分木なし
+            if lo &gt; hi:
+                return None
+
+            # ⑦ preorder の現在位置 = この部分木のルート値
+            #    preorder は「ルート→左→右」順なので呼ばれた時点の先頭が必ずルート
+            root_val: int = preorder[preorder_idx]
+            preorder_idx += 1  # 次の再帰のためにカーソルを進める
+
+            # ⑧ dict でルートの inorder 上の位置を O(1) で取得
+            #    この位置(mid)が左部分木と右部分木の境界線になる
+            mid: int = inorder_index[root_val]
+
+            # ⑨ ノードを生成し左→右の順で再帰構築して接続する
+            #    ★左を先にする理由: preorder が「ルート→左→右」順のため
+            #    左の再帰が終わると次のカーソル位置が右部分木のルートになる
+            node = TreeNode(root_val)
+            node.left  = build(lo,      mid - 1)  # 左部分木(mid の左側)
+            node.right = build(mid + 1, hi)        # 右部分木(mid の右側)
+            return node
+
+        # ⑩ inorder 全体(0〜n-1)を対象に木全体を構築して返す
+        return build(0, n - 1)
+</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">▶ 入力例 preorder=[3,9,20,15,7] / inorder=[9,3,15,20,7] での動作トレース</p>
+      <pre class="text-slate-700 text-xs font-mono leading-6 overflow-x-auto whitespace-pre">前処理: inorder_index = {9:0, 3:1, 15:2, 20:3, 7:4}
+preorder_idx = 0
+
+build(0, 4):
+  root_val=3 (preorder[0]), preorder_idx→1, mid=inorder_index[3]=1
+  node = TreeNode(3)
+  node.left  = build(0, 0)
+    root_val=9, preorder_idx→2, mid=0
+    node.left  = build(0,-1) → lo&gt;hi → None
+    node.right = build(1, 0) → lo&gt;hi → None
+    ✅ return TreeNode(9)
+  node.right = build(2, 4)
+    root_val=20, preorder_idx→3, mid=3
+    node.left  = build(2, 2)
+      root_val=15, preorder_idx→4, mid=2
+      → TreeNode(15, None, None)  ✅
+    node.right = build(4, 4)
+      root_val=7, preorder_idx→5, mid=4
+      → TreeNode(7, None, None)   ✅
+    ✅ return TreeNode(20, left=15, right=7)
+✅ return TreeNode(3, left=9, right=20)
+
+最終ツリー:
+        3
+       / \
+      9  20
+         / \
+        15   7
+Output: [3,9,20,null,null,15,7]  ✅</pre>
+    </div>
+  </section>
+
+  <!-- ============================================================ DIAGRAM -->
+  <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+    <h2 class="outfit 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="28" height="18"><ellipse cx="14" cy="9" rx="12" ry="8" fill="#d1fae5" stroke="#10b981" stroke-width="1.5"/></svg>
+          <span>楕円（緑）＝ 開始・終了</span>
+        </div>
+        <div class="flex items-center gap-2">
+          <svg width="28" height="18"><rect x="1" y="2" width="26" height="14" rx="3" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.5"/></svg>
+          <span>四角（青）＝ 処理ステップ</span>
+        </div>
+        <div class="flex items-center gap-2">
+          <svg width="28" height="18"><polygon points="14,1 27,9 14,17 1,9" fill="#fef3c7" stroke="#f59e0b" stroke-width="1.5"/></svg>
+          <span>ひし形（黄）＝ 条件分岐</span>
+        </div>
+        <div class="flex items-center gap-2 col-span-2 md:col-span-1">
+          <span class="inline-block w-5 h-0.5 bg-emerald-500 mr-1"></span>緑＝Yes
+          <span class="inline-block w-5 h-0.5 bg-red-500 mx-1"></span>赤＝No
+        </div>
+      </div>
+    </div>
+
+    <!-- SVG フローチャート -->
+    <div class="overflow-x-auto">
+      <svg viewBox="0 0 560 1360"
+           style="max-width:560px;width:100%;height:auto;display:block;margin:0 auto;"
+           role="img" aria-label="LeetCode 105 buildTree 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="#dc2626"/></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>
+
+        <!-- ノード定義: x=60, width=440, center=280, 縦積み -->
+
+        <!-- N0: 開始 -->
+        <ellipse cx="280" cy="38" rx="110" ry="28" fill="#d1fae5" stroke="#10b981" stroke-width="2"/>
+        <text x="280" y="38" text-anchor="middle" dominant-baseline="middle" font-size="14" font-weight="bold" fill="#065f46" font-family="'Noto Sans JP',sans-serif">buildTree 開始</text>
+
+        <!-- N0→N1 -->
+        <line x1="280" y1="66" x2="280" y2="92" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- N1: 型チェック -->
+        <rect x="60" y="92" width="440" height="52" rx="8" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.8"/>
+        <text x="280" y="112" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#1e3a5f" font-family="'Noto Sans JP',sans-serif">① 型チェック</text>
+        <text x="280" y="132" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="'JetBrains Mono',monospace">isinstance(preorder, list) and isinstance(inorder, list)</text>
+
+        <!-- N1→C1 -->
+        <line x1="280" y1="144" x2="280" y2="172" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- C1: 型OK? -->
+        <polygon points="280,172 420,222 280,272 140,222" fill="#fef3c7" stroke="#f59e0b" stroke-width="1.8"/>
+        <text x="280" y="217" text-anchor="middle" dominant-baseline="middle" font-size="12" font-weight="bold" fill="#78350f" font-family="'Noto Sans JP',sans-serif">型は正しい？</text>
+
+        <!-- C1 No → TypeError -->
+        <line x1="420" y1="222" x2="500" y2="222" stroke="#dc2626" stroke-width="1.8" marker-end="url(#fc-arrowRed)"/>
+        <text x="462" y="214" text-anchor="middle" font-size="10" fill="#dc2626" font-family="'Noto Sans JP',sans-serif">No</text>
+        <ellipse cx="530" cy="222" rx="28" ry="18" fill="#fee2e2" stroke="#dc2626" stroke-width="1.5"/>
+        <text x="530" y="222" text-anchor="middle" dominant-baseline="middle" font-size="10" fill="#991b1b" font-family="'Noto Sans JP',sans-serif">TypeError</text>
+
+        <!-- C1 Yes → N2 -->
+        <line x1="280" y1="272" x2="280" y2="298" stroke="#059669" stroke-width="1.8" marker-end="url(#fc-arrowGreen)"/>
+        <text x="290" y="288" font-size="10" fill="#059669" font-family="'Noto Sans JP',sans-serif">Yes</text>
+
+        <!-- N2: 長さチェック -->
+        <rect x="60" y="298" width="440" height="44" rx="8" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.8"/>
+        <text x="280" y="313" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#1e3a5f" font-family="'Noto Sans JP',sans-serif">② 長さチェック</text>
+        <text x="280" y="331" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="'JetBrains Mono',monospace">len(preorder) == len(inorder)</text>
+
+        <!-- N2→C2 -->
+        <line x1="280" y1="342" x2="280" y2="368" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- C2: 同じ長さ？ -->
+        <polygon points="280,368 420,418 280,468 140,418" fill="#fef3c7" stroke="#f59e0b" stroke-width="1.8"/>
+        <text x="280" y="413" text-anchor="middle" dominant-baseline="middle" font-size="12" font-weight="bold" fill="#78350f" font-family="'Noto Sans JP',sans-serif">同じ長さ？</text>
+
+        <!-- C2 No → ValueError -->
+        <line x1="420" y1="418" x2="500" y2="418" stroke="#dc2626" stroke-width="1.8" marker-end="url(#fc-arrowRed)"/>
+        <text x="462" y="410" text-anchor="middle" font-size="10" fill="#dc2626" font-family="'Noto Sans JP',sans-serif">No</text>
+        <ellipse cx="530" cy="418" rx="28" ry="18" fill="#fee2e2" stroke="#dc2626" stroke-width="1.5"/>
+        <text x="530" y="418" text-anchor="middle" dominant-baseline="middle" font-size="10" fill="#991b1b" font-family="'Noto Sans JP',sans-serif">ValueError</text>
+
+        <!-- C2 Yes → C3 -->
+        <line x1="280" y1="468" x2="280" y2="494" stroke="#059669" stroke-width="1.8" marker-end="url(#fc-arrowGreen)"/>
+        <text x="290" y="484" font-size="10" fill="#059669" font-family="'Noto Sans JP',sans-serif">Yes</text>
+
+        <!-- C3: 空リスト？ -->
+        <polygon points="280,494 420,544 280,594 140,544" fill="#fef3c7" stroke="#f59e0b" stroke-width="1.8"/>
+        <text x="280" y="539" text-anchor="middle" dominant-baseline="middle" font-size="12" font-weight="bold" fill="#78350f" font-family="'Noto Sans JP',sans-serif">preorder が空？</text>
+
+        <!-- C3 Yes → return None early -->
+        <line x1="420" y1="544" x2="500" y2="544" stroke="#dc2626" stroke-width="1.8" marker-end="url(#fc-arrowRed)"/>
+        <text x="462" y="536" text-anchor="middle" font-size="10" fill="#dc2626" font-family="'Noto Sans JP',sans-serif">Yes</text>
+        <ellipse cx="530" cy="544" rx="28" ry="18" fill="#f0fdf4" stroke="#10b981" stroke-width="1.5"/>
+        <text x="530" y="544" text-anchor="middle" dominant-baseline="middle" font-size="10" fill="#065f46" font-family="'Noto Sans JP',sans-serif">None</text>
+
+        <!-- C3 No → N3 -->
+        <line x1="280" y1="594" x2="280" y2="620" stroke="#059669" stroke-width="1.8" marker-end="url(#fc-arrowGreen)"/>
+        <text x="290" y="610" font-size="10" fill="#059669" font-family="'Noto Sans JP',sans-serif">No</text>
+
+        <!-- N3: dict前処理 -->
+        <rect x="60" y="620" width="440" height="52" rx="8" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.8"/>
+        <text x="280" y="640" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#1e3a5f" font-family="'Noto Sans JP',sans-serif">③ 前処理: inorder_dict 構築 [O(n)]</text>
+        <text x="280" y="660" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="'JetBrains Mono',monospace">{val: i for i, val in enumerate(inorder)}</text>
+
+        <!-- N3→N4 -->
+        <line x1="280" y1="672" x2="280" y2="698" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- N4: カーソル初期化 -->
+        <rect x="60" y="698" width="440" height="44" rx="8" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.8"/>
+        <text x="280" y="715" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#1e3a5f" font-family="'Noto Sans JP',sans-serif">④ preorder_idx = 0 （カーソル初期化）</text>
+        <text x="280" y="733" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="'JetBrains Mono',monospace">build(0, n-1) 呼び出し</text>
+
+        <!-- N4→C4 -->
+        <line x1="280" y1="742" x2="280" y2="770" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- ──── 再帰 build(lo, hi) ──── -->
+        <rect x="60" y="765" width="440" height="22" rx="5" fill="#f8fafc" stroke="#cbd5e1" stroke-width="1" stroke-dasharray="4,3"/>
+        <text x="280" y="776" text-anchor="middle" dominant-baseline="middle" font-size="10" fill="#94a3b8" font-family="'Noto Sans JP',sans-serif">─── 再帰 build(lo, hi) ───</text>
+
+        <line x1="280" y1="787" x2="280" y2="808" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- C4: lo > hi? -->
+        <polygon points="280,808 420,858 280,908 140,858" fill="#fef3c7" stroke="#f59e0b" stroke-width="1.8"/>
+        <text x="280" y="853" text-anchor="middle" dominant-baseline="middle" font-size="12" font-weight="bold" fill="#78350f" font-family="'Noto Sans JP',sans-serif">lo &gt; hi ?</text>
+        <text x="280" y="873" text-anchor="middle" dominant-baseline="middle" font-size="10" fill="#b45309" font-family="'Noto Sans JP',sans-serif">（空の部分木）</text>
+
+        <!-- C4 Yes → None -->
+        <line x1="420" y1="858" x2="500" y2="858" stroke="#dc2626" stroke-width="1.8" marker-end="url(#fc-arrowRed)"/>
+        <text x="462" y="850" text-anchor="middle" font-size="10" fill="#dc2626" font-family="'Noto Sans JP',sans-serif">Yes</text>
+        <ellipse cx="530" cy="858" rx="28" ry="18" fill="#f0fdf4" stroke="#10b981" stroke-width="1.5"/>
+        <text x="530" y="858" text-anchor="middle" dominant-baseline="middle" font-size="10" fill="#065f46" font-family="'Noto Sans JP',sans-serif">None</text>
+
+        <!-- C4 No → N5 -->
+        <line x1="280" y1="908" x2="280" y2="934" stroke="#059669" stroke-width="1.8" marker-end="url(#fc-arrowGreen)"/>
+        <text x="290" y="924" font-size="10" fill="#059669" font-family="'Noto Sans JP',sans-serif">No</text>
+
+        <!-- N5: root_val取得 -->
+        <rect x="60" y="934" width="440" height="52" rx="8" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.8"/>
+        <text x="280" y="954" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#1e3a5f" font-family="'Noto Sans JP',sans-serif">⑤ ルート値を取得しカーソルを進める</text>
+        <text x="280" y="974" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="'JetBrains Mono',monospace">root_val = preorder[idx];  idx += 1</text>
+
+        <!-- N5→N6 -->
+        <line x1="280" y1="986" x2="280" y2="1012" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- N6: mid取得 -->
+        <rect x="60" y="1012" width="440" height="52" rx="8" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.8"/>
+        <text x="280" y="1032" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#1e3a5f" font-family="'Noto Sans JP',sans-serif">⑥ inorder_dict でルート位置を O(1) 取得</text>
+        <text x="280" y="1052" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="'JetBrains Mono',monospace">mid = inorder_dict[root_val]</text>
+
+        <!-- N6→N7 -->
+        <line x1="280" y1="1064" x2="280" y2="1090" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- N7: ノード生成 -->
+        <rect x="60" y="1090" width="440" height="44" rx="8" fill="#d1fae5" stroke="#10b981" stroke-width="1.8"/>
+        <text x="280" y="1107" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#065f46" font-family="'Noto Sans JP',sans-serif">⑦ node = TreeNode(root_val) 生成</text>
+        <text x="280" y="1125" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#059669" font-family="'JetBrains Mono',monospace">node.left = build(lo, mid-1)</text>
+
+        <!-- N7→N8 -->
+        <line x1="280" y1="1134" x2="280" y2="1160" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- N8: 右再帰 -->
+        <rect x="60" y="1160" width="440" height="44" rx="8" fill="#d1fae5" stroke="#10b981" stroke-width="1.8"/>
+        <text x="280" y="1177" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#065f46" font-family="'Noto Sans JP',sans-serif">⑧ 右部分木を再帰構築して接続</text>
+        <text x="280" y="1195" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#059669" font-family="'JetBrains Mono',monospace">node.right = build(mid+1, hi)</text>
+
+        <!-- N8→N9 -->
+        <line x1="280" y1="1204" x2="280" y2="1230" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- N9: return node -->
+        <rect x="60" y="1230" width="440" height="44" rx="8" fill="#ede9fe" stroke="#7c3aed" stroke-width="1.8"/>
+        <text x="280" y="1247" text-anchor="middle" dominant-baseline="middle" font-size="12" fill="#4c1d95" font-family="'Noto Sans JP',sans-serif">⑨ return node</text>
+        <text x="280" y="1265" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#5b21b6" font-family="'Noto Sans JP',sans-serif">（再帰が終わると最終的にルートが返る）</text>
+
+        <!-- N9→End -->
+        <line x1="280" y1="1274" x2="280" y2="1300" stroke="#64748b" stroke-width="1.8" marker-end="url(#fc-arrow)"/>
+
+        <!-- End -->
+        <ellipse cx="280" cy="1326" rx="130" ry="28" fill="#d1fae5" stroke="#10b981" stroke-width="2"/>
+        <text x="280" y="1326" text-anchor="middle" dominant-baseline="middle" font-size="14" font-weight="bold" fill="#065f46" font-family="'Noto Sans JP',sans-serif">完成した木のルートを返す ✅</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">🔎 入力例 preorder=[3,9,20,15,7] / inorder=[9,3,15,20,7] でのフロー追跡</p>
+      <ol class="text-slate-600 text-sm space-y-1 list-decimal list-inside leading-7">
+        <li>「buildTree 開始」→ 両方 list ✅ 長さ5=5 ✅ 空でない ✅</li>
+        <li>「前処理」→ <code class="bg-white px-1 rounded font-mono text-xs">{9:0,3:1,15:2,20:3,7:4}</code> を O(n) で構築</li>
+        <li>「build(0,4)」→ root_val=3, mid=1, TreeNode(3) 生成</li>
+        <li>「build(0,0)」→ root_val=9, mid=0, TreeNode(9) → 左右None → ✅</li>
+        <li>「build(2,4)」→ root_val=20, mid=3, TreeNode(20)</li>
+        <li>「build(2,2)」→ TreeNode(15)、「build(4,4)」→ TreeNode(7) → ✅</li>
+        <li>全再帰が完了 → ルート TreeNode(3) を返す ✅</li>
+      </ol>
+    </div>
+
+    <p class="mt-5 text-slate-600 leading-8 text-sm">
+      <strong class="text-lg text-teal-800">フローの説明：</strong><br/>
+      入口の検証（①②③）でエラーを早期発見し、dict 前処理（③）で O(n²) を O(n) に改善します。再帰 build(lo,hi) では終了条件 <code class="bg-slate-100 px-1 rounded font-mono text-xs">lo&gt;hi</code> を確認した後、preorder カーソルからルートを取得（⑤）し、dict でルートの inorder 位置を特定（⑥）して左→右の順に再帰呼び出しを行います（⑦⑧）。各再帰は必ず処理対象範囲が縮小するため有限回で終了します。
+    </p>
+  </section>
+
+  <!-- ============================================================ COMPLEXITY -->
+  <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+    <h2 class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200">計算量分析</h2>
+
+    <!-- Big-O 早見表 -->
+    <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 記法の読み方</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">例: dict のルックアップ</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>
+
+    <!-- 時間計算量テーブル -->
+    <h3 class="font-bold text-teal-800 mb-2">⏱ 時間計算量</h3>
+    <div class="overflow-x-auto mb-4">
+      <table class="w-full text-sm border-collapse">
+        <thead>
+          <tr class="bg-emerald-50">
+            <th class="text-left p-3 border border-slate-200 text-teal-800">処理</th>
+            <th class="text-center p-3 border border-slate-200 text-teal-800">計算量</th>
+            <th class="text-left p-3 border border-slate-200 text-teal-800">理由</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr class="hover:bg-slate-50">
+            <td class="p-3 border border-slate-200 font-mono text-xs">inorder_dict 構築</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-sky-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">全要素を1回ずつ登録</td>
+          </tr>
+          <tr class="hover:bg-slate-50">
+            <td class="p-3 border border-slate-200 font-mono text-xs">build 再帰呼び出し合計</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-sky-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">各ノードをちょうど1回だけ処理</td>
+          </tr>
+          <tr class="hover:bg-slate-50">
+            <td class="p-3 border border-slate-200 font-mono text-xs">inorder_dict[val] 1回あたり</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-emerald-700">O(1)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">dict の平均ルックアップコスト</td>
+          </tr>
+          <tr class="bg-emerald-50 font-bold">
+            <td class="p-3 border border-slate-200">合計</td>
+            <td class="p-3 border border-slate-200 text-center text-emerald-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">–</td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <!-- 空間計算量テーブル -->
+    <h3 class="font-bold text-teal-800 mb-2 mt-5">💾 空間計算量</h3>
+    <div class="overflow-x-auto mb-4">
+      <table class="w-full text-sm border-collapse">
+        <thead>
+          <tr class="bg-sky-50">
+            <th class="text-left p-3 border border-slate-200 text-sky-800">使用メモリ</th>
+            <th class="text-center p-3 border border-slate-200 text-sky-800">計算量</th>
+            <th class="text-left p-3 border border-slate-200 text-sky-800">理由</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr class="hover:bg-slate-50">
+            <td class="p-3 border border-slate-200 font-mono text-xs">inorder_dict</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-sky-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">n 個のキー・値ペアを保持</td>
+          </tr>
+          <tr class="hover:bg-slate-50">
+            <td class="p-3 border border-slate-200 font-mono text-xs">再帰スタック</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-sky-700">O(h)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">h=木の高さ。バランス木 O(log n)、偏り木 O(n)</td>
+          </tr>
+          <tr class="hover:bg-slate-50">
+            <td class="p-3 border border-slate-200 font-mono text-xs">生成ノード（出力）</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-sky-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">復元した木全体のノード数</td>
+          </tr>
+          <tr class="bg-sky-50 font-bold">
+            <td class="p-3 border border-slate-200">合計</td>
+            <td class="p-3 border border-slate-200 text-center text-sky-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">–</td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <!-- アプローチ比較 -->
+    <h3 class="font-bold text-teal-800 mb-2 mt-5">⚖ アプローチ比較</h3>
+    <div class="overflow-x-auto mb-5">
+      <table class="w-full text-sm border-collapse">
+        <thead>
+          <tr class="bg-purple-50">
+            <th class="text-left p-3 border border-slate-200 text-purple-800">アプローチ</th>
+            <th class="text-center p-3 border border-slate-200 text-purple-800">時間</th>
+            <th class="text-center p-3 border border-slate-200 text-purple-800">空間</th>
+            <th class="text-left p-3 border border-slate-200 text-purple-800">備考</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr class="bg-emerald-50">
+            <td class="p-3 border border-slate-200 font-semibold text-emerald-800">★ dict前処理 + 再帰（今回採用）</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-emerald-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-emerald-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-600">最速・コード明瞭</td>
+          </tr>
+          <tr class="hover:bg-slate-50">
+            <td class="p-3 border border-slate-200">list.index() + 再帰</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-red-600">O(n²)</td>
+            <td class="p-3 border border-slate-200 text-center">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-500">n=3000 で約450万回比較、TLE リスク</td>
+          </tr>
+          <tr class="hover:bg-slate-50">
+            <td class="p-3 border border-slate-200">反復（スタック）+ dict</td>
+            <td class="p-3 border border-slate-200 text-center font-bold text-sky-700">O(n)</td>
+            <td class="p-3 border border-slate-200 text-center">O(n)</td>
+            <td class="p-3 border border-slate-200 text-slate-500">同速だが実装が複雑</td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <!-- なぜこの計算量になるか -->
+    <div class="mt-5 p-4 rounded-xl bg-emerald-50 border border-emerald-200">
+      <p class="text-emerald-800 font-semibold text-sm mb-2">🔍 なぜ O(n) になるのか</p>
+      <p class="text-slate-700 text-sm leading-7">
+        <strong>ポイント1</strong>：dict の前処理は全要素を1回走査するだけなので O(n)。<br/>
+        <strong>ポイント2</strong>：再帰関数 build は各ノードに対して「1回だけ」呼ばれます。preorder カーソルは単調増加（0→n-1）で、各値を重複なく消費するからです。<br/>
+        <strong>ポイント3</strong>：build の中で行う <code class="bg-white px-1 rounded font-mono text-xs">inorder_dict[val]</code> は平均 O(1) なので、合計 n × O(1) = O(n)。<br/>
+        まとめると O(n) + O(n) = <strong>O(n)</strong> となります。
+      </p>
+    </div>
+  </section>
+
+  <!-- ============================================================ GLOSSARY -->
+  <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+    <h2 class="outfit 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="arrow text-emerald-500">▶</span> inorder（中順探索）
+        </summary>
+        <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+          二分木を「<strong>左部分木 → ルート → 右部分木</strong>」の順に訪れる探索方法。配列中のルートの位置が左右の境界線になるため、preorder と組み合わせると木を一意に復元できます。
+        </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="arrow text-emerald-500">▶</span> O(n²)（オーダーn二乗）
+        </summary>
+        <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+          入力サイズが2倍になると処理時間が約4倍になることを示す計算量記法。二重ループや毎回の線形探索に多く見られます。本問で <code class="bg-slate-100 px-1 rounded font-mono text-xs">list.index()</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="arrow text-emerald-500">▶</span> dict（ハッシュマップ）
+        </summary>
+        <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+          キーから値を平均 <strong>O(1)</strong> で取り出せる Python の組み込みデータ構造。内部はハッシュテーブル（キーのハッシュ値から格納場所を直接計算する仕組み）です。図書館の索引カード（タイトル→棚番号）に例えられます。
+        </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="arrow text-emerald-500">▶</span> nonlocal（ノンローカル宣言）
+        </summary>
+        <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+          内側の関数から外側スコープにある変数を<strong>書き換える</strong>ための Python キーワード。<code class="bg-slate-100 px-1 rounded font-mono text-xs">global</code>（モジュール変数）とは異なり、直近の外側スコープのみが対象。これがないと <code class="bg-slate-100 px-1 rounded font-mono text-xs">+=</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="arrow text-emerald-500">▶</span> preorder（前順探索）
+        </summary>
+        <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+          二分木を「<strong>ルート → 左部分木 → 右部分木</strong>」の順に訪れる探索方法。配列の先頭要素が必ずルートになるという性質があります。
+        </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="arrow text-emerald-500">▶</span> RecursionError（再帰深度エラー）
+        </summary>
+        <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+          Python の再帰深度制限（デフォルト1000回）を超えたときに発生するエラー。完全に偏った木（n=3000）では深さ3000の再帰が起きるため、<code class="bg-slate-100 px-1 rounded font-mono text-xs">sys.setrecursionlimit(10_000)</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="arrow text-emerald-500">▶</span> 再帰（Recursion）
+        </summary>
+        <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+          関数が自分自身を呼び出して問題を小さな部分問題に分解して解く手法。ロシア人形（マトリョーシカ）の入れ子構造に似ており、必ず「これ以上小さくできない＝終了条件」が必要です。
+        </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="arrow text-emerald-500">▶</span> 不変条件（Invariant）
+        </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">preorder[preorder_idx]</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="arrow text-emerald-500">▶</span> 偏った木（Skewed Tree）
+        </summary>
+        <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+          すべてのノードが左だけ・または右だけにつながった、一直線の木。再帰深度が n（ノード数）と等しくなるため最悪ケースとなります。
+        </div>
+      </details>
+
+    </div>
+  </section>
+
+  <!-- footer -->
+  <footer class="text-center text-slate-400 text-xs pb-8">
+    LeetCode 105 – Construct Binary Tree from Preorder and Inorder Traversal | Python (CPython 3.11) 解説ページ
+  </footer>
+
+</div><!-- /max-w-5xl -->
+
+<!-- ============================================================ React Steps Component -->
+<script type="text/babel">
+const { useState, useEffect, useRef } = React;
+
+const PREORDER = [3, 9, 20, 15, 7];
+const INORDER  = [9, 3, 15, 20, 7];
+
+/* ── ツリービジュアライザ ─────────────────────────── */
+// 各ステップで表示するノード情報
+const STEP_NODES = [
+  // step 1: 何も無し
+  [],
+  // step 2: ルート3登場
+  [{ val:3, x:280, y:44, color:"#059669", textColor:"#fff", label:"ルート" }],
+  // step 3: ルート3 + 左子9
+  [
+    { val:3, x:280, y:44, color:"#059669", textColor:"#fff", label:"" },
+    { val:9, x:170, y:124, color:"#0284c7", textColor:"#fff", label:"左" },
+    // edge 3→9
+  ],
+  // step 4: ルート3 + 左9 + 右20
+  [
+    { val:3, x:280, y:44, color:"#059669", textColor:"#fff", label:"" },
+    { val:9, x:170, y:124, color:"#0284c7", textColor:"#fff", label:"左" },
+    { val:20, x:390, y:124, color:"#7c3aed", textColor:"#fff", label:"右" },
+  ],
+  // step 5: 全ノード
+  [
+    { val:3,  x:280, y:44,  color:"#059669", textColor:"#fff", label:"" },
+    { val:9,  x:170, y:124, color:"#0284c7", textColor:"#fff", label:"" },
+    { val:20, x:390, y:124, color:"#7c3aed", textColor:"#fff", label:"" },
+    { val:15, x:320, y:204, color:"#d97706", textColor:"#fff", label:"左" },
+    { val:7,  x:460, y:204, color:"#d97706", textColor:"#fff", label:"右" },
+  ],
+  // step 6: 完成
+  [
+    { val:3,  x:280, y:44,  color:"#059669", textColor:"#fff", label:"✅" },
+    { val:9,  x:170, y:124, color:"#0284c7", textColor:"#fff", label:"" },
+    { val:20, x:390, y:124, color:"#7c3aed", textColor:"#fff", label:"" },
+    { val:15, x:320, y:204, color:"#d97706", textColor:"#fff", label:"" },
+    { val:7,  x:460, y:204, color:"#d97706", textColor:"#fff", label:"" },
+  ],
+];
+
+const EDGES = [
+  { x1:280, y1:64, x2:186, y2:104 },   // 3→9
+  { x1:280, y1:64, x2:374, y2:104 },   // 3→20
+  { x1:390, y1:144, x2:336, y2:184 },  // 20→15
+  { x1:390, y1:144, x2:444, y2:184 },  // 20→7
+];
+
+function TreeViz({ step }) {
+  const nodes = STEP_NODES[step - 1] || [];
+  const visibleEdges = step >= 3 ? (step >= 4 ? (step >= 5 ? EDGES : EDGES.slice(0,2)) : EDGES.slice(0,1)) : [];
+
+  return (
+    <svg viewBox="0 0 560 244" style={{ width:"100%", maxWidth:480, height:"auto", display:"block", margin:"0 auto" }}>
+      {/* edges */}
+      {visibleEdges.map((e, i) => (
+        <line key={i} x1={e.x1} y1={e.y1} x2={e.x2} y2={e.y2}
+              stroke="#94a3b8" strokeWidth="2.5" />
+      ))}
+      {/* nodes */}
+      {nodes.map((n, i) => (
+        <g key={n.val} className="node-pop" style={{ animationDelay: `${i*0.08}s` }}>
+          <circle cx={n.x} cy={n.y} r="22" fill={n.color} stroke="white" strokeWidth="3"
+                  filter="url(#shadow)" />
+          <text x={n.x} y={n.y} textAnchor="middle" dominantBaseline="middle"
+                fontSize="14" fontWeight="bold" fill={n.textColor}
+                fontFamily="'JetBrains Mono',monospace">{n.val}</text>
+          {n.label && (
+            <text x={n.x} y={n.y + 34} textAnchor="middle" fontSize="10"
+                  fill="#475569" fontFamily="'Noto Sans JP',sans-serif">{n.label}</text>
+          )}
+        </g>
+      ))}
+      <defs>
+        <filter id="shadow"><feDropShadow dx="0" dy="2" stdDeviation="3" floodOpacity="0.18"/></filter>
+      </defs>
+    </svg>
+  );
+}
+
+/* ── 変数状態パネル ─────────────────────────────── */
+function VarPanel({ step }) {
+  const states = [
+    { pre_i: "–", lo: "–",  hi: "–",  mid: "–",  root: "–",    note: "初期状態" },
+    { pre_i:  0,  lo:  0,   hi:  4,   mid:  1,   root:  3,     note: "preorder[0]=3 がルート。inorder 中の 3 は位置 1 → mid=1" },
+    { pre_i:  1,  lo:  0,   hi:  0,   mid:  0,   root:  9,     note: "左部分木。preorder[1]=9。inorder の 9 は位置 0 → mid=0" },
+    { pre_i:  2,  lo:  2,   hi:  4,   mid:  3,   root: 20,     note: "右部分木。preorder[2]=20。inorder の 20 は位置 3 → mid=3" },
+    { pre_i:  3,  lo:  2,   hi:  2,   mid:  2,   root: 15,     note: "20 の左子。preorder[3]=15。inorder の 15 は位置 2" },
+    { pre_i:  5,  lo:  "完", hi: "了", mid: "–",  root: "完成！", note: "すべてのノードを処理。ルート TreeNode(3) を返す ✅" },
+  ];
+  const s = states[step - 1] || states[0];
+  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>
+      <div className="grid grid-cols-2 gap-x-4 gap-y-1">
+        <div><span className="text-slate-400">preorder_idx</span> <span className="text-emerald-700 font-bold">= {String(s.pre_i)}</span></div>
+        <div><span className="text-slate-400">root_val</span> <span className="text-purple-700 font-bold">= {String(s.root)}</span></div>
+        <div><span className="text-slate-400">lo</span> <span className="text-sky-700 font-bold">= {String(s.lo)}</span></div>
+        <div><span className="text-slate-400">hi</span> <span className="text-sky-700 font-bold">= {String(s.hi)}</span></div>
+        <div className="col-span-2"><span className="text-slate-400">mid</span> <span className="text-amber-700 font-bold">= {String(s.mid)}</span></div>
+      </div>
+      <div className="mt-2 text-slate-500 font-sans text-xs leading-5 border-t border-slate-200 pt-2">{s.note}</div>
+    </div>
+  );
+}
+
+/* ── ステップデータ ───────────────────────────────── */
+const stepsData = [
+  {
+    step: 1,
+    title: "入力検証と前処理（dict 構築）",
+    desc:
+      "【何をするか】型チェック・長さ確認・空リスト確認を行ったあと、inorder の「値→インデックス」を dict に登録します。\n" +
+      "【なぜか】後の再帰でルートの位置を毎回 O(1) で取り出すためです。list.index() を使うと1回 O(n) の探索が n 回で O(n²) になりますが、dict なら全体で O(n) で済みます。\n" +
+      "【具体例】inorder=[9,3,15,20,7] → {9:0, 3:1, 15:2, 20:3, 7:4}",
+    visual: "dict",
+  },
+  {
+    step: 2,
+    title: "ルートノードを確定（preorder[0]=3）",
+    desc:
+      "【何をするか】preorder の先頭（インデックス 0）の値を取り出して、ルートノードを生成します。\n" +
+      "【なぜか】preorder は「ルート→左→右」の順に並んでいるため、先頭が必ずこの部分木のルートになります。\n" +
+      "【具体例】preorder[0]=3 → TreeNode(3) を生成。カーソルを 0→1 に進める。",
+    visual: "root",
+  },
+  {
+    step: 3,
+    title: "inorder でルート位置を特定し左右を分割",
+    desc:
+      "【何をするか】dict で root_val=3 の inorder 上の位置（mid）を O(1) で取得します。\n" +
+      "【なぜか】mid を境に「inorder[lo..mid-1]＝左部分木」「inorder[mid+1..hi]＝右部分木」と分割できるからです。\n" +
+      "【具体例】inorder_dict[3]=1 → mid=1。左は inorder[0..0]=[9]、右は inorder[2..4]=[15,20,7]。",
+    visual: "split",
+  },
+  {
+    step: 4,
+    title: "左部分木を再帰構築（build(0, mid-1)）",
+    desc:
+      "【何をするか】左の範囲 [lo, mid-1]=[0,0] で build を再帰呼び出しし、node.left に接続します。\n" +
+      "【なぜか】左を先に処理する理由は preorder が「ルート→左→右」順なので、左の再帰が終わると次のカーソル位置に右のルートが来るからです。\n" +
+      "【具体例】build(0,0)：preorder[1]=9、mid=0 → TreeNode(9)。左右とも lo>hi で None。",
+    visual: "left",
+  },
+  {
+    step: 5,
+    title: "右部分木を再帰構築（build(mid+1, hi)）",
+    desc:
+      "【何をするか】右の範囲 [mid+1, hi]=[2,4] で build を再帰呼び出しし、node.right に接続します。\n" +
+      "【なぜか】左の再帰完了後、preorder カーソルは自動的に右部分木のルート位置を指しています。\n" +
+      "【具体例】build(2,4)：preorder[2]=20、mid=3 → TreeNode(20)。さらに build(2,2)→15、build(4,4)→7 を生成。",
+    visual: "right",
+  },
+  {
+    step: 6,
+    title: "完成したノードを返す（return node）",
+    desc:
+      "【何をするか】左右の子が設定されたノードを呼び出し元に返します。\n" +
+      "【なぜか】再帰的に返されたノードが積み重なることで、最終的にルートが得られます。\n" +
+      "【具体例】TreeNode(3, left=TreeNode(9), right=TreeNode(20, left=TreeNode(15), right=TreeNode(7))) が完成し Output=[3,9,20,null,null,15,7] ✅",
+    visual: "done",
+  },
+];
+
+/* ── Steps コンポーネント ────────────────────────── */
+function StepsApp() {
+  const [activeStep, setActiveStep] = useState(1);
+  const [isPlaying, setIsPlaying] = useState(false);
+  const timerRef = useRef(null);
+
+  useEffect(() => {
+    if (isPlaying) {
+      timerRef.current = setTimeout(() => {
+        if (activeStep === stepsData.length) {
+          setActiveStep(1);
+          setIsPlaying(false);
+        } else {
+          setActiveStep(prev => prev + 1);
+        }
+      }, 2200);
+    }
+    return () => { if (timerRef.current) clearTimeout(timerRef.current); };
+  }, [isPlaying, activeStep]);
+
+  const cur = stepsData[activeStep - 1];
+
+  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-lg font-semibold outfit">ステップ一覧</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-sm rounded-xl border-2 transition cursor-pointer px-4 py-3",
+                  isActive
+                    ? "bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 step-active"
+                    : "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 text-sm", isActive ? "text-emerald-900" : "text-teal-800"].join(" ")}>
+                  Step {s.step}: {s.title}
+                </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}）では「{stepsData[activeStep - 2]?.title}」を行いました
+          </div>
+        )}
+
+        <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)] fade-slide" key={activeStep}>
+          <h3 className="mt-0 text-teal-800 text-lg font-bold outfit">
+            Step {cur.step}: {cur.title}
+          </h3>
+          <div className="mt-2 space-y-1">
+            {cur.desc.split("\n").map((line, i) => (
+              <p key={i} className="text-slate-600 text-sm leading-7">{line}</p>
+            ))}
+          </div>
+        </div>
+
+        {/* ツリービジュアライザ */}
+        <div className="mt-4 p-3 rounded-xl bg-white border border-slate-200">
+          <p className="text-xs text-slate-400 mb-1 font-sans">🌳 ツリーの構築状態</p>
+          <TreeViz step={activeStep} />
+        </div>
+
+        {/* 変数状態パネル */}
+        <VarPanel step={activeStep} />
+
+        {/* inorder_dict 表示 */}
+        {activeStep >= 1 && (
+          <div className="mt-3 p-3 rounded-xl bg-emerald-50 border border-emerald-200">
+            <p className="text-xs font-sans text-emerald-700 font-semibold mb-1">📚 inorder_dict（前処理の辞書）</p>
+            <div className="flex flex-wrap gap-2 font-mono text-xs">
+              {INORDER.map((v, i) => (
+                <span key={v}
+                  className={[
+                    "px-2 py-1 rounded-lg border",
+                    activeStep >= 2 && PREORDER.slice(0, activeStep === 6 ? 5 : Math.max(0, activeStep - 2)).includes(v)
+                      ? "bg-emerald-200 border-emerald-500 text-emerald-900"
+                      : "bg-white border-slate-200 text-slate-600"
+                  ].join(" ")}
+                >
+                  {v}:{i}
+                </span>
+              ))}
+            </div>
+            <p className="text-xs text-slate-400 mt-1">ハイライト（緑）＝処理済みのルート</p>
+          </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>
+
+<script>
+  // Prism ハイライト再実行
+  window.addEventListener("load", () => {
+    if (window.Prism) Prism.highlightAll();
+  });
+  // details の arrow アニメーション
+  document.querySelectorAll("details").forEach(d => {
+    d.addEventListener("toggle", () => {
+      const arrow = d.querySelector(".arrow");
+      if (arrow) arrow.style.transform = d.open ? "rotate(90deg)" : "rotate(0deg)";
+    });
+  });
+</script>
+</body>
+</html>
diff --git a/public/Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README_React.html b/public/Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README_React.html
new file mode 100644
index 0000000..7f64755
--- /dev/null
+++ b/public/Algorithm/BinaryTree/leetcode/106. Construct Binary Tree from Inorder and Postorder Traversal/claude sonnet 4.6 extended/README_React.html	
@@ -0,0 +1,1074 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+<meta charset="UTF-8"/>
+<meta name="viewport" content="width=device-width,initial-scale=1.0"/>
+<title>LeetCode 106 · Construct Binary Tree from Inorder and Postorder Traversal</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"/>
+<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>
+<link href="https://fonts.googleapis.com/css2?family=Outfit:wght@600;700;800&family=Source+Serif+4:wght@400;600&family=JetBrains+Mono:wght@400;600&display=swap" rel="stylesheet"/>
+<style>
+  html{scroll-behavior:smooth}
+  body{font-family:'Source Serif 4',serif;background:linear-gradient(135deg,#f0fdf4 0%,#e0f2fe 100%);min-height:100vh}
+  .outfit{font-family:'Outfit',sans-serif}
+  .mono{font-family:'JetBrains Mono',monospace}
+  .code-toolbar>.toolbar .toolbar-item a,
+  .code-toolbar>.toolbar .toolbar-item button,
+  .code-toolbar>.toolbar .toolbar-item span{
+    background:#10b981 !important;color:#fff !important;border-radius:6px !important;
+    padding:3px 10px !important;font-size:12px !important;border:none !important;cursor:pointer !important;
+  }
+  details summary::-webkit-details-marker{display:none}
+  details[open] summary span.arrow{transform:rotate(90deg)}
+  details summary span.arrow{display:inline-block;transition:transform .2s}
+</style>
+</head>
+<body class="py-6 px-3 md:px-8">
+<div class="max-w-5xl mx-auto">
+
+<!-- ===== HEADER ===== -->
+<header id="header" class="mb-8 rounded-2xl p-8 shadow-[0_10px_30px_rgba(16,185,129,0.14)] bg-[linear-gradient(135deg,#d1fae5,#bfdbfe)]">
+  <div class="flex flex-wrap items-center gap-3 mb-2">
+    <span class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit">LeetCode 106</span>
+    <span class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit">Medium</span>
+    <span class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit">二分木 / 再帰 / HashMap</span>
+  </div>
+  <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+    Construct Binary Tree from<br/>Inorder and Postorder Traversal
+  </h1>
+  <p class="text-base text-cyan-700 font-semibold mt-1 outfit">
+    HashMap 事前構築 + 再帰分割 による O(n) 実装
+  </p>
+  <div class="mt-3 text-base text-teal-800 bg-white/60 rounded-xl px-4 py-2 inline-block">
+    💡 一言で言うと：「2種類の巡回記録から元の二分木を復元する問題」
+  </div>
+  <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="outfit 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">
+      💡 この問題を一言で言うと：「2種類の木の巡回記録（Inorder・Postorder）を手がかりに、元の二分木の形を復元する問題」
+    </p>
+    <p class="text-slate-600 text-sm mt-2 leading-7">
+      二分木を「巡回する順番のルール」が複数あり、<strong>Postorderの末尾要素は必ずその部分木のルート（根）</strong>になります。この性質とHashMapを組み合わせることで、配列コピーなしにO(n)で木を再構築できます。
+    </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 leading-7">
+      <li><code class="bg-amber-100 px-1 rounded mono text-xs">list.index()</code> でルート位置を毎回探すと O(n) × n回 ＝ <strong>O(n²)</strong> になりTLEになる（n=3000で最大900万回の操作）</li>
+      <li>配列をスライスしてコピーしながら再帰すると O(n²) のメモリが必要になりMLEになる</li>
+      <li>Pythonのデフォルト再帰上限は1000。偏った木ではn=3000段の再帰が必要になるため <code class="bg-amber-100 px-1 rounded mono text-xs">sys.setrecursionlimit</code> が必須</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-base font-mono break-all leading-tight">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-base font-mono break-all leading-tight">O(n)</div>
+      <div class="text-xs mt-1">空間計算量</div>
+    </div>
+    <div style="background:#fef3c7;color:#92400e" class="rounded-xl p-3 text-center">
+      <div class="font-bold text-xs font-mono break-all leading-tight">HashMap+再帰</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">≤ 3000</div>
+      <div class="text-xs mt-1">入力サイズ上限</div>
+    </div>
+  </div>
+
+  <!-- 入出力例 -->
+  <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-4">
+    <div class="rounded-xl border border-slate-200 p-4 bg-slate-50">
+      <p class="text-slate-500 text-xs font-semibold mb-2 mono">入力</p>
+      <pre class="text-slate-800 text-sm mono">inorder   = [9, 3, 15, 20, 7]
+postorder = [9, 15, 7, 20, 3]</pre>
+    </div>
+    <div class="rounded-xl border border-emerald-200 p-4 bg-emerald-50">
+      <p class="text-emerald-600 text-xs font-semibold mb-2 mono">出力（木の形）</p>
+      <pre class="text-slate-800 text-sm mono">      3
+     / \
+    9   20
+       /  \
+      15    7</pre>
+    </div>
+  </div>
+  <p class="text-slate-600 text-sm leading-7">
+    <strong class="text-teal-700">なぜこれが正解か：</strong>
+    postorderの末尾<code class="bg-slate-100 px-1 rounded mono text-xs">3</code>がルート → inorderで<code class="bg-slate-100 px-1 rounded mono text-xs">3</code>の左が<code class="bg-slate-100 px-1 rounded mono text-xs">[9]</code>（左部分木）、右が<code class="bg-slate-100 px-1 rounded mono text-xs">[15,20,7]</code>（右部分木）と特定できる。この操作を再帰的に繰り返すことで木全体を復元できる。
+  </p>
+</section>
+
+<!-- ===== STEPS (React) ===== -->
+<section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+  <h2 class="outfit 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-6">▶ Play ボタンで自動再生、Prev/Next で手動操作できます。</p>
+  <div id="react-steps"></div>
+</section>
+
+<!-- ===== CODE ===== -->
+<section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+  <h2 class="outfit 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 leading-7">
+      <li><strong>再帰上限引き上げ</strong>：完全偏り木でも安全に動作させるため <code class="bg-emerald-100 px-1 rounded mono text-xs">sys.setrecursionlimit(10_000)</code> を設定</li>
+      <li><strong>HashMap構築</strong>：<code class="bg-emerald-100 px-1 rounded mono text-xs">idx_map = {v: i for i, v in enumerate(inorder)}</code> で O(1) 検索を可能にする</li>
+      <li><strong>ポインタ初期化</strong>：<code class="bg-emerald-100 px-1 rounded mono text-xs">post_idx = [len(postorder) - 1]</code> で末尾からルートを消費するカーソルを設置</li>
+      <li><strong>再帰ヘルパー dfs</strong>：終了条件チェック → ルート取得 → 右部分木を先に再帰 → 左部分木を再帰 → ノード返却</li>
+    </ol>
+  </div>
+
+  <pre class="line-numbers"><code class="language-python">import sys
+from typing import Optional, List
+
+class Solution:
+    def buildTree(
+        self,
+        inorder: List[int],
+        postorder: List[int]
+    ) -&gt; Optional[TreeNode]:
+        # Python のデフォルト再帰上限は 1000。
+        # 完全偏り木では n=3000 段の再帰が必要になるため上限を引き上げる。
+        sys.setrecursionlimit(10_000)
+
+        # dict 内包表記で「値 → inorder のインデックス」を O(n) で1回だけ構築。
+        # list.index() を毎回呼ぶと O(n²) になるため、事前構築で O(1) 検索を実現。
+        idx_map: dict[int, int] = {v: i for i, v in enumerate(inorder)}
+
+        # post_idx をリストで包む慣用句。
+        # 内側関数から外側の int を書き換えるには nonlocal が必要だが、
+        # リストに包むことで「リストの中身を変える」操作になり nonlocal 不要になる。
+        post_idx: List[int] = [len(postorder) - 1]
+
+        def dfs(left: int, right: int) -&gt; Optional[TreeNode]:
+            # 終了条件：左端が右端を超えた = この範囲に要素がない = 部分木なし
+            if left &gt; right:
+                return None
+
+            # postorder の末尾から現在の部分木のルートを取り出す。
+            # list のインデックスアクセスは O(1)。カーソルを1つ前に進める。
+            val: int = postorder[post_idx[0]]
+            post_idx[0] -= 1
+
+            # ルートノードを作成する。
+            node = TreeNode(val)
+
+            # dict から O(1) でルートの inorder 上の位置を取得する。
+            # この位置より「左側」が左部分木、「右側」が右部分木になる。
+            mid: int = idx_map[val]
+
+            # ★重要★ 右部分木を先に再帰する理由：
+            # postorder を末尾から逆順に消費すると「ルート→右→左」の順になる。
+            # つまり次の pop は「右部分木のルート」を指している。
+            # 左を先にすると消費順序がずれて誤った木になってしまう。
+            node.right = dfs(mid + 1, right)  # 右：mid+1 〜 right
+            node.left  = dfs(left, mid - 1)   # 左：left 〜 mid-1
+
+            return node
+
+        # inorder の全範囲（0 〜 n-1）を対象に木を構築して返す
+        return dfs(0, len(inorder) - 1)</code></pre>
+
+  <div class="mt-5 p-4 rounded-xl bg-sky-50 border border-sky-200">
+    <p class="text-sky-800 font-semibold text-sm mb-3">▶ 入力例 <code class="bg-sky-100 px-1 rounded mono text-xs">inorder=[9,3,15,20,7], postorder=[9,15,7,20,3]</code> での動作トレース</p>
+    <pre class="text-slate-700 text-xs mono leading-6 overflow-x-auto whitespace-pre">事前準備:
+  idx_map   = { 9:0, 3:1, 15:2, 20:3, 7:4 }
+  post_idx  = [4]  ← postorder の末尾インデックス
+
+dfs(0, 4)  ← inorder 全体の範囲
+  val = postorder[4] = 3    post_idx: [4]→[3]
+  mid = idx_map[3] = 1
+  node = TreeNode(3)
+  ├─ node.right = dfs(2, 4)
+  │    val = postorder[3] = 20   post_idx: [3]→[2]
+  │    mid = idx_map[20] = 3
+  │    node = TreeNode(20)
+  │    ├─ node.right = dfs(4, 4)
+  │    │    val = postorder[2] = 7    post_idx: [2]→[1]
+  │    │    node = TreeNode(7) ← 葉ノード（左右None）
+  │    │    return TreeNode(7) ✅
+  │    └─ node.left = dfs(2, 2)
+  │         val = postorder[1] = 15   post_idx: [1]→[0]
+  │         node = TreeNode(15) ← 葉ノード
+  │         return TreeNode(15) ✅
+  │    return TreeNode(20) ✅
+  └─ node.left = dfs(0, 0)
+       val = postorder[0] = 9    post_idx: [0]→[-1]
+       node = TreeNode(9) ← 葉ノード
+       return TreeNode(9) ✅
+
+最終結果:
+      3
+     / \
+    9   20
+       /  \
+      15    7   ✅</pre>
+  </div>
+</section>
+
+<!-- ===== DIAGRAM ===== -->
+<section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+  <h2 class="outfit 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="26" height="18"><ellipse cx="13" cy="9" rx="12" ry="8" fill="#d1fae5" stroke="#10b981" stroke-width="1.5"/></svg>
+        <span>楕円（緑）＝ 開始・終了</span>
+      </div>
+      <div class="flex items-center gap-2">
+        <svg width="26" height="18"><rect x="1" y="2" width="24" height="14" rx="3" fill="#e0f2fe" stroke="#0284c7" stroke-width="1.5"/></svg>
+        <span>四角（青）＝ 処理ステップ</span>
+      </div>
+      <div class="flex items-center gap-2">
+        <svg width="26" height="18"><polygon points="13,1 25,9 13,17 1,9" fill="#fef3c7" stroke="#f59e0b" stroke-width="1.5"/></svg>
+        <span>ひし形（黄）＝ 条件分岐</span>
+      </div>
+      <div class="flex items-center gap-2 col-span-2 md:col-span-1">
+        <span class="inline-block w-4 h-0.5 bg-emerald-500 mr-1"></span><span class="text-xs">緑＝はい</span>
+        <span class="inline-block w-4 h-0.5 bg-red-500 mx-1"></span><span class="text-xs">赤＝いいえ</span>
+      </div>
+    </div>
+  </div>
+
+  <div class="mt-5 overflow-x-auto">
+    <!--
+      SVG設計 (静的HTML → ケバブケース属性を使用)
+      viewBox: 0 0 560 1165
+      center x = 280, box: x=60 width=440
+      最終楕円: cy=1120, ry=28 → 下端=1148 + 余白17 = 1165
+    -->
+    <svg
+      viewBox="0 0 560 1165"
+      style="max-width:560px;width:100%;height:auto;display:block;margin:0 auto;"
+      role="img"
+      aria-label="LeetCode 106 flowchart"
+    >
+      <defs>
+        <marker id="fc-arrow" markerWidth="10" markerHeight="10" refX="9" refY="3" orient="auto" marker-units="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" marker-units="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" marker-units="strokeWidth">
+          <path d="M0,0 L0,6 L9,3 z" fill="#dc2626"/>
+        </marker>
+        <marker id="fc-arrowPurple" markerWidth="10" markerHeight="10" refX="9" refY="3" orient="auto" marker-units="strokeWidth">
+          <path d="M0,0 L0,6 L9,3 z" fill="#a855f7"/>
+        </marker>
+      </defs>
+
+      <!-- ===== NODE 1: START ===== -->
+      <!-- 楕円: cx=280 cy=50 rx=160 ry=28 → bottom=78 -->
+      <ellipse cx="280" cy="50" rx="160" ry="28" fill="#d1fae5" stroke="#059669" stroke-width="2"/>
+      <text x="280" y="50" text-anchor="middle" dominant-baseline="middle" font-size="14" font-weight="bold" fill="#065f46" font-family="sans-serif">buildTree 開始</text>
+
+      <!-- arrow 78→110 -->
+      <line x1="280" y1="78" x2="280" y2="108" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== NODE 2: EMPTY CHECK (diamond) ===== -->
+      <!-- diamond: center(280,140), half-w=150, half-h=40 → top=100, bottom=180, right=430, left=130 -->
+      <polygon points="280,100 430,140 280,180 130,140" fill="#fef3c7" stroke="#f59e0b" stroke-width="2"/>
+      <text x="280" y="134" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#92400e" font-family="sans-serif">inorder が空？</text>
+      <text x="280" y="152" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#92400e" font-family="sans-serif">len(inorder) == 0</text>
+
+      <!-- Yes → right → None ellipse -->
+      <line x1="430" y1="140" x2="495" y2="140" stroke="#059669" stroke-width="2" marker-end="url(#fc-arrowGreen)"/>
+      <text x="454" y="131" text-anchor="middle" font-size="11" fill="#059669" font-family="sans-serif" font-weight="bold">はい</text>
+      <ellipse cx="520" cy="140" rx="38" ry="22" fill="#d1fae5" stroke="#059669" stroke-width="1.5"/>
+      <text x="520" y="140" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#065f46" font-family="sans-serif" font-weight="bold">None</text>
+
+      <!-- No → down arrow 180→210 -->
+      <line x1="280" y1="180" x2="280" y2="208" stroke="#dc2626" stroke-width="2" marker-end="url(#fc-arrowRed)"/>
+      <text x="258" y="196" text-anchor="middle" font-size="11" fill="#dc2626" font-family="sans-serif" font-weight="bold">いいえ</text>
+
+      <!-- ===== NODE 3: BUILD idx_map ===== -->
+      <!-- rect: y=210, h=65, bottom=275 -->
+      <rect x="60" y="210" width="440" height="65" rx="10" fill="#e0f2fe" stroke="#0284c7" stroke-width="2"/>
+      <text x="280" y="233" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#1e40af" font-family="sans-serif">① idx_map を構築</text>
+      <line x1="80" y1="248" x2="480" y2="248" stroke="#bfdbfe" stroke-width="1"/>
+      <text x="280" y="263" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="monospace">{v: i for i, v in enumerate(inorder)}</text>
+
+      <!-- arrow 275→305 -->
+      <line x1="280" y1="275" x2="280" y2="303" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== NODE 4: SET post_idx ===== -->
+      <!-- rect: y=305, h=60, bottom=365 -->
+      <rect x="60" y="305" width="440" height="60" rx="10" fill="#e0f2fe" stroke="#0284c7" stroke-width="2"/>
+      <text x="280" y="326" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#1e40af" font-family="sans-serif">② post_idx を末尾インデックスに設定</text>
+      <line x1="80" y1="341" x2="480" y2="341" stroke="#bfdbfe" stroke-width="1"/>
+      <text x="280" y="356" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="monospace">post_idx = [len(postorder) - 1]</text>
+
+      <!-- arrow 365→395 -->
+      <line x1="280" y1="365" x2="280" y2="393" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== dfs subgraph background ===== -->
+      <rect x="30" y="395" width="500" height="645" rx="14" fill="#f8fafc" stroke="#cbd5e1" stroke-width="1.5" stroke-dasharray="6,3"/>
+      <text x="55" y="418" font-size="11" fill="#94a3b8" font-family="sans-serif" font-weight="bold">dfs ヘルパー関数</text>
+
+      <!-- ===== NODE 5: CALL dfs ===== -->
+      <!-- rect: y=425, h=55, bottom=480 -->
+      <rect x="60" y="425" width="440" height="55" rx="10" fill="#d1fae5" stroke="#059669" stroke-width="2"/>
+      <text x="280" y="445" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#065f46" font-family="sans-serif">③ dfs(0, n-1) 呼び出し</text>
+      <line x1="80" y1="460" x2="480" y2="460" stroke="#a7f3d0" stroke-width="1"/>
+      <text x="280" y="474" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#065f46" font-family="monospace">inorder の全範囲を対象に再帰開始</text>
+
+      <!-- arrow 480→510 -->
+      <line x1="280" y1="480" x2="280" y2="508" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== NODE 6: BASE CASE (diamond) ===== -->
+      <!-- diamond: center(280,545), half-w=145, half-h=40 → top=505, bottom=585, right=425, left=135 -->
+      <polygon points="280,505 425,545 280,585 135,545" fill="#fef3c7" stroke="#f59e0b" stroke-width="2"/>
+      <text x="280" y="539" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#92400e" font-family="sans-serif">④ left &gt; right ?</text>
+      <text x="280" y="557" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#92400e" font-family="sans-serif">部分木が空の場合</text>
+
+      <!-- Yes → right → None -->
+      <line x1="425" y1="545" x2="495" y2="545" stroke="#059669" stroke-width="2" marker-end="url(#fc-arrowGreen)"/>
+      <text x="452" y="536" text-anchor="middle" font-size="11" fill="#059669" font-family="sans-serif" font-weight="bold">はい</text>
+      <ellipse cx="520" cy="545" rx="38" ry="22" fill="#d1fae5" stroke="#059669" stroke-width="1.5"/>
+      <text x="520" y="545" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#065f46" font-family="sans-serif" font-weight="bold">None</text>
+
+      <!-- No → down 585→615 -->
+      <line x1="280" y1="585" x2="280" y2="613" stroke="#dc2626" stroke-width="2" marker-end="url(#fc-arrowRed)"/>
+      <text x="258" y="601" text-anchor="middle" font-size="11" fill="#dc2626" font-family="sans-serif" font-weight="bold">いいえ</text>
+
+      <!-- ===== NODE 7: POP ROOT ===== -->
+      <!-- rect: y=615, h=65, bottom=680 -->
+      <rect x="60" y="615" width="440" height="65" rx="10" fill="#e0f2fe" stroke="#0284c7" stroke-width="2"/>
+      <text x="280" y="637" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#1e40af" font-family="sans-serif">⑤ postorder 末尾からルートを取得</text>
+      <line x1="80" y1="653" x2="480" y2="653" stroke="#bfdbfe" stroke-width="1"/>
+      <text x="280" y="668" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="monospace">val = postorder[post_idx[0]]; post_idx[0] -= 1</text>
+
+      <!-- arrow 680→710 -->
+      <line x1="280" y1="680" x2="280" y2="708" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== NODE 8: CREATE NODE + LOOKUP mid ===== -->
+      <!-- rect: y=710, h=75, bottom=785 -->
+      <rect x="60" y="710" width="440" height="75" rx="10" fill="#e0f2fe" stroke="#0284c7" stroke-width="2"/>
+      <text x="280" y="732" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#1e40af" font-family="sans-serif">⑥ ノード作成 &amp; mid を O(1) で検索</text>
+      <line x1="80" y1="748" x2="480" y2="748" stroke="#bfdbfe" stroke-width="1"/>
+      <text x="280" y="763" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="monospace">node = TreeNode(val)</text>
+      <text x="280" y="778" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#1e40af" font-family="monospace">mid = idx_map[val]  # O(1)</text>
+
+      <!-- arrow 785→815 -->
+      <line x1="280" y1="785" x2="280" y2="813" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== NODE 9: RECURSE RIGHT ===== -->
+      <!-- rect: y=815, h=60, bottom=875 -->
+      <rect x="60" y="815" width="440" height="60" rx="10" fill="#ede9fe" stroke="#7c3aed" stroke-width="2"/>
+      <text x="280" y="836" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#5b21b6" font-family="sans-serif">⑦ 右部分木を先に再帰 ★重要★</text>
+      <line x1="80" y1="851" x2="480" y2="851" stroke="#ddd6fe" stroke-width="1"/>
+      <text x="280" y="866" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#5b21b6" font-family="monospace">node.right = dfs(mid + 1, right)</text>
+
+      <!-- arrow 875→905 -->
+      <line x1="280" y1="875" x2="280" y2="903" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== NODE 10: RECURSE LEFT ===== -->
+      <!-- rect: y=905, h=60, bottom=965 -->
+      <rect x="60" y="905" width="440" height="60" rx="10" fill="#ede9fe" stroke="#7c3aed" stroke-width="2"/>
+      <text x="280" y="926" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#5b21b6" font-family="sans-serif">⑧ 左部分木を再帰</text>
+      <line x1="80" y1="941" x2="480" y2="941" stroke="#ddd6fe" stroke-width="1"/>
+      <text x="280" y="956" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#5b21b6" font-family="monospace">node.left = dfs(left, mid - 1)</text>
+
+      <!-- arrow 965→995 -->
+      <line x1="280" y1="965" x2="280" y2="993" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== NODE 11: ATTACH & RETURN ===== -->
+      <!-- rect: y=995, h=55, bottom=1050 -->
+      <rect x="60" y="995" width="440" height="55" rx="10" fill="#d1fae5" stroke="#059669" stroke-width="2"/>
+      <text x="280" y="1015" text-anchor="middle" dominant-baseline="middle" font-size="13" font-weight="bold" fill="#065f46" font-family="sans-serif">⑨ 子ノードを設定して返す</text>
+      <line x1="80" y1="1030" x2="480" y2="1030" stroke="#a7f3d0" stroke-width="1"/>
+      <text x="280" y="1044" text-anchor="middle" dominant-baseline="middle" font-size="11" fill="#065f46" font-family="monospace">return node</text>
+
+      <!-- arrow 1050→1082 -->
+      <line x1="280" y1="1050" x2="280" y2="1090" stroke="#64748b" stroke-width="2" marker-end="url(#fc-arrow)"/>
+
+      <!-- ===== NODE 12: END ===== -->
+      <!-- ellipse cy=1120 ry=28 → bottom=1148 -->
+      <ellipse cx="280" cy="1120" rx="155" ry="28" fill="#d1fae5" stroke="#059669" stroke-width="2"/>
+      <text x="280" y="1120" text-anchor="middle" dominant-baseline="middle" font-size="14" font-weight="bold" fill="#065f46" font-family="sans-serif">buildTree 完了・木を返す</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">🔎 入力例 <code class="bg-slate-200 px-1 rounded mono text-xs">inorder=[9,3,15,20,7], postorder=[9,15,7,20,3]</code> でのフロー追跡</p>
+    <ol class="text-slate-600 text-sm space-y-2 list-decimal list-inside leading-7">
+      <li>「buildTree 開始」→ inorder=[9,3,15,20,7] を受け取る（空でない → いいえ経路へ）</li>
+      <li>「idx_map を構築」→ <code class="bg-slate-100 px-1 rounded mono text-xs">{9:0, 3:1, 15:2, 20:3, 7:4}</code> を O(n)で生成</li>
+      <li>「post_idx を設定」→ <code class="bg-slate-100 px-1 rounded mono text-xs">post_idx=[4]</code>（末尾インデックス）</li>
+      <li>「dfs(0, 4) 呼び出し」→ left=0, right=4、終了条件チェック: 0 ≤ 4 → いいえ経路へ</li>
+      <li>「ルートを取得」→ <code class="bg-slate-100 px-1 rounded mono text-xs">val=postorder[4]=3</code>、post_idx=[3]</li>
+      <li>「ノード作成・mid検索」→ <code class="bg-slate-100 px-1 rounded mono text-xs">node=TreeNode(3)</code>、<code class="bg-slate-100 px-1 rounded mono text-xs">mid=idx_map[3]=1</code></li>
+      <li>「右部分木を先に再帰」→ <code class="bg-slate-100 px-1 rounded mono text-xs">dfs(2, 4)</code> でルート20の部分木を構築</li>
+      <li>「左部分木を再帰」→ <code class="bg-slate-100 px-1 rounded mono text-xs">dfs(0, 0)</code> でルート9の葉ノードを構築</li>
+      <li>「完了・木を返す」→ ルート TreeNode(3) を返す ✅</li>
+    </ol>
+  </div>
+
+  <div class="mt-5 p-4 rounded-xl bg-violet-50 border border-violet-200">
+    <p class="text-violet-800 font-semibold text-sm mb-1">⚡ なぜ「右を先に再帰する」のか？</p>
+    <p class="text-slate-700 text-sm leading-7">Postorderは「左→右→自分」の順なので、<strong>末尾から逆順に取り出すと「自分→右→左」の順になります</strong>。post_idxのカーソルを進めた直後に来る次の末尾要素は常に「右部分木のルート」です。左を先に再帰してしまうとカーソルがずれ、誤ったノードをルートにしてしまいます。</p>
+  </div>
+</section>
+
+<!-- ===== COMPLEXITY ===== -->
+<section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+  <h2 class="outfit 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 mono text-base mb-1">O(1)</div>
+        <div class="leading-5">常に一定<br/><span class="text-emerald-600">例：dict の直接引き</span></div>
+      </div>
+      <div class="text-center p-3 rounded-lg bg-sky-100 text-sky-800">
+        <div class="font-bold 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 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 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-5">
+    <table class="w-full text-sm border-collapse">
+      <thead>
+        <tr class="bg-teal-50">
+          <th class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-bold outfit">種別</th>
+          <th class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-bold outfit">計算量</th>
+          <th class="border border-slate-200 px-4 py-3 text-left text-teal-800 font-bold outfit">内訳</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr class="bg-white hover:bg-emerald-50 transition">
+          <td class="border border-slate-200 px-4 py-3 font-semibold text-teal-700">時間計算量</td>
+          <td class="border border-slate-200 px-4 py-3"><span class="mono font-bold text-emerald-700 bg-emerald-100 px-2 py-0.5 rounded">O(n)</span></td>
+          <td class="border border-slate-200 px-4 py-3 text-slate-600">idx_map 構築 O(n) + 各ノードを1回だけ処理 O(n) = O(n)</td>
+        </tr>
+        <tr class="bg-slate-50 hover:bg-sky-50 transition">
+          <td class="border border-slate-200 px-4 py-3 font-semibold text-teal-700">空間計算量</td>
+          <td class="border border-slate-200 px-4 py-3"><span class="mono font-bold text-sky-700 bg-sky-100 px-2 py-0.5 rounded">O(n)</span></td>
+          <td class="border border-slate-200 px-4 py-3 text-slate-600">idx_map O(n) + 再帰スタック O(h)（h=木の高さ、最悪 O(n)）+ 出力ノード O(n)</td>
+        </tr>
+        <tr class="bg-white">
+          <td class="border border-slate-200 px-4 py-3 font-semibold text-red-600">⚠️ 比較：ナイーブ版</td>
+          <td class="border border-slate-200 px-4 py-3"><span class="mono font-bold text-red-700 bg-red-100 px-2 py-0.5 rounded">O(n²)</span></td>
+          <td class="border border-slate-200 px-4 py-3 text-slate-600"><code class="bg-red-50 px-1 rounded mono text-xs">list.index()</code> を毎回呼ぶと O(n) × n回 = O(n²)。n=3000で最大900万操作。</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>：<code class="bg-emerald-100 px-1 rounded mono text-xs">idx_map</code>の構築はenumerate()で1回だけ走査するのでO(n)。dfs()はn個のノードそれぞれを1回だけ処理し、各処理内のdict検索とpop()はO(1)なので合計O(n)。全体でO(n)+O(n)=O(n)。
+    </p>
+    <p class="text-slate-700 text-sm leading-7 mt-2">
+      <strong>空間O(n)の理由</strong>：<code class="bg-emerald-100 px-1 rounded mono text-xs">idx_map</code>にn個のエントリを格納するのでO(n)。再帰スタックは木の高さh分だけ積まれるが、完全に偏った木では h=n になるので最悪O(n)。出力の木もn個のノードを作成するのでO(n)。
+    </p>
+  </div>
+</section>
+
+<!-- ===== GLOSSARY ===== -->
+<section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+  <h2 class="outfit 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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> 後順走査（Postorder Traversal）
+      </summary>
+      <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+        「左の子 → 右の子 → 自分（ルート）」の順でノードを訪れる走査方法。
+        <strong>配列の末尾要素が必ずその部分木のルートになる</strong>という性質がこのアルゴリズムの核心。
+        例：ルート=3の木では postorder=[9, 15, 7, 20, <strong>3</strong>] のように末尾に3が来る。
+      </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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> 中順走査（Inorder Traversal）
+      </summary>
+      <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+        「左の子 → 自分（ルート） → 右の子」の順でノードを訪れる走査方法。
+        ルートのインデックスが分かると、<strong>そのインデックスの左側が左部分木・右側が右部分木</strong>という分割ができる。
+        例：inorder=[9, <strong>3</strong>, 15, 20, 7]でルート=3なら、左部分木=[9]、右部分木=[15,20,7]。
+      </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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> dict（ハッシュテーブル / 辞書）
+      </summary>
+      <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+        「キー → 値」の対応を <strong>O(1)（＝入力サイズに関わらず常に一定の時間）</strong>で検索できるデータ構造。
+        図書館の索引カードのようなもので、タイトル（キー）から棚番号（値）を瞬時に引ける。
+        このアルゴリズムでは <code class="bg-slate-100 px-1 rounded mono text-xs">idx_map = {v: i for i, v in enumerate(inorder)}</code> で
+        「値 → inorderでの位置番号」を記録し、ルートの位置を O(n)→<strong>O(1)</strong>に短縮している。
+      </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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> 再帰（Recursion）
+      </summary>
+      <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+        関数が自分自身を呼び出すことで問題を分割して解く手法。
+        「大きな問題 = 小さな問題 × 2 + 少しの処理」の構造を持つ木の問題に適している。
+        必ず<strong>終了条件（再帰の底）</strong>が必要で、このコードでは <code class="bg-slate-100 px-1 rounded mono text-xs">if left &gt; right: return 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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> 再帰スタック（Call Stack）
+      </summary>
+      <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+        再帰呼び出しが積み重なるメモリ領域。お皿の積み重ねと同じで、最後に呼んだ関数が最初に終わる（LIFO）。
+        木の高さ h 段分だけ積まれるため、<strong>完全偏り木（全ノードが一方向に連なる）ではh=nになり、デフォルト上限1000を超える可能性</strong>がある。
+        <code class="bg-slate-100 px-1 rounded mono text-xs">sys.setrecursionlimit(10_000)</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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> dict 内包表記
+      </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 mono text-xs">{k: v for ...}</code> の形で dict を1行で作る Python の書き方。
+        通常の for ループより <strong>CPython（＝最も広く使われる Python の実装）内部で最適化された命令</strong>を使うため高速。
+        <code class="bg-slate-100 px-1 rounded mono text-xs">{v: i for i, v in enumerate(inorder)}</code> は
+        「inorder の値 → そのインデックス」を O(n) で一括構築する。
+      </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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> TLE（Time Limit Exceeded）
+      </summary>
+      <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+        LeetCode などの競技プログラミングサイトで、処理時間が制限を超えたときに表示されるエラー。
+        <code class="bg-slate-100 px-1 rounded mono text-xs">list.index()</code> を毎回呼ぶナイーブな実装は O(n²) になり、
+        n=3000 で最大<strong>900万回</strong>の操作が必要になるため TLE になる可能性がある。
+      </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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> ルート / 葉ノード（Root / Leaf Node）
+      </summary>
+      <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+        <strong>ルート（根）</strong>：木の最上位ノード。この問題では postorder の末尾がルートになる。
+        <strong>葉ノード</strong>：左右の子を持たない末端ノード。再帰の終了時に <code class="bg-slate-100 px-1 rounded mono text-xs">left == right</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 list-none flex items-center gap-2">
+        <span class="text-emerald-500 arrow">▶</span> 部分木（Subtree）
+      </summary>
+      <div class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200">
+        ある木のノードを根（ルート）とした木の一部分のこと。
+        このアルゴリズムは「全体 = 左部分木 + ルート + 右部分木」という性質を利用して再帰的に問題を分割している。
+        dfs(left, right) の引数 left/right は「inorder 上でこの部分木が占める範囲のインデックス」を表す。
+      </div>
+    </details>
+
+  </div>
+</section>
+
+<!-- FOOTER -->
+<footer class="text-center text-slate-400 text-xs pb-6">
+  LeetCode 106 · Python (CPython 3.11+) · Time O(n) · Space O(n) · HashMap + 再帰分割
+</footer>
+
+</div><!-- /max-w-5xl -->
+
+<!-- ===== REACT STEPS COMPONENT ===== -->
+<script type="text/babel">
+const { useState, useEffect, useRef } = React;
+
+const INORDER   = [9, 3, 15, 20, 7];
+const POSTORDER = [9, 15, 7, 20, 3];
+const IDX_MAP   = { 9:0, 3:1, 15:2, 20:3, 7:4 };
+
+const stepsData = [
+  {
+    step: 1,
+    title: "HashMap を事前構築する",
+    desc: "「inorderの値 → そのインデックス」を辞書に記録します。\n" +
+          "なぜなら、ルートが inorder のどこにあるかを毎回 list.index() で探すと O(n) × n回 = O(n²) になってしまうからです。\n" +
+          "例）inorder=[9,3,15,20,7] から {9:0, 3:1, 15:2, 20:3, 7:4} を構築。これで任意の値の位置を O(1) で引けます。",
+    visual: "build_map"
+  },
+  {
+    step: 2,
+    title: "postorder ポインタを末尾に設定",
+    desc: "postorder を末尾から逆順に消費するためのカーソルを末尾インデックスに設定します。\n" +
+          "Postorderは「左→右→自分(ルート)」の順なので、末尾が必ず現在の部分木のルートです。\n" +
+          "例）postorder=[9,15,7,20,3] → post_idx=[4]。postorder[4]=3 が全体のルートになります。",
+    visual: "set_pointer"
+  },
+  {
+    step: 3,
+    title: "再帰の終了条件をチェック",
+    desc: "dfs(left, right) が呼ばれるたびに left > right かどうかを確認します。\n" +
+          "left > right は「この範囲に要素が0個」を意味し、部分木が存在しないことを表します。\n" +
+          "例）葉ノード(値7)の左子を求めるとき dfs(5, 4) が呼ばれ、5>4 なので None を返します。",
+    visual: "base_case"
+  },
+  {
+    step: 4,
+    title: "末尾からルートを取り出す",
+    desc: "postorder[post_idx[0]] でルートの値を取得し、post_idx[0] を1減らします。\n" +
+          "list の末尾アクセスは O(1)（先頭の list.pop(0) は O(n) なので使いません）。\n" +
+          "例）post_idx=[4] → val=postorder[4]=3、その後 post_idx=[3]（次回は20がルートになる）。",
+    visual: "pop_root"
+  },
+  {
+    step: 5,
+    title: "inorder でルートの位置（mid）を O(1) 取得",
+    desc: "idx_map[val] でルートが inorder のどこにあるかを O(1) で取得し、左右の範囲を決めます。\n" +
+          "mid より左が左部分木の inorder 範囲、mid より右が右部分木の inorder 範囲になります。\n" +
+          "例）val=3 → mid=idx_map[3]=1。左範囲=[0..0]=[9]、右範囲=[2..4]=[15,20,7]。",
+    visual: "lookup_mid"
+  },
+  {
+    step: 6,
+    title: "右部分木を先に再帰する（★重要★）",
+    desc: "dfs(mid+1, right) で右部分木を先に再帰します。左より先に右を処理することが必須です。\n" +
+          "postorder を末尾から逆順消費すると「ルート→右→左」の順になるため、右を先に処理しないとポインタがずれます。\n" +
+          "例）mid=1 → dfs(2, 4) を呼ぶ。次の post_idx[0]=3 → postorder[3]=20 が右部分木のルートになります。",
+    visual: "recurse_right"
+  },
+  {
+    step: 7,
+    title: "左部分木を再帰する",
+    desc: "dfs(left, mid-1) で左部分木を再帰します。右部分木の再帰がすべて完了した後に呼ばれます。\n" +
+          "右部分木の全ノードが先に消費されているため、このタイミングで post_idx が正しく左部分木のルートを指しています。\n" +
+          "例）右部分木(20,15,7)の処理後に post_idx[0]=0 → postorder[0]=9 が左部分木のルートになります。",
+    visual: "recurse_left"
+  },
+  {
+    step: 8,
+    title: "子ノードを設定してノードを返す",
+    desc: "左右の再帰から返ってきたノードを node.left / node.right に設定し、完成したノードを返します。\n" +
+          "再帰が底から順に返ってくることで、葉ノードから積み上がって最終的にルートが完成します。\n" +
+          "例）node(3).left=TreeNode(9), node(3).right=TreeNode(20) → 木全体が復元完了 ✅",
+    visual: "attach_return"
+  }
+];
+
+function StepVisualization({ visual, step }) {
+  // inorder 配列の表示用
+  const InorderBar = ({ highlightIdx }) => (
+    <div className="flex gap-1 flex-wrap justify-center">
+      {INORDER.map((v, i) => (
+        <div key={i} className={[
+          "flex flex-col items-center rounded-lg border-2 px-2 py-1 transition-all",
+          highlightIdx === i
+            ? "bg-emerald-400 border-emerald-600 text-white scale-110 shadow-lg"
+            : "bg-white border-slate-300 text-slate-700"
+        ].join(" ")}>
+          <span className="font-bold mono text-sm">{v}</span>
+          <span className="text-xs text-slate-400 mono">[{i}]</span>
+        </div>
+      ))}
+    </div>
+  );
+
+  const PostorderBar = ({ highlightIdx, consumedFrom }) => (
+    <div className="flex gap-1 flex-wrap justify-center">
+      {POSTORDER.map((v, i) => (
+        <div key={i} className={[
+          "flex flex-col items-center rounded-lg border-2 px-2 py-1 transition-all",
+          i === highlightIdx
+            ? "bg-sky-400 border-sky-600 text-white scale-110 shadow-lg"
+            : consumedFrom !== undefined && i > consumedFrom
+            ? "bg-slate-200 border-slate-300 text-slate-400 opacity-50"
+            : "bg-white border-slate-300 text-slate-700"
+        ].join(" ")}>
+          <span className="font-bold mono text-sm">{v}</span>
+          <span className="text-xs mono" style={{color: i === highlightIdx ? "#fff" : "#94a3b8"}}>[{i}]</span>
+        </div>
+      ))}
+    </div>
+  );
+
+  if (visual === "build_map") {
+    return (
+      <div className="mt-4 space-y-3">
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200">
+          <div className="text-slate-500 text-xs font-semibold mb-2">📥 入力: inorder</div>
+          <InorderBar highlightIdx={-1}/>
+        </div>
+        <div className="flex justify-center text-2xl text-emerald-500">↓</div>
+        <div className="p-3 rounded-xl bg-emerald-50 border border-emerald-200">
+          <div className="text-emerald-700 text-xs font-semibold mb-2 mono">idx_map（O(1)検索が可能になる）</div>
+          <div className="flex gap-2 flex-wrap justify-center">
+            {Object.entries(IDX_MAP).map(([k, v]) => (
+              <div key={k} className="bg-white border-2 border-emerald-400 rounded-lg px-3 py-2 text-center shadow-sm">
+                <span className="text-emerald-700 font-bold mono text-sm">{k}</span>
+                <span className="text-slate-400 mx-1 text-xs">→</span>
+                <span className="text-sky-700 font-bold mono text-sm">{v}</span>
+              </div>
+            ))}
+          </div>
+        </div>
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 mono text-xs">
+          <div className="text-slate-500 mb-1 font-sans font-semibold">🔍 現在の変数の状態</div>
+          <div className="text-emerald-700">idx_map = &#123;9:0, 3:1, 15:2, 20:3, 7:4&#125;</div>
+          <div className="text-slate-500">post_idx = まだ未設定</div>
+        </div>
+      </div>
+    );
+  }
+
+  if (visual === "set_pointer") {
+    return (
+      <div className="mt-4 space-y-3">
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200">
+          <div className="text-slate-500 text-xs font-semibold mb-2">📥 postorder（末尾がルート）</div>
+          <PostorderBar highlightIdx={4} consumedFrom={-1}/>
+          <div className="text-center mt-2 text-sky-600 text-xs font-semibold">↑ post_idx=[4] が指す位置（末尾）</div>
+        </div>
+        <div className="p-3 rounded-xl bg-sky-50 border border-sky-200 mono text-xs">
+          <div className="text-slate-500 mb-1 font-sans font-semibold">🔍 現在の変数の状態</div>
+          <div className="text-emerald-700">idx_map = &#123;9:0, 3:1, 15:2, 20:3, 7:4&#125;</div>
+          <div className="text-sky-700">post_idx = [4]　← 末尾インデックス</div>
+          <div className="text-amber-700">postorder[4] = 3　← 全体のルート！</div>
+        </div>
+      </div>
+    );
+  }
+
+  if (visual === "base_case") {
+    return (
+      <div className="mt-4 space-y-3">
+        <div className="grid grid-cols-2 gap-3">
+          <div className="p-3 rounded-xl bg-red-50 border-2 border-red-300 text-center">
+            <div className="text-red-600 font-bold text-sm mb-1">❌ left &gt; right</div>
+            <div className="mono text-xs text-slate-600">dfs(<span className="text-red-600 font-bold">5</span>, <span className="text-red-600 font-bold">4</span>)</div>
+            <div className="text-xs text-slate-500 mt-1">5 &gt; 4 → None を返す</div>
+            <div className="text-xs text-slate-500">（部分木なし）</div>
+          </div>
+          <div className="p-3 rounded-xl bg-emerald-50 border-2 border-emerald-300 text-center">
+            <div className="text-emerald-600 font-bold text-sm mb-1">✅ left ≤ right</div>
+            <div className="mono text-xs text-slate-600">dfs(<span className="text-emerald-600 font-bold">2</span>, <span className="text-emerald-600 font-bold">4</span>)</div>
+            <div className="text-xs text-slate-500 mt-1">2 ≤ 4 → 続行</div>
+            <div className="text-xs text-slate-500">（部分木あり）</div>
+          </div>
+        </div>
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 mono text-xs">
+          <div className="text-slate-500 mb-1 font-sans font-semibold">🔍 現在の変数の状態</div>
+          <div className="text-slate-600">left &gt; right → <span className="text-red-600 font-bold">return None</span></div>
+          <div className="text-slate-600">left ≤ right → <span className="text-emerald-600 font-bold">処理続行</span></div>
+        </div>
+      </div>
+    );
+  }
+
+  if (visual === "pop_root") {
+    return (
+      <div className="mt-4 space-y-3">
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200">
+          <div className="text-slate-500 text-xs font-semibold mb-2">postorder（末尾からルートを取得）</div>
+          <PostorderBar highlightIdx={4} consumedFrom={-1}/>
+          <div className="text-center mt-2">
+            <span className="bg-sky-500 text-white text-xs font-bold px-3 py-1 rounded-full">取得：val = 3（インデックス4）</span>
+          </div>
+        </div>
+        <div className="flex justify-center text-slate-400 text-sm">post_idx: [4] → [3]</div>
+        <div className="p-3 rounded-xl bg-sky-50 border border-sky-200">
+          <div className="text-slate-500 text-xs font-semibold mb-2">次回の post_idx=[3] は？</div>
+          <PostorderBar highlightIdx={3} consumedFrom={3}/>
+          <div className="text-center mt-2 text-xs text-slate-500">次回は postorder[3]=20 が右部分木のルートになる</div>
+        </div>
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 mono text-xs">
+          <div className="text-slate-500 mb-1 font-sans font-semibold">🔍 現在の変数の状態</div>
+          <div className="text-sky-700">val = 3（全体のルート）</div>
+          <div className="text-slate-600">post_idx = [3]（次回は20）</div>
+          <div className="text-emerald-700">node = TreeNode(3) 作成済み</div>
+        </div>
+      </div>
+    );
+  }
+
+  if (visual === "lookup_mid") {
+    return (
+      <div className="mt-4 space-y-3">
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200">
+          <div className="text-slate-500 text-xs font-semibold mb-2">inorder でルートの位置を検索</div>
+          <InorderBar highlightIdx={1}/>
+          <div className="text-center mt-2">
+            <span className="bg-emerald-500 text-white text-xs font-bold px-3 py-1 rounded-full">mid = idx_map[3] = 1</span>
+          </div>
+        </div>
+        <div className="grid grid-cols-3 gap-2 text-center text-xs">
+          <div className="bg-sky-100 border border-sky-300 rounded-lg p-2">
+            <div className="text-sky-700 font-bold">[0..0]</div>
+            <div className="text-slate-600">左部分木</div>
+            <div className="mono text-sky-800">[9]</div>
+          </div>
+          <div className="bg-emerald-200 border-2 border-emerald-500 rounded-lg p-2">
+            <div className="text-emerald-700 font-bold">mid=1</div>
+            <div className="text-slate-600">ルート</div>
+            <div className="mono text-emerald-800 font-bold">3</div>
+          </div>
+          <div className="bg-violet-100 border border-violet-300 rounded-lg p-2">
+            <div className="text-violet-700 font-bold">[2..4]</div>
+            <div className="text-slate-600">右部分木</div>
+            <div className="mono text-violet-800">[15,20,7]</div>
+          </div>
+        </div>
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 mono text-xs">
+          <div className="text-slate-500 mb-1 font-sans font-semibold">🔍 現在の変数の状態</div>
+          <div className="text-emerald-700">val = 3, mid = 1</div>
+          <div className="text-sky-700">左範囲: dfs(0, 0) → inorder[0]=[9]</div>
+          <div className="text-violet-700">右範囲: dfs(2, 4) → inorder[2..4]=[15,20,7]</div>
+        </div>
+      </div>
+    );
+  }
+
+  if (visual === "recurse_right") {
+    return (
+      <div className="mt-4 space-y-3">
+        <div className="p-3 rounded-xl bg-violet-50 border-2 border-violet-300">
+          <div className="text-violet-700 font-bold text-sm mb-2">dfs(2, 4) — 右部分木を構築中</div>
+          <div className="text-xs text-slate-600 leading-6 mb-2">
+            post_idx=[3] → postorder[3]=<strong>20</strong> が右部分木のルート<br/>
+            mid=idx_map[20]=3 → さらに右=[7], 左=[15] に分割
+          </div>
+          <svg viewBox="0 0 280 130" className="w-full max-w-xs mx-auto">
+            <ellipse cx="140" cy="30" rx="30" ry="20" fill="#ede9fe" stroke="#7c3aed" strokeWidth="2"/>
+            <text x="140" y="30" textAnchor="middle" dominantBaseline="middle" fontSize="14" fontWeight="bold" fill="#5b21b6" fontFamily="monospace">20</text>
+            <line x1="115" y1="47" x2="75" y2="80" stroke="#7c3aed" strokeWidth="1.5"/>
+            <line x1="165" y1="47" x2="205" y2="80" stroke="#7c3aed" strokeWidth="1.5"/>
+            <ellipse cx="70" cy="95" rx="28" ry="20" fill="#ddd6fe" stroke="#7c3aed" strokeWidth="1.5"/>
+            <text x="70" y="95" textAnchor="middle" dominantBaseline="middle" fontSize="13" fill="#5b21b6" fontFamily="monospace">15</text>
+            <ellipse cx="210" cy="95" rx="28" ry="20" fill="#ddd6fe" stroke="#7c3aed" strokeWidth="1.5"/>
+            <text x="210" y="95" textAnchor="middle" dominantBaseline="middle" fontSize="13" fill="#5b21b6" fontFamily="monospace">7</text>
+          </svg>
+        </div>
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 mono text-xs">
+          <div className="text-slate-500 mb-1 font-sans font-semibold">🔍 現在の変数の状態</div>
+          <div className="text-violet-700">node(3).right = dfs(2, 4) 実行中...</div>
+          <div className="text-slate-500">post_idx の消費順: 3→20, 2→7, 1→15</div>
+          <div className="text-slate-500">（右を先に再帰するのでこの順になる）</div>
+        </div>
+      </div>
+    );
+  }
+
+  if (visual === "recurse_left") {
+    return (
+      <div className="mt-4 space-y-3">
+        <div className="p-3 rounded-xl bg-sky-50 border-2 border-sky-300">
+          <div className="text-sky-700 font-bold text-sm mb-2">dfs(0, 0) — 左部分木を構築中</div>
+          <div className="text-xs text-slate-600 leading-6 mb-2">
+            右部分木(20,7,15)の処理完了後、post_idx=[0]<br/>
+            postorder[0]=<strong>9</strong> が左部分木のルート（葉ノード）
+          </div>
+          <svg viewBox="0 0 120 80" className="w-full max-w-[120px] mx-auto">
+            <ellipse cx="60" cy="40" rx="30" ry="22" fill="#e0f2fe" stroke="#0284c7" strokeWidth="2"/>
+            <text x="60" y="40" textAnchor="middle" dominantBaseline="middle" fontSize="14" fontWeight="bold" fill="#1e40af" fontFamily="monospace">9</text>
+          </svg>
+        </div>
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 mono text-xs">
+          <div className="text-slate-500 mb-1 font-sans font-semibold">🔍 現在の変数の状態</div>
+          <div className="text-sky-700">node(3).left = dfs(0, 0) → TreeNode(9)</div>
+          <div className="text-slate-500">post_idx=[0] → postorder[0]=9</div>
+          <div className="text-emerald-600">葉ノード：左右ともNone</div>
+        </div>
+      </div>
+    );
+  }
+
+  if (visual === "attach_return") {
+    return (
+      <div className="mt-4 space-y-3">
+        <div className="p-3 rounded-xl bg-emerald-50 border-2 border-emerald-400">
+          <div className="text-emerald-700 font-bold text-sm mb-2">✅ 完成した木</div>
+          <svg viewBox="0 0 280 180" className="w-full max-w-sm mx-auto">
+            {/* 3 (root) */}
+            <ellipse cx="140" cy="30" rx="30" ry="22" fill="#d1fae5" stroke="#059669" strokeWidth="2.5"/>
+            <text x="140" y="30" textAnchor="middle" dominantBaseline="middle" fontSize="15" fontWeight="bold" fill="#065f46" fontFamily="monospace">3</text>
+            {/* edges */}
+            <line x1="113" y1="43" x2="73" y2="80" stroke="#10b981" strokeWidth="2"/>
+            <line x1="167" y1="43" x2="207" y2="80" stroke="#10b981" strokeWidth="2"/>
+            {/* 9 (left) */}
+            <ellipse cx="68" cy="95" rx="28" ry="20" fill="#e0f2fe" stroke="#0284c7" strokeWidth="2"/>
+            <text x="68" y="95" textAnchor="middle" dominantBaseline="middle" fontSize="14" fontWeight="bold" fill="#1e40af" fontFamily="monospace">9</text>
+            {/* 20 (right) */}
+            <ellipse cx="212" cy="95" rx="28" ry="20" fill="#ede9fe" stroke="#7c3aed" strokeWidth="2"/>
+            <text x="212" y="95" textAnchor="middle" dominantBaseline="middle" fontSize="14" fontWeight="bold" fill="#5b21b6" fontFamily="monospace">20</text>
+            {/* edges 20→15, 20→7 */}
+            <line x1="188" y1="110" x2="163" y2="148" stroke="#7c3aed" strokeWidth="1.5"/>
+            <line x1="236" y1="110" x2="249" y2="148" stroke="#7c3aed" strokeWidth="1.5"/>
+            {/* 15 */}
+            <ellipse cx="157" cy="160" rx="26" ry="18" fill="#ddd6fe" stroke="#7c3aed" strokeWidth="1.5"/>
+            <text x="157" y="160" textAnchor="middle" dominantBaseline="middle" fontSize="13" fill="#5b21b6" fontFamily="monospace">15</text>
+            {/* 7 */}
+            <ellipse cx="252" cy="160" rx="26" ry="18" fill="#ddd6fe" stroke="#7c3aed" strokeWidth="1.5"/>
+            <text x="252" y="160" textAnchor="middle" dominantBaseline="middle" fontSize="13" fill="#5b21b6" fontFamily="monospace">7</text>
+          </svg>
+        </div>
+        <div className="p-3 rounded-xl bg-slate-50 border border-slate-200 mono text-xs">
+          <div className="text-slate-500 mb-1 font-sans font-semibold">🔍 最終的な変数の状態</div>
+          <div className="text-emerald-700 font-bold">return TreeNode(3) ✅</div>
+          <div className="text-slate-500">node(3).left  = TreeNode(9)</div>
+          <div className="text-slate-500">node(3).right = TreeNode(20)</div>
+          <div className="text-slate-500">　node(20).left  = TreeNode(15)</div>
+          <div className="text-slate-500">　node(20).right = TreeNode(7)</div>
+        </div>
+      </div>
+    );
+  }
+
+  return null;
+}
+
+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);
+        }
+      }, 2000);
+    }
+    return () => { if (timerRef.current) clearTimeout(timerRef.current); };
+  }, [isPlaying, activeStep]);
+
+  return (
+    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-6 mt-2">
+      {/* Step list */}
+      <div>
+        <h3 className="mt-0 mb-3 text-teal-800 text-base font-bold outfit">ステップ一覧</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 rounded-xl border-2 transition cursor-pointer px-3 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 text-sm", isActive ? "text-emerald-900" : "text-teal-800"].join(" ")}>
+                  Step {s.step}: {s.title}
+                </div>
+              </button>
+            );
+          })}
+        </div>
+      </div>
+
+      {/* Detail panel */}
+      <div>
+        {activeStep > 1 && (
+          <div className="mb-3 px-3 py-2 rounded-lg bg-slate-100 border border-slate-200 text-xs text-slate-500">
+            ← Step {activeStep - 1} では「{stepsData[activeStep - 2].title}」を行いました
+          </div>
+        )}
+
+        <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)]">
+          <div className="text-teal-500 text-xs font-bold mb-1 outfit">Step {currentStepData.step} / {stepsData.length}</div>
+          <h3 className="mt-0 text-teal-800 text-base font-bold mb-2">{currentStepData.title}</h3>
+          <p className="text-slate-600 leading-7 text-sm whitespace-pre-line">{currentStepData.desc}</p>
+        </div>
+
+        <StepVisualization visual={currentStepData.visual} step={activeStep}/>
+
+        <div className="flex flex-wrap justify-center gap-2 mt-4">
+          <button type="button"
+            className="px-4 py-2 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-4 py-2 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-4 py-2 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-4 py-2 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>
+  );
+}
+
+const root = ReactDOM.createRoot(document.getElementById("react-steps"));
+root.render(React.createElement(StepsApp));
+
+// Re-highlight code after React renders
+requestAnimationFrame(() => {
+  if (window.Prism) Prism.highlightAll();
+});
+</script>
+</body>
+</html>
diff --git a/public/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html b/public/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html
new file mode 100644
index 0000000..d810fd6
--- /dev/null
+++ b/public/Algorithm/BinaryTree/leetcode/110. Balanced Binary Tree/claude sonnet 4.6 adaptive/README_react.html	
@@ -0,0 +1,1958 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1" />
+        <title>LeetCode 110 · Balanced Binary Tree</title>
+        <link rel="preconnect" href="https://fonts.googleapis.com" />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;800;900&family=JetBrains+Mono:wght@400;500;700&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <script src="/vendor/react/react.development.js" crossorigin></script>
+        <script
+            src="/vendor/react-dom/react-dom.development.js"
+            crossorigin
+        ></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"
+        />
+        <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>
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            .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;
+            }
+            details > summary {
+                list-style: none;
+            }
+            details > summary::-webkit-details-marker {
+                display: none;
+            }
+            details[open] > summary .arrow {
+                transform: rotate(90deg);
+            }
+            .arrow {
+                display: inline-block;
+                transition: transform 0.2s;
+            }
+        </style>
+    </head>
+    <body class="bg-gradient-to-br from-emerald-50 via-sky-50 to-slate-100 min-h-screen py-8 px-4">
+        <div class="max-w-5xl mx-auto">
+            <!-- ===================== HEADER ===================== -->
+            <header
+                id="header"
+                class="mb-8 rounded-2xl p-8 shadow-lg"
+                style="background: linear-gradient(135deg, #d1fae5, #bfdbfe)"
+            >
+                <div class="flex flex-wrap items-center gap-3 mb-3">
+                    <span
+                        class="bg-emerald-600 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >LeetCode 110</span
+                    >
+                    <span
+                        class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Easy</span
+                    >
+                    <span
+                        class="bg-violet-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Tree · DFS</span
+                    >
+                </div>
+                <h1 class="outfit text-4xl font-extrabold text-teal-900 mb-1">
+                    Balanced Binary Tree
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    ボトムアップDFS（番兵値-1）による O(n) 実装
+                </p>
+                <div
+                    class="mt-4 inline-block bg-white/70 rounded-xl px-5 py-3 text-teal-800 font-semibold text-base"
+                >
+                    💡
+                    一言で言うと：「木のすべてのノードで、左右の枝の深さの差が1以内かどうかを判定する問題」
+                </div>
+                <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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 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-md hover:-translate-y-0.5 hover:border-teal-500 hover:bg-emerald-50 text-sm"
+                        >📖 用語集</a
+                    >
+                </nav>
+            </header>
+
+            <!-- ===================== OVERVIEW ===================== -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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">
+                        💡
+                        この問題を一言で言うと：「木のすべてのノードで、左右の枝の深さの差が1以内かどうかを判定する問題」
+                    </p>
+                    <p class="text-slate-600 text-sm mt-2 leading-7">
+                        高さ均衡二分木（height-balanced binary
+                        tree）とは、全ノードで左右の部分木の高さの差が最大1であるような二分木です。
+                        空の木（root = null）も高さ均衡として扱います。
+                    </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 leading-7">
+                        <li>
+                            「高さ計算」と「均衡チェック」を別々に行うと、同じノードを何度も訪問するためO(n²)になってしまいます（素朴なトップダウン再帰の罠）。
+                        </li>
+                        <li>
+                            不均衡が見つかった瞬間に結果を上位ノードへ伝える仕組みがないと、無駄な計算が増えてしまいます。
+                        </li>
+                    </ul>
+                </div>
+
+                <div class="grid grid-cols-2 md:grid-cols-4 gap-3 mb-7">
+                    <div
+                        style="background: #d1fae5; color: #065f46"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-base 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-base font-mono">O(h)</div>
+                        <div class="text-xs mt-1">空間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">
+                            Bottom-up DFS
+                        </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">
+                            番兵値 -1
+                        </div>
+                        <div class="text-xs mt-1">エラー伝播</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 1 — true
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+    3
+   / \
+  9  20
+     / \
+    15   7</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            全ノードで左右の高さの差 ≤ 1 →
+                            <span class="text-emerald-600 font-bold">true</span>
+                        </p>
+                    </div>
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 2 — false
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+      1
+    /   \
+   2     2
+  / \
+ 3   3
+/ \
+4   4</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            ルートの左右の高さ差 = 2 →
+                            <span class="text-red-500 font-bold">false</span>
+                        </p>
+                    </div>
+                    <div class="rounded-xl border border-slate-200 p-4">
+                        <div class="text-xs font-semibold text-slate-500 mb-2">
+                            Example 3 — true
+                        </div>
+                        <pre
+                            class="text-xs font-mono text-slate-700 leading-6 bg-slate-50 rounded-lg p-3"
+                        >
+（空の木）
+root = null</pre
+                        >
+                        <p class="text-xs text-slate-500 mt-2">
+                            空の木は定義上 均衡 →
+                            <span class="text-emerald-600 font-bold">true</span>
+                        </p>
+                    </div>
+                </div>
+
+                <div class="p-4 rounded-xl bg-sky-50 border border-sky-200">
+                    <p class="text-sky-800 font-semibold text-sm mb-2">
+                        🧠 解法のアイデア：1パスで高さ計算と均衡チェックを同時に行う
+                    </p>
+                    <p class="text-slate-600 text-sm leading-7">
+                        葉ノード（子のないノード）から根ノードに向かってさかのぼりながら（ボトムアップ）、高さを返しつつ同時に均衡チェックも行います。
+                        不均衡が見つかったら
+                        <span class="font-mono bg-white px-1 rounded text-red-600">-1</span
+                        >（番兵値）を返し、上位ノードへ伝播させます。
+                        これにより各ノードをちょうど1回だけ訪問する O(n) が実現できます。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===================== STEPS (React) ===================== -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-2 pb-2 border-b-4 border-emerald-200"
+                >
+                    ステップバイステップ解説
+                </h2>
+                <p class="text-slate-500 text-sm mb-5">
+                    各ステップをクリックするか ▶ Play で自動再生できます。
+                </p>
+                <div id="steps-root"></div>
+            </section>
+
+            <!-- ===================== CODE ===================== -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 border-emerald-200"
+                >
+                    Python 実装
+                </h2>
+
+                <div class="mb-5 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 leading-7">
+                        <li>
+                            <strong>isBalanced</strong
+                            >：外部に公開するエントリポイント。check_height を呼んで -1 でなければ
+                            True を返す
+                        </li>
+                        <li>
+                            <strong>check_height（ネスト関数）</strong
+                            >：再帰の本体。高さを返しつつ不均衡なら -1 を返す
+                        </li>
+                        <li>ベースケース：node が None なら高さ 0 を返す</li>
+                        <li>左右を再帰し、-1 が返ってきたら即 -1 を伝播（早期リターン）</li>
+                        <li>
+                            左右の高さの差 &gt; 1 なら -1、そうでなければ max(左, 右) + 1 を返す
+                        </li>
+                    </ol>
+                </div>
+
+                <pre class="line-numbers"><code class="language-python">from typing import Optional
+
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -&gt; bool:
+
+        def check_height(node: Optional[TreeNode]) -&gt; int:
+            # ベースケース：空のノードは高さ0
+            # `is None` はPEP 8推奨。None はシングルトンなので is が正確
+            if node is None:
+                return 0
+
+            # 左サブツリーの高さを再帰で取得
+            left_height = check_height(node.left)
+            # 左が -1（不均衡検知済み）なら即座に -1 を返す（早期リターン）
+            if left_height == -1:
+                return -1
+
+            # 右サブツリーの高さを再帰で取得
+            right_height = check_height(node.right)
+            # 右が -1 のときも同様に伝播
+            if right_height == -1:
+                return -1
+
+            # このノードでの均衡チェック
+            # abs() はC実装の組み込み関数で高速
+            if abs(left_height - right_height) &gt; 1:
+                return -1  # 番兵値 -1 を返して不均衡を上位へ知らせる
+
+            # このノードの高さ = max(左, 右) + 自分の1
+            # max() もC実装の組み込み関数で高速
+            return max(left_height, right_height) + 1
+
+        # check_height が -1 でなければ均衡している
+        return check_height(root) != -1</code></pre>
+
+                <div class="mt-5 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"
+                    >
+check_height(3)  開始
+  ├─ check_height(9)   → left=0, right=0, diff=0 ≤ 1  → return 1
+  │   left_height=1 (≠-1、継続)
+  ├─ check_height(20)  開始
+  │   ├─ check_height(15) → return 1
+  │   │   left_height=1 (≠-1、継続)
+  │   ├─ check_height(7)  → return 1
+  │   │   right_height=1 (≠-1、継続)
+  │   └─ abs(1-1)=0 ≤ 1 → return max(1,1)+1 = 2
+  │   right_height=2 (≠-1、継続)
+  └─ abs(1-2)=1 ≤ 1 → return max(1,2)+1 = 3
+
+check_height(root) = 3
+3 != -1  →  isBalanced = True ✅</pre
+                    >
+                </div>
+
+                <div class="mt-4 p-4 rounded-xl bg-red-50 border border-red-200">
+                    <p class="text-red-800 font-semibold text-sm mb-2">
+                        ▶ 不均衡ケース [1,2,2,3,3,null,null,4,4] での動作トレース
+                    </p>
+                    <pre
+                        class="text-slate-700 text-xs font-mono leading-7 overflow-x-auto whitespace-pre"
+                    >
+check_height(4) → 1  (左の4)
+check_height(4) → 1  (右の4)
+check_height(3) [左]  → abs(1-1)=0 → return 2
+check_height(3) [右]  → abs(0-0)=0 → return 1
+check_height(2) [左]  → abs(2-1)=1 ≤ 1 → return 3
+check_height(2) [右]  → return 1
+check_height(1) [ルート]
+  left_height=3, right_height=1
+  abs(3-1) = 2  &gt; 1  → return -1  ← 不均衡！
+
+check_height(root) = -1
+-1 == -1  →  isBalanced = False ✅</pre
+                    >
+                </div>
+            </section>
+
+            <!-- ===================== FLOWCHART ===================== -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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="28" height="18">
+                                <ellipse
+                                    cx="14"
+                                    cy="9"
+                                    rx="13"
+                                    ry="8"
+                                    fill="#d1fae5"
+                                    stroke="#10b981"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>楕円（緑）＝ 開始・終了</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <rect
+                                    x="1"
+                                    y="2"
+                                    width="26"
+                                    height="14"
+                                    rx="3"
+                                    fill="#e0f2fe"
+                                    stroke="#0284c7"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>四角（青）＝ 処理ステップ</span>
+                        </div>
+                        <div class="flex items-center gap-2">
+                            <svg width="28" height="18">
+                                <polygon
+                                    points="14,1 27,9 14,17 1,9"
+                                    fill="#fef3c7"
+                                    stroke="#f59e0b"
+                                    stroke-width="1.5"
+                                />
+                            </svg>
+                            <span>ひし形（黄）＝ 条件分岐</span>
+                        </div>
+                        <div class="flex items-center gap-2 col-span-2 md:col-span-1">
+                            <span class="inline-block w-5 h-0.5 bg-emerald-500 mr-1"></span
+                            ><span class="mr-2">緑＝はい</span>
+                            <span class="inline-block w-5 h-0.5 bg-red-500 mr-1"></span>赤＝いいえ
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-5 overflow-x-auto">
+                    <svg
+                        viewBox="0 0 560 1200"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Balanced Binary Tree DFS 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="#dc2626" />
+                            </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>
+
+                        <!-- N1: START -->
+                        <ellipse
+                            cx="280"
+                            cy="44"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="40"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#065f46"
+                            font-weight="600"
+                        >
+                            isBalanced(root) 開始
+                        </text>
+                        <text
+                            x="280"
+                            y="55"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            check_height(root) を呼ぶ
+                        </text>
+
+                        <!-- Arrow N1→N2 -->
+                        <line
+                            x1="280"
+                            y1="72"
+                            x2="280"
+                            y2="105"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N2: check_height(node) called -->
+                        <rect
+                            x="80"
+                            y="108"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="128"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            check_height(node) を呼ぶ
+                        </text>
+                        <text
+                            x="280"
+                            y="148"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            node = 現在処理中のノード
+                        </text>
+
+                        <!-- Arrow N2→N3 -->
+                        <line
+                            x1="280"
+                            y1="158"
+                            x2="280"
+                            y2="195"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N3: node is None? -->
+                        <polygon
+                            points="280,198 430,248 280,298 130,248"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="243"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            node is None ?
+                        </text>
+                        <text
+                            x="280"
+                            y="260"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （木の末端に到達したか）
+                        </text>
+
+                        <!-- N3 → YES → return 0 -->
+                        <line
+                            x1="430"
+                            y1="248"
+                            x2="500"
+                            y2="248"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="464"
+                            y="240"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="220"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="244"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="262"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            0
+                        </text>
+
+                        <!-- N3 → NO → continue down -->
+                        <line
+                            x1="280"
+                            y1="298"
+                            x2="280"
+                            y2="335"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="293"
+                            y="320"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N4: left_height = check_height(node.left) -->
+                        <rect
+                            x="80"
+                            y="338"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="358"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            left_height = check_height(node.left)
+                        </text>
+                        <text
+                            x="280"
+                            y="378"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            左の部分木の高さを再帰で計算
+                        </text>
+
+                        <!-- Arrow N4→N5 -->
+                        <line
+                            x1="280"
+                            y1="388"
+                            x2="280"
+                            y2="425"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N5: left_height == -1 ? -->
+                        <polygon
+                            points="280,428 430,478 280,528 130,478"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="473"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            left_height == -1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="490"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （左サブツリーで不均衡を検知済みか）
+                        </text>
+
+                        <!-- N5 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="478"
+                            x2="500"
+                            y2="478"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="470"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="450"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="474"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="492"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N5 → NO -->
+                        <line
+                            x1="280"
+                            y1="528"
+                            x2="280"
+                            y2="565"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="550"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N6: right_height = check_height(node.right) -->
+                        <rect
+                            x="80"
+                            y="568"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="588"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e3a5f"
+                            font-weight="600"
+                        >
+                            right_height = check_height(node.right)
+                        </text>
+                        <text
+                            x="280"
+                            y="608"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#1e40af"
+                        >
+                            右の部分木の高さを再帰で計算
+                        </text>
+
+                        <!-- Arrow N6→N7 -->
+                        <line
+                            x1="280"
+                            y1="618"
+                            x2="280"
+                            y2="655"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N7: right_height == -1 ? -->
+                        <polygon
+                            points="280,658 430,708 280,758 130,708"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="703"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            right_height == -1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="720"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （右サブツリーで不均衡を検知済みか）
+                        </text>
+
+                        <!-- N7 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="708"
+                            x2="500"
+                            y2="708"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="700"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="680"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="704"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="722"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N7 → NO -->
+                        <line
+                            x1="280"
+                            y1="758"
+                            x2="280"
+                            y2="795"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="780"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N8: abs(left-right) > 1 ? -->
+                        <polygon
+                            points="280,798 430,858 280,918 130,858"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="848"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#78350f"
+                            font-weight="600"
+                        >
+                            abs(left_height - right_height) &gt; 1 ?
+                        </text>
+                        <text
+                            x="280"
+                            y="868"
+                            text-anchor="middle"
+                            font-size="10"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#92400e"
+                        >
+                            （このノードで左右の高さの差が大きすぎるか）
+                        </text>
+
+                        <!-- N8 → YES → return -1 -->
+                        <line
+                            x1="430"
+                            y1="858"
+                            x2="500"
+                            y2="858"
+                            stroke="#dc2626"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="464"
+                            y="850"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#dc2626"
+                            font-weight="600"
+                        >
+                            はい
+                        </text>
+                        <rect
+                            x="500"
+                            y="830"
+                            width="50"
+                            height="56"
+                            rx="8"
+                            fill="#fee2e2"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="525"
+                            y="854"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            return
+                        </text>
+                        <text
+                            x="525"
+                            y="872"
+                            text-anchor="middle"
+                            font-size="12"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#991b1b"
+                            font-weight="700"
+                        >
+                            -1
+                        </text>
+
+                        <!-- N8 → NO -->
+                        <line
+                            x1="280"
+                            y1="918"
+                            x2="280"
+                            y2="955"
+                            stroke="#059669"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="293"
+                            y="940"
+                            text-anchor="start"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                            font-weight="600"
+                        >
+                            いいえ
+                        </text>
+
+                        <!-- N9: return max(l,r)+1 -->
+                        <rect
+                            x="80"
+                            y="958"
+                            width="400"
+                            height="50"
+                            rx="8"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="978"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="JetBrains Mono,monospace"
+                            fill="#065f46"
+                            font-weight="700"
+                        >
+                            return max(left_height, right_height) + 1
+                        </text>
+                        <text
+                            x="280"
+                            y="998"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            このノードの高さ（均衡OK）を親へ返す
+                        </text>
+
+                        <!-- Arrow N9→N10 -->
+                        <line
+                            x1="280"
+                            y1="1008"
+                            x2="280"
+                            y2="1045"
+                            stroke="#64748b"
+                            stroke-width="1.5"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- N10: END -->
+                        <ellipse
+                            cx="280"
+                            cy="1080"
+                            rx="140"
+                            ry="32"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="1074"
+                            text-anchor="middle"
+                            font-size="13"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#065f46"
+                            font-weight="600"
+                        >
+                            check_height(root) != -1 を返す
+                        </text>
+                        <text
+                            x="280"
+                            y="1092"
+                            text-anchor="middle"
+                            font-size="11"
+                            font-family="Noto Sans JP,sans-serif"
+                            fill="#059669"
+                        >
+                            True（均衡）または False（不均衡）
+                        </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-2 list-decimal list-inside leading-7">
+                        <li>
+                            「開始」→ check_height(node=3) を呼ぶ。node は None でないので処理継続
+                        </li>
+                        <li>
+                            左サブツリー check_height(9) を計算 → 9の左右はどちらも None
+                            なので高さ1を返す。-1 でないので継続
+                        </li>
+                        <li>
+                            右サブツリー check_height(20) を計算 → 15と7の高さがそれぞれ1 →
+                            abs(1-1)=0 ≤ 1 → 高さ2を返す。-1 でないので継続
+                        </li>
+                        <li>ルート3での均衡チェック：abs(1-2)=1 ≤ 1 → 均衡OK → 高さ3を返す</li>
+                        <li>
+                            「終了」→ 3 != -1 → isBalanced =
+                            <span class="text-emerald-600 font-bold">True</span>
+                        </li>
+                    </ol>
+                </div>
+            </section>
+
+            <!-- ===================== COMPLEXITY ===================== -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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(log n)</div>
+                            <div class="leading-5">
+                                log倍に増加<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-5">
+                    <table class="w-full border-collapse text-sm">
+                        <thead>
+                            <tr class="bg-gradient-to-r from-emerald-100 to-sky-100">
+                                <th
+                                    class="p-3 text-left text-slate-700 font-bold border border-slate-200 rounded-tl-lg"
+                                >
+                                    アプローチ
+                                </th>
+                                <th
+                                    class="p-3 text-center text-slate-700 font-bold border border-slate-200"
+                                >
+                                    時間計算量
+                                </th>
+                                <th
+                                    class="p-3 text-center text-slate-700 font-bold border border-slate-200"
+                                >
+                                    空間計算量
+                                </th>
+                                <th
+                                    class="p-3 text-left text-slate-700 font-bold border border-slate-200 rounded-tr-lg"
+                                >
+                                    備考
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="bg-emerald-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-emerald-800"
+                                >
+                                    ✅ ボトムアップDFS（番兵値-1）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-emerald-700"
+                                >
+                                    O(n)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-emerald-700"
+                                >
+                                    O(h)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    各ノードを1回だけ訪問。h=木の高さ（均衡木ではO(log
+                                    n)、最悪O(n)）
+                                </td>
+                            </tr>
+                            <tr class="bg-red-50">
+                                <td class="p-3 border border-slate-200 font-semibold text-red-700">
+                                    ❌ トップダウン再帰（素朴）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-red-600"
+                                >
+                                    O(n²)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono text-red-600"
+                                >
+                                    O(h)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    高さ計算と均衡チェックを分離するため同じノードを繰り返し訪問してしまう
+                                </td>
+                            </tr>
+                            <tr class="bg-amber-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-amber-700"
+                                >
+                                    BFS（幅優先探索）
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono font-bold text-amber-600"
+                                >
+                                    O(n)
+                                </td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center font-mono text-amber-600"
+                                >
+                                    O(n)
+                                </td>
+                                <td class="p-3 border border-slate-200 text-slate-600 text-xs">
+                                    dequeのメモリ確保コストがある。実装も複雑になりやすい
+                                </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>：check_height
+                        はすべてのノードをちょうど1回だけ訪問します。不均衡が見つかった瞬間に -1
+                        を返す早期リターンにより、無駄な再帰呼び出しを省けています。<br />
+                        <strong>空間計算量 O(h)</strong>：再帰呼び出しのコールスタックが木の高さ h
+                        分だけ積み重なります。均衡木では h = O(log n)、最悪の一直線の木では h = O(n)
+                        になります。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ===================== GLOSSARY ===================== -->
+            <section id="glossary" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-4 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="arrow text-emerald-500">▶</span>
+                            高さ均衡二分木（Height-balanced Binary Tree）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            すべてのノードで、左右の部分木の高さの差が最大1である二分木のこと。AVL木がこの代表例です。均衡が保たれていると、検索・挿入・削除などの操作をO(log
+                            n)で行えます。
+                        </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="arrow text-emerald-500">▶</span> 番兵値（Sentinel Value）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            通常の値としてあり得ない特別な値を使ってエラーや特殊状態を表す手法です。この問題では
+                            -1 が番兵値で「不均衡が検知済み」を意味します。高さは常に0以上なので、-1
+                            は安全な番兵値として機能します。
+                        </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="arrow text-emerald-500">▶</span>
+                            ボトムアップ再帰（Bottom-up Recursion）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            葉ノード（末端）から根ノードに向かって結果を積み上げていく再帰の方向です。対義語はトップダウン（根から葉へ）。ボトムアップにすると、計算結果を再利用できるためO(n)が実現できます。
+                        </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="arrow text-emerald-500">▶</span> ネスト関数（Nested
+                            Function）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数の中に定義された関数のこと。外部スコープから直接呼べないため、内部実装を隠蔽できます。Pythonではネスト関数はローカルスコープで名前解決されるため、クラスメソッドより少し高速です。
+                        </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="arrow text-emerald-500">▶</span> DFS（深さ優先探索 /
+                            Depth-First Search）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            木やグラフを探索する方法の一つで、できるだけ深く進んでから戻る方式です。迷路を解くとき「行き止まりになるまで進んで、戻って別の道を試す」イメージです。木の問題では再帰で自然に実装できます。
+                        </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="arrow text-emerald-500">▶</span> ベースケース（Base Case）
+                        </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 is None</code
+                            >
+                            がベースケースで、高さ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="arrow text-emerald-500">▶</span> 早期リターン（Early
+                            Return）
+                        </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">return</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="arrow text-emerald-500">▶</span> シングルトン（Singleton）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            プログラム中に1つしか存在しないオブジェクトのことです。Pythonの
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">None</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs">True</code
+                            >、<code class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >False</code
+                            >
+                            がこれにあたります。<code
+                                class="bg-slate-100 px-1 rounded font-mono text-xs"
+                                >is None</code
+                            >
+                            が
+                            <code class="bg-slate-100 px-1 rounded font-mono text-xs">== None</code>
+                            より正確で速い理由は、Noneがシングルトンだからです。
+                        </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="arrow text-emerald-500">▶</span> コールスタック（Call
+                            Stack）
+                        </summary>
+                        <div
+                            class="px-5 py-3 text-slate-600 text-sm leading-7 border-t border-slate-200"
+                        >
+                            関数呼び出しが積み重なっていく記録です。「お皿の積み重ね」のように、最後に呼んだ関数が最初に終わります（LIFO）。再帰が深くなるほどコールスタックが大きくなり、空間計算量に影響します。
+                        </div>
+                    </details>
+                </div>
+            </section>
+
+            <footer class="text-center text-slate-400 text-sm py-4">
+                LeetCode 110 · Balanced Binary Tree — ボトムアップDFS解説
+            </footer>
+        </div>
+
+        <!-- ===================== REACT COMPONENT ===================== -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: 'isBalanced でエントリポイントを定義',
+                    desc: 'まず外部に公開する関数 isBalanced を定義し、その中でヘルパー関数 check_height を呼び出します。なぜヘルパーをネスト関数にするかというと、「高さを返す / -1 を返す」という内部の詳細を外に見せないためです。外部から見ると isBalanced は「True/False を返す」だけのシンプルなAPIになります。例）isBalanced(root=TreeNode(3)) を呼ぶと、内部で check_height(TreeNode(3)) が実行されます。',
+                    visual: 'entry',
+                },
+                {
+                    step: 2,
+                    title: 'ベースケース：node is None → return 0',
+                    desc: 'check_height が最初に確認するのは「今のノードが None（空）かどうか」です。なぜなら、再帰はいつか木の末端（葉の下）に到達し、そこで処理を止める必要があるからです。None のノードは「高さ0の空の木」なので 0 を返します。`is None` を使う理由：Pythonの None はシングルトン（プログラム中に1つだけ存在）なので、`is` による同一性チェックが正確かつ高速です。',
+                    visual: 'base',
+                },
+                {
+                    step: 3,
+                    title: '左サブツリーを再帰処理',
+                    desc: '現在のノードの左の子 node.left を引数に check_height を再帰呼び出しし、左サブツリーの高さを取得します。なぜ先に左を処理するかは、左右どちらから始めても正解ですが、DFSは慣習的に左から始めます。返り値が -1 なら左サブツリーで不均衡が見つかっているので、即座に -1 を上位ノードへ返します（早期リターン）。例）node=TreeNode(3) で left=TreeNode(9) のとき、check_height(9) を呼ぶ。',
+                    visual: 'left',
+                },
+                {
+                    step: 4,
+                    title: '右サブツリーを再帰処理',
+                    desc: '左サブツリーが均衡していた（left_height ≠ -1）場合のみ、右の子 node.right を引数に check_height を再帰呼び出しします。なぜ左の確認後に右を処理するかというと、左で不均衡が確定しているなら右を調べる必要が全くないからです（早期リターンで効率化）。返り値が -1 なら同様に -1 を伝播します。例）left_height=1 (≠-1) なので right=TreeNode(20) を処理 → check_height(20) を呼ぶ。',
+                    visual: 'right',
+                },
+                {
+                    step: 5,
+                    title: '均衡チェック：abs(left - right) > 1 ?',
+                    desc: '左右両サブツリーが均衡している（どちらも ≠ -1）場合、このノードでの均衡チェックを行います。abs(left_height - right_height) > 1 であれば不均衡なので -1 を返します。abs()（絶対値）を使う理由：左が深い場合も右が深い場合も1行で処理でき、かつCPythonのC実装なので高速です。例）left=1, right=2 → abs(1-2)=1 ≤ 1 → 均衡OK。left=3, right=1 → abs(3-1)=2 > 1 → 不均衡 → return -1。',
+                    visual: 'balance',
+                },
+                {
+                    step: 6,
+                    title: '高さを返す：return max(left, right) + 1',
+                    desc: '均衡チェックを通過したノードは「高さ = max(左の高さ, 右の高さ) + 1」を返します。+1 は「自分自身のノード1段分」を追加しています。max() を使う理由：左右のうち深い方が実際のサブツリーの高さになるからです。max() もCPythonのC実装で高速です。例）left=1, right=2 → max(1,2)+1 = 3 を親ノードへ返す。これが親ノードの left_height または right_height になります。',
+                    visual: 'height',
+                },
+                {
+                    step: 7,
+                    title: '最終判定：check_height(root) != -1',
+                    desc: 'すべての再帰が完了して check_height(root) の結果が返ってきます。-1 でなければ全ノードが均衡していたことを意味し True を返します。-1 であれば不均衡が検知されたので False を返します。この != -1 という単純な比較で全体の判定が完結します。例）Example1 → check_height(3) = 3 → 3 != -1 → True。Example2 → check_height(1) = -1 → -1 == -1 → False。',
+                    visual: 'final',
+                },
+            ];
+
+            const treeNodes = {
+                entry: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#10b981' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '3',
+                    label: 'isBalanced(root=3) を呼び出し中',
+                },
+                base: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: 'N', x: 30, y: 160, c: '#f59e0b' },
+                        { v: 'N', x: 130, y: 160, c: '#f59e0b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 80, y1: 110, x2: 30, y2: 145 },
+                        { x1: 80, y1: 110, x2: 130, y2: 145 },
+                    ],
+                    highlight: 'N',
+                    label: 'None → return 0（高さ0）',
+                },
+                left: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#10b981' },
+                        { v: '20', x: 240, y: 95, c: '#e2e8f0' },
+                        { v: 'N', x: 30, y: 160, c: '#64748b' },
+                        { v: 'N', x: 130, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 80, y1: 110, x2: 30, y2: 145 },
+                        { x1: 80, y1: 110, x2: 130, y2: 145 },
+                    ],
+                    highlight: '9',
+                    label: 'check_height(9) → left_height = 1',
+                },
+                right: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#64748b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#0ea5e9' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '20',
+                    label: 'check_height(20) → right_height = 2',
+                },
+                balance: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#a855f7' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                        { v: '15', x: 190, y: 160, c: '#64748b' },
+                        { v: '7', x: 290, y: 160, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: '3',
+                    label: 'abs(1-2)=1 ≤ 1 → 均衡OK！',
+                },
+                height: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#f59e0b' },
+                        { v: '9', x: 80, y: 95, c: '#64748b' },
+                        { v: '20', x: 240, y: 95, c: '#64748b' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                    ],
+                    highlight: '3',
+                    label: 'return max(1,2)+1 = 3 を返す',
+                },
+                final: {
+                    nodes: [
+                        { v: '3', x: 160, y: 30, c: '#10b981' },
+                        { v: '9', x: 80, y: 95, c: '#10b981' },
+                        { v: '20', x: 240, y: 95, c: '#10b981' },
+                        { v: '15', x: 190, y: 160, c: '#10b981' },
+                        { v: '7', x: 290, y: 160, c: '#10b981' },
+                    ],
+                    edges: [
+                        { x1: 160, y1: 45, x2: 80, y2: 80 },
+                        { x1: 160, y1: 45, x2: 240, y2: 80 },
+                        { x1: 240, y1: 110, x2: 190, y2: 145 },
+                        { x1: 240, y1: 110, x2: 290, y2: 145 },
+                    ],
+                    highlight: 'all',
+                    label: '3 != -1 → True ✅ 全ノード均衡！',
+                },
+            };
+
+            const varStates = {
+                entry: { node: '3', left_height: '未計算', right_height: '未計算', result: '—' },
+                base: { node: 'None', left_height: '—', right_height: '—', result: '0 を返す' },
+                left: { node: '3', left_height: '1', right_height: '未計算', result: '—' },
+                right: { node: '3', left_height: '1', right_height: '2', result: '—' },
+                balance: {
+                    node: '3',
+                    left_height: '1',
+                    right_height: '2',
+                    result: 'abs(1-2)=1 ≤ 1 → OK',
+                },
+                height: { node: '3', left_height: '1', right_height: '2', result: 'return 3' },
+                final: {
+                    node: 'root',
+                    left_height: '—',
+                    right_height: '—',
+                    result: '3 != -1 → True',
+                },
+            };
+
+            function TreeViz({ visual }) {
+                const data = treeNodes[visual];
+                if (!data) return null;
+                return (
+                    <div className="mt-3">
+                        <svg
+                            viewBox="0 0 340 200"
+                            style={{
+                                width: '100%',
+                                maxWidth: '340px',
+                                display: 'block',
+                                margin: '0 auto',
+                            }}
+                        >
+                            {data.edges.map((e, i) => (
+                                <line
+                                    key={i}
+                                    x1={e.x1}
+                                    y1={e.y1}
+                                    x2={e.x2}
+                                    y2={e.y2}
+                                    stroke="#cbd5e1"
+                                    strokeWidth="2"
+                                />
+                            ))}
+                            {data.nodes.map((n, i) => (
+                                <g key={i}>
+                                    <circle
+                                        cx={n.x}
+                                        cy={n.y + 15}
+                                        r="22"
+                                        fill={n.c}
+                                        stroke={n.c === '#e2e8f0' ? '#cbd5e1' : 'white'}
+                                        strokeWidth="2.5"
+                                    />
+                                    <text
+                                        x={n.x}
+                                        y={n.y + 20}
+                                        textAnchor="middle"
+                                        fontSize="13"
+                                        fontFamily="JetBrains Mono,monospace"
+                                        fill="white"
+                                        fontWeight="700"
+                                    >
+                                        {n.v}
+                                    </text>
+                                </g>
+                            ))}
+                        </svg>
+                        <p className="text-center text-xs text-slate-500 mt-2 font-mono">
+                            {data.label}
+                        </p>
+                    </div>
+                );
+            }
+
+            function VarPanel({ visual }) {
+                const v = varStates[visual] || {};
+                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>
+                        <div className="grid grid-cols-2 gap-1">
+                            <div>
+                                <span className="text-violet-500">node</span> ={' '}
+                                <span className="text-slate-700">{v.node}</span>
+                            </div>
+                            <div>
+                                <span className="text-emerald-600">left_height</span> ={' '}
+                                <span className="text-slate-700">{v.left_height}</span>
+                            </div>
+                            <div>
+                                <span className="text-sky-600">right_height</span> ={' '}
+                                <span className="text-slate-700">{v.right_height}</span>
+                            </div>
+                            <div>
+                                <span className="text-amber-600">戻り値</span> ={' '}
+                                <span className="text-slate-700">{v.result}</span>
+                            </div>
+                        </div>
+                    </div>
+                );
+            }
+
+            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);
+                            }
+                        }, 2000);
+                    }
+                    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((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-sm rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                isActive
+                                                    ? 'bg-gradient-to-br from-emerald-50 to-teal-50 border-emerald-400 shadow-md'
+                                                    : 'bg-white border-slate-200 hover:border-emerald-300 hover:translate-x-1',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5',
+                                                    isActive
+                                                        ? 'text-emerald-800'
+                                                        : 'text-slate-700',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}
+                                            </div>
+                                            <div className="text-slate-500 text-xs">
+                                                {step.title}
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        <div className="my-auto">
+                            {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}）：
+                                    {stepsData[activeStep - 2]?.title}
+                                </div>
+                            )}
+
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-gradient-to-br from-emerald-50 to-sky-50">
+                                <h3 className="mt-0 text-teal-800 text-base font-bold mb-1">
+                                    Step {currentStepData.step}: {currentStepData.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2">
+                                    {currentStepData.desc}
+                                </p>
+                            </div>
+
+                            <TreeViz visual={currentStepData.visual} />
+                            <VarPanel visual={currentStepData.visual} />
+
+                            <div className="flex flex-wrap justify-center gap-2 mt-4">
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-emerald-500 to-emerald-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => setIsPlaying(true)}
+                                    disabled={isPlaying}
+                                >
+                                    ▶ Play
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-sky-500 to-sky-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.max(1, s - 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === 1}
+                                >
+                                    ◀ Prev
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-40 bg-gradient-to-br from-sky-500 to-sky-600 text-sm shadow hover:-translate-y-0.5"
+                                    onClick={() => {
+                                        setActiveStep((s) => Math.min(stepsData.length, s + 1));
+                                        setIsPlaying(false);
+                                    }}
+                                    disabled={activeStep === stepsData.length}
+                                >
+                                    Next ▶
+                                </button>
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-slate-700 transition bg-white border-2 border-slate-200 text-sm shadow hover:-translate-y-0.5"
+                                    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 />);
+
+            setTimeout(() => {
+                if (window.Prism) Prism.highlightAll();
+            }, 500);
+        </script>
+    </body>
+</html>
diff --git a/public/Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/README_react.html b/public/Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/README_react.html
new file mode 100644
index 0000000..590b8c8
--- /dev/null
+++ b/public/Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder Traversal/claude sonnet 4.6 extended/README_react.html	
@@ -0,0 +1,1573 @@
+<!doctype html>
+<html lang="ja">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1.0" />
+        <title>LeetCode 94 - Binary Tree Inorder Traversal</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="preconnect" href="https://fonts.googleapis.com" />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Outfit:wght@400;600;700;900&family=JetBrains+Mono:wght@400;600;700&family=Noto+Sans+JP:wght@400;500;700&display=swap"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/themes/prism-tomorrow.css"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/plugins/line-numbers/prism-line-numbers.css"
+            rel="stylesheet"
+        />
+        <link
+            href="/vendor/prismjs/plugins/toolbar/prism-toolbar.css"
+            rel="stylesheet"
+        />
+        <script src="/vendor/prismjs/prism.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>
+        <script src="/vendor/prismjs/components/prism-python.min.js"></script>
+        <script src="/vendor/prismjs/components/prism-typescript.min.js"></script>
+        <script src="/vendor/prismjs/components/prism-rust.min.js"></script>
+        <style>
+            html {
+                scroll-behavior: smooth;
+            }
+            body {
+                font-family: 'Noto Sans JP', sans-serif;
+            }
+            .outfit {
+                font-family: 'Outfit', sans-serif;
+            }
+            .mono {
+                font-family: 'JetBrains Mono', monospace;
+            }
+            .code-toolbar > .toolbar {
+                top: 0.6em;
+                right: 0.8em;
+                opacity: 1 !important;
+            }
+            .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;
+                text-shadow: none !important;
+            }
+            .code-toolbar > .toolbar .toolbar-item button:hover,
+            .code-toolbar > .toolbar .toolbar-item a:hover {
+                background: #059669 !important;
+                color: white !important;
+            }
+            pre[class*='language-'] {
+                border-radius: 12px;
+                font-size: 0.85rem;
+            }
+            .tab-btn {
+                transition: all 0.2s;
+            }
+            .tab-btn.active {
+                background: linear-gradient(135deg, #10b981, #059669);
+                color: white;
+                box-shadow: 0 4px 12px rgba(16, 185, 129, 0.3);
+            }
+        </style>
+    </head>
+    <body class="bg-[linear-gradient(135deg,#f0fdf4,#e0f2fe)] min-h-screen p-4 md:p-8">
+        <div class="max-w-5xl 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 outfit"
+                        >LeetCode 94</span
+                    >
+                    <span
+                        class="bg-sky-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Easy</span
+                    >
+                    <span
+                        class="bg-purple-500 text-white text-sm font-bold px-3 py-1 rounded-full outfit"
+                        >Tree / DFS</span
+                    >
+                </div>
+                <h1 class="outfit text-[2.2rem] font-extrabold text-teal-900 mb-1 leading-tight">
+                    Binary Tree Inorder Traversal
+                </h1>
+                <p class="text-lg text-cyan-700 font-semibold mt-1">
+                    反復スタック（明示スタック）による O(N) 中順走査
+                </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
+                    >
+                </nav>
+            </header>
+
+            <!-- ====== OVERVIEW ====== -->
+            <section id="overview" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    アルゴリズム概要
+                </h2>
+                <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-xs font-mono break-all leading-tight">
+                            中順走査
+                        </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-xs font-mono break-all leading-tight">O(N)</div>
+                        <div class="text-xs mt-1">時間計算量</div>
+                    </div>
+                    <div
+                        style="background: #fef3c7; color: #92400e"
+                        class="rounded-xl p-3 text-center"
+                    >
+                        <div class="font-bold text-xs font-mono break-all leading-tight">O(N)</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">
+                            反復スタック
+                        </div>
+                        <div class="text-xs mt-1">再帰なし実装</div>
+                    </div>
+                </div>
+
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+                    <div class="rounded-xl p-5 bg-slate-50 border border-slate-200">
+                        <h3 class="outfit font-bold text-teal-800 text-base mb-3">📌 問題要約</h3>
+                        <p class="text-sm text-slate-600 leading-7">
+                            二分木の根ノード
+                            <span class="mono text-emerald-700 font-bold">root</span> が与えられる。
+                            <strong>中順走査（左→根→右）</strong>
+                            でノードの値を収集し、リストとして返す。<br />
+                            Follow-up:
+                            <span class="text-amber-700 font-semibold">再帰を使わない反復解</span
+                            >を実装せよ。
+                        </p>
+                        <div class="mt-3 rounded-lg bg-emerald-50 border border-emerald-200 p-3">
+                            <p class="text-xs font-mono text-emerald-800">
+                                <strong>Input:</strong> root = [1, null, 2, 3]<br />
+                                <strong>Output:</strong> [1, 3, 2]
+                            </p>
+                        </div>
+                    </div>
+                    <div class="rounded-xl p-5 bg-slate-50 border border-slate-200">
+                        <h3 class="outfit font-bold text-teal-800 text-base mb-3">📏 制約</h3>
+                        <ul class="text-sm text-slate-600 leading-7 list-none space-y-1">
+                            <li>🔢 ノード数 N: 0 ≤ N ≤ 100</li>
+                            <li>🔢 値の範囲: −100 ≤ val ≤ 100</li>
+                            <li>⚠️ Python再帰上限: デフォルト 1,000（N&gt;1000で危険）</li>
+                            <li>✅ 反復実装でスタックオーバーフロー回避</li>
+                        </ul>
+                    </div>
+                </div>
+            </section>
+
+            <!-- ====== STEPS: React Mount Point ====== -->
+            <section id="steps" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    ステップ解説
+                </h2>
+                <div id="react-steps-root"></div>
+            </section>
+
+            <!-- ====== CODE ====== -->
+            <section id="code" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    実装コード
+                </h2>
+                <!-- Tab buttons -->
+                <div class="flex gap-2 mb-4 flex-wrap" id="lang-tabs">
+                    <button
+                        type="button"
+                        class="tab-btn active px-4 py-2 rounded-lg font-semibold text-sm border-2 border-emerald-300"
+                        onclick="showTab('python')"
+                    >
+                        Python
+                    </button>
+                    <button
+                        type="button"
+                        class="tab-btn px-4 py-2 rounded-lg font-semibold text-sm border-2 border-slate-200 bg-white text-slate-700"
+                        onclick="showTab('typescript')"
+                    >
+                        TypeScript
+                    </button>
+                    <button
+                        type="button"
+                        class="tab-btn px-4 py-2 rounded-lg font-semibold text-sm border-2 border-slate-200 bg-white text-slate-700"
+                        onclick="showTab('rust')"
+                    >
+                        Rust
+                    </button>
+                </div>
+
+                <!-- Python -->
+                <div id="tab-python">
+                    <pre
+                        class="line-numbers"
+                    ><code class="language-python">from __future__ import annotations
+from typing import Optional
+
+
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(
+        self,
+        val: int = 0,
+        left: Optional["TreeNode"] = None,
+        right: Optional["TreeNode"] = None,
+    ) -> None:
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    """
+    LeetCode 94 - Binary Tree Inorder Traversal
+    中順走査（左→根→右）を明示スタックによる反復で実装。
+
+    Time:  O(N) - 全ノードを一度だけ訪問
+    Space: O(N) - 明示スタックの最大深さ（最悪: 左偏木で N）
+    """
+
+    def inorderTraversal(self, root: Optional[TreeNode]) -> list[int]:
+        # ── ガード: 空木は即座に空リストを返す
+        if root is None:
+            return []
+
+        result: list[int] = []          # 中順走査の結果
+        stack: list[TreeNode] = []      # 明示スタック（非 None のみ格納）
+        cur: Optional[TreeNode] = root  # 現在注目しているノード
+
+        while cur is not None or stack:
+
+            # Ph1: 左端まで潜りながらスタックに積む
+            while cur is not None:
+                stack.append(cur)   # 右・自身は後回し
+                cur = cur.left      # 左へ進む
+
+            # Ph2: スタック top を取り出して訪問
+            node: TreeNode = stack.pop()
+            result.append(node.val)  # ← 中順で値を記録
+
+            # Ph3: 右部分木へカーソルを移す
+            cur = node.right  # None なら次ループで即 Ph2 へ
+
+        return result</code></pre>
+                </div>
+
+                <!-- TypeScript -->
+                <div id="tab-typescript" style="display: none">
+                    <pre class="line-numbers"><code class="language-typescript">/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+/**
+ * Binary Tree Inorder Traversal（反復・明示スタック実装）
+ * @complexity Time: O(N), Space: O(N)
+ */
+function inorderTraversal(root: TreeNode | null): number[] {
+    if (root === null) return [];
+
+    const result: number[]   = [];
+    const stack: TreeNode[]  = [];
+    let current: TreeNode | null = root;
+
+    while (current !== null || stack.length > 0) {
+
+        // Ph1: 左端まで潜る
+        while (current !== null) {
+            stack.push(current);
+            current = current.left;
+        }
+
+        // Ph2: 訪問
+        const node = stack.pop()!;   // stack.length > 0 保証済み
+        result.push(node.val);
+
+        // Ph3: 右へ移動
+        current = node.right;
+    }
+
+    return result;
+}</code></pre>
+                </div>
+
+                <!-- Rust -->
+                <div id="tab-rust" style="display: none">
+                    <pre
+                        class="line-numbers"
+                    ><code class="language-rust">// use std::rc::Rc; use std::cell::RefCell; // LeetCode 環境で提供済み
+
+/// Binary Tree Inorder Traversal（反復・明示スタック実装）
+///
+/// # Complexity
+/// - Time:  O(N)
+/// - Space: O(N)
+pub fn inorder_traversal(root: Option&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;) -> Vec&lt;i32&gt; {
+    if root.is_none() { return vec![]; }
+
+    let mut result: Vec&lt;i32&gt;                    = Vec::new();
+    let mut stack:  Vec&lt;Rc&lt;RefCell&lt;TreeNode&gt;&gt;&gt;  = Vec::new();
+    let mut current = root;
+
+    while current.is_some() || !stack.is_empty() {
+
+        // Ph1: 左端まで潜りながらスタックに積む
+        while let Some(node_rc) = current {
+            stack.push(Rc::clone(&node_rc));
+            let left = node_rc.borrow().left.clone();
+            current = left;
+        }
+
+        // Ph2: スタック top を取り出して訪問
+        if let Some(node_rc) = stack.pop() {
+            let (val, right) = {
+                let node = node_rc.borrow();
+                (node.val, node.right.clone())
+            }; // Ref が drop され借用解放
+
+            result.push(val);
+
+            // Ph3: 右部分木へカーソルを移す
+            current = right;
+        }
+    }
+
+    result
+}</code></pre>
+                </div>
+            </section>
+
+            <!-- ====== DIAGRAM ====== -->
+            <section id="diagram" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    処理フローチャート
+                </h2>
+                <div class="mt-5 overflow-x-auto">
+                    <svg
+                        viewBox="0 0 560 1060"
+                        style="
+                            max-width: 560px;
+                            width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 0 auto;
+                        "
+                        role="img"
+                        aria-label="Binary Tree Inorder Traversal 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="#dc2626" />
+                            </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>
+
+                        <!-- 開始 -->
+                        <ellipse
+                            cx="280"
+                            cy="42"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="42"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="15"
+                            font-weight="bold"
+                            fill="#065f46"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            開始
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="70"
+                            x2="280"
+                            y2="97"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- 初期化 -->
+                        <rect
+                            x="60"
+                            y="102"
+                            width="440"
+                            height="60"
+                            rx="10"
+                            fill="#e0f2fe"
+                            stroke="#0284c7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="124"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#0c4a6e"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            初期化
+                        </text>
+                        <line
+                            x1="80"
+                            y1="136"
+                            x2="480"
+                            y2="136"
+                            stroke="#bae6fd"
+                            stroke-width="1"
+                        />
+                        <text
+                            x="280"
+                            y="152"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#0369a1"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            result=[] stack=[] cur=root
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="162"
+                            x2="280"
+                            y2="189"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- ループ条件ダイヤモンド -->
+                        <polygon
+                            points="280,194 460,244 280,294 100,244"
+                            fill="#fef3c7"
+                            stroke="#f59e0b"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="236"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="bold"
+                            fill="#78350f"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            cur != None
+                        </text>
+                        <text
+                            x="280"
+                            y="254"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#92400e"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            または stack 非空?
+                        </text>
+
+                        <!-- No → 終了へ -->
+                        <line
+                            x1="460"
+                            y1="244"
+                            x2="520"
+                            y2="244"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+                        <text
+                            x="491"
+                            y="234"
+                            text-anchor="middle"
+                            font-size="11"
+                            fill="#dc2626"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            No
+                        </text>
+                        <line
+                            x1="520"
+                            y1="244"
+                            x2="520"
+                            y2="990"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <line
+                            x1="520"
+                            y1="990"
+                            x2="395"
+                            y2="990"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <!-- Yes → Ph1 -->
+                        <line
+                            x1="280"
+                            y1="294"
+                            x2="280"
+                            y2="321"
+                            stroke="#059669"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="245"
+                            y="311"
+                            text-anchor="middle"
+                            font-size="11"
+                            fill="#059669"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            Yes
+                        </text>
+
+                        <!-- Ph1ダイヤモンド -->
+                        <polygon
+                            points="280,326 440,366 280,406 120,366"
+                            fill="#f0fdf4"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="358"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            font-weight="bold"
+                            fill="#065f46"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            Ph1: cur != None?
+                        </text>
+                        <text
+                            x="280"
+                            y="376"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#047857"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            （左端まで潜る）
+                        </text>
+
+                        <!-- Ph1 Yes → push & move left -->
+                        <line
+                            x1="280"
+                            y1="406"
+                            x2="280"
+                            y2="433"
+                            stroke="#059669"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <text
+                            x="245"
+                            y="423"
+                            text-anchor="middle"
+                            font-size="11"
+                            fill="#059669"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            Yes
+                        </text>
+
+                        <rect
+                            x="60"
+                            y="438"
+                            width="440"
+                            height="60"
+                            rx="10"
+                            fill="#ecfdf5"
+                            stroke="#059669"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="460"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#065f46"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            スタックに積む
+                        </text>
+                        <line
+                            x1="80"
+                            y1="472"
+                            x2="480"
+                            y2="472"
+                            stroke="#a7f3d0"
+                            stroke-width="1"
+                        />
+                        <text
+                            x="280"
+                            y="488"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#047857"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            stack.append(cur) cur = cur.left
+                        </text>
+
+                        <!-- ループバック矢印 -->
+                        <line x1="60" y1="468" x2="30" y2="468" stroke="#a855f7" stroke-width="2" />
+                        <line x1="30" y1="468" x2="30" y2="366" stroke="#a855f7" stroke-width="2" />
+                        <line
+                            x1="30"
+                            y1="366"
+                            x2="120"
+                            y2="366"
+                            stroke="#a855f7"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowPurple)"
+                        />
+                        <text
+                            x="18"
+                            y="420"
+                            text-anchor="middle"
+                            font-size="10"
+                            fill="#a855f7"
+                            font-family="Noto Sans JP, sans-serif"
+                            transform="rotate(-90,18,420)"
+                        >
+                            繰り返し
+                        </text>
+
+                        <!-- Ph1 No → Ph2 -->
+                        <line
+                            x1="440"
+                            y1="366"
+                            x2="530"
+                            y2="366"
+                            stroke="#64748b"
+                            stroke-width="2"
+                        />
+                        <line
+                            x1="530"
+                            y1="366"
+                            x2="530"
+                            y2="546"
+                            stroke="#64748b"
+                            stroke-width="2"
+                        />
+                        <line
+                            x1="530"
+                            y1="546"
+                            x2="500"
+                            y2="546"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+                        <text
+                            x="488"
+                            y="355"
+                            text-anchor="middle"
+                            font-size="11"
+                            fill="#64748b"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            No
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="498"
+                            x2="280"
+                            y2="527"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- Ph2 pop + record -->
+                        <rect
+                            x="60"
+                            y="532"
+                            width="440"
+                            height="78"
+                            rx="10"
+                            fill="#eff6ff"
+                            stroke="#3b82f6"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="554"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#1e3a8a"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            Ph2: スタックから取り出して訪問
+                        </text>
+                        <line
+                            x1="80"
+                            y1="567"
+                            x2="480"
+                            y2="567"
+                            stroke="#bfdbfe"
+                            stroke-width="1"
+                        />
+                        <text
+                            x="280"
+                            y="584"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1d4ed8"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            node = stack.pop()
+                        </text>
+                        <text
+                            x="280"
+                            y="602"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#1d4ed8"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            result.append(node.val) ← 中順で記録
+                        </text>
+
+                        <line
+                            x1="280"
+                            y1="610"
+                            x2="280"
+                            y2="637"
+                            stroke="#64748b"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrow)"
+                        />
+
+                        <!-- Ph3 right -->
+                        <rect
+                            x="60"
+                            y="642"
+                            width="440"
+                            height="60"
+                            rx="10"
+                            fill="#faf5ff"
+                            stroke="#a855f7"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="664"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#4c1d95"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            Ph3: 右部分木へ移動
+                        </text>
+                        <line
+                            x1="80"
+                            y1="676"
+                            x2="480"
+                            y2="676"
+                            stroke="#e9d5ff"
+                            stroke-width="1"
+                        />
+                        <text
+                            x="280"
+                            y="692"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="11"
+                            fill="#6d28d9"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            cur = node.right
+                        </text>
+
+                        <!-- ループバック to ループ条件 -->
+                        <line
+                            x1="280"
+                            y1="702"
+                            x2="280"
+                            y2="730"
+                            stroke="#a855f7"
+                            stroke-width="2"
+                        />
+                        <line
+                            x1="280"
+                            y1="730"
+                            x2="560"
+                            y2="730"
+                            stroke="#a855f7"
+                            stroke-width="2"
+                        />
+                        <line
+                            x1="560"
+                            y1="730"
+                            x2="560"
+                            y2="196"
+                            stroke="#a855f7"
+                            stroke-width="2"
+                        />
+                        <line
+                            x1="560"
+                            y1="196"
+                            x2="500"
+                            y2="196"
+                            stroke="#a855f7"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowPurple)"
+                        />
+                        <text
+                            x="548"
+                            y="460"
+                            text-anchor="middle"
+                            font-size="10"
+                            fill="#a855f7"
+                            font-family="Noto Sans JP, sans-serif"
+                            transform="rotate(-90,548,460)"
+                        >
+                            ループ継続
+                        </text>
+
+                        <!-- 結果出力 -->
+                        <line
+                            x1="395"
+                            y1="990"
+                            x2="280"
+                            y2="990"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                        />
+                        <line
+                            x1="280"
+                            y1="990"
+                            x2="280"
+                            y2="963"
+                            stroke="#dc2626"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowRed)"
+                        />
+
+                        <rect
+                            x="60"
+                            y="882"
+                            width="440"
+                            height="76"
+                            rx="12"
+                            fill="#d1fae5"
+                            stroke="#059669"
+                            stroke-width="2.5"
+                        />
+                        <text
+                            x="280"
+                            y="908"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="13"
+                            font-weight="bold"
+                            fill="#065f46"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            結果を返す
+                        </text>
+                        <line
+                            x1="80"
+                            y1="921"
+                            x2="480"
+                            y2="921"
+                            stroke="#a7f3d0"
+                            stroke-width="1"
+                        />
+                        <text
+                            x="280"
+                            y="942"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="12"
+                            fill="#047857"
+                            font-family="JetBrains Mono, monospace"
+                        >
+                            return result # list[int]
+                        </text>
+
+                        <!-- 終了 -->
+                        <line
+                            x1="280"
+                            y1="882"
+                            x2="280"
+                            y2="855"
+                            stroke="#059669"
+                            stroke-width="2"
+                            marker-end="url(#fc-arrowGreen)"
+                        />
+                        <ellipse
+                            cx="280"
+                            cy="828"
+                            rx="110"
+                            ry="28"
+                            fill="#d1fae5"
+                            stroke="#10b981"
+                            stroke-width="2"
+                        />
+                        <text
+                            x="280"
+                            y="828"
+                            text-anchor="middle"
+                            dominant-baseline="middle"
+                            font-size="15"
+                            font-weight="bold"
+                            fill="#065f46"
+                            font-family="Noto Sans JP, sans-serif"
+                        >
+                            終了
+                        </text>
+                    </svg>
+                </div>
+
+                <div class="mt-6 rounded-xl p-5 bg-slate-50 border border-slate-200">
+                    <p class="text-slate-700 leading-8 text-sm">
+                        <strong class="text-base text-teal-800">フローの説明：</strong><br />
+                        1. <strong>初期化</strong>: result・stack・curを初期設定する。<br />
+                        2. <strong>ループ条件</strong>:
+                        curが非Noneまたはstackが空でない間、3フェーズを繰り返す。<br />
+                        3. <strong>Ph1（緑）</strong>:
+                        curが非Noneの間、左端まで潜りながらスタックに積む（ループバック＝紫矢印）。<br />
+                        4. <strong>Ph2（青）</strong>: スタックからpopし、val
+                        を結果リストに中順で記録する。<br />
+                        5. <strong>Ph3（紫）</strong>: cur = node.right
+                        に移動し、ループ条件へ戻る（紫矢印）。<br />
+                        6. <strong>終了（赤）</strong>: curとstackが共に空になったら結果を返す。
+                    </p>
+                </div>
+            </section>
+
+            <!-- ====== COMPLEXITY ====== -->
+            <section id="complexity" class="bg-white rounded-2xl p-8 mb-8 shadow">
+                <h2
+                    class="outfit text-[1.9rem] font-bold text-cyan-700 mb-4 pb-2 border-b-[3px] border-emerald-200"
+                >
+                    計算量分析
+                </h2>
+
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-6 mb-6">
+                    <div
+                        class="rounded-xl p-5 bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-2 border-emerald-300"
+                    >
+                        <div class="outfit text-2xl font-black text-emerald-900 mb-1">O(N)</div>
+                        <div class="font-bold text-emerald-800 text-sm">時間計算量</div>
+                        <p class="text-xs text-emerald-700 mt-2 leading-5">
+                            全ノードをスタックに push 1回・pop 1回の合計 2N 操作。定数倍を無視すると
+                            O(N)。
+                        </p>
+                    </div>
+                    <div
+                        class="rounded-xl p-5 bg-[linear-gradient(135deg,#bfdbfe,#93c5fd)] border-2 border-blue-300"
+                    >
+                        <div class="outfit text-2xl font-black text-blue-900 mb-1">O(N)</div>
+                        <div class="font-bold text-blue-800 text-sm">空間計算量</div>
+                        <p class="text-xs text-blue-700 mt-2 leading-5">
+                            明示スタックの最大深さ。最悪ケースは N
+                            ノードが全て左に偏った木（スタック深さ = N）。
+                        </p>
+                    </div>
+                </div>
+
+                <div class="overflow-x-auto">
+                    <table class="w-full text-sm border-collapse">
+                        <thead>
+                            <tr class="bg-slate-100">
+                                <th
+                                    class="p-3 text-left font-bold text-slate-700 border border-slate-200 rounded-tl-lg"
+                                >
+                                    アプローチ
+                                </th>
+                                <th
+                                    class="p-3 text-center font-bold text-slate-700 border border-slate-200"
+                                >
+                                    時間
+                                </th>
+                                <th
+                                    class="p-3 text-center font-bold text-slate-700 border border-slate-200"
+                                >
+                                    空間
+                                </th>
+                                <th
+                                    class="p-3 text-center font-bold text-slate-700 border border-slate-200"
+                                >
+                                    可読性
+                                </th>
+                                <th
+                                    class="p-3 text-center font-bold text-slate-700 border border-slate-200 rounded-tr-lg"
+                                >
+                                    安全性
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            <tr class="bg-emerald-50">
+                                <td class="p-3 border border-slate-200 font-bold text-emerald-800">
+                                    ✅ 反復（明示スタック）
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center mono">O(N)</td>
+                                <td class="p-3 border border-slate-200 text-center mono">O(N)</td>
+                                <td class="p-3 border border-slate-200 text-center">★★★</td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center text-emerald-700 font-bold"
+                                >
+                                    ◎
+                                </td>
+                            </tr>
+                            <tr>
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    再帰 DFS
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center mono">O(N)</td>
+                                <td class="p-3 border border-slate-200 text-center mono">O(N)</td>
+                                <td class="p-3 border border-slate-200 text-center">★★★</td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center text-amber-600 font-bold"
+                                >
+                                    △ ※
+                                </td>
+                            </tr>
+                            <tr class="bg-slate-50">
+                                <td
+                                    class="p-3 border border-slate-200 font-semibold text-slate-700"
+                                >
+                                    Morris Traversal
+                                </td>
+                                <td class="p-3 border border-slate-200 text-center mono">O(N)</td>
+                                <td class="p-3 border border-slate-200 text-center mono">O(1)</td>
+                                <td class="p-3 border border-slate-200 text-center">★☆☆</td>
+                                <td
+                                    class="p-3 border border-slate-200 text-center text-red-600 font-bold"
+                                >
+                                    △ 副作用
+                                </td>
+                            </tr>
+                        </tbody>
+                    </table>
+                    <p class="text-xs text-slate-500 mt-2">
+                        ※ Python デフォルト再帰上限 1,000 でスタックオーバーフローリスクあり
+                    </p>
+                </div>
+            </section>
+
+            <!-- ====== FOOTER ====== -->
+            <footer class="text-center text-slate-400 text-xs py-6">
+                LeetCode 94 — Binary Tree Inorder Traversal | 反復スタック実装解説
+            </footer>
+        </div>
+        <!-- /max-w-5xl -->
+
+        <script>
+            function showTab(lang) {
+                ['python', 'typescript', 'rust'].forEach((l) => {
+                    document.getElementById('tab-' + l).style.display = l === lang ? '' : 'none';
+                });
+                document.querySelectorAll('.tab-btn').forEach((btn, i) => {
+                    const langs = ['python', 'typescript', 'rust'];
+                    btn.classList.toggle('active', langs[i] === lang);
+                    if (langs[i] !== lang) {
+                        btn.classList.add('bg-white', 'text-slate-700');
+                        btn.style.borderColor = '#e2e8f0';
+                    } else {
+                        btn.classList.remove('bg-white', 'text-slate-700');
+                        btn.style.borderColor = '';
+                    }
+                });
+                setTimeout(() => {
+                    if (window.Prism) Prism.highlightAll();
+                }, 50);
+            }
+        </script>
+
+        <!-- ====== REACT: ステップ解説コンポーネント ====== -->
+        <script type="text/babel">
+            const { useState, useEffect, useRef } = React;
+
+            const stepsData = [
+                {
+                    step: 1,
+                    title: '初期化',
+                    desc: 'result（結果リスト）、stack（明示スタック）、cur（カーソル）を初期化します。curはrootから開始。空木（root=None）の場合は即座に[]を返します。',
+                    visual: 'init',
+                },
+                {
+                    step: 2,
+                    title: 'Ph1: 左端まで潜る',
+                    desc: 'cur が None でない間、スタックに積みながら左へ進みます。左端に到達したら Ph2 へ移行。これにより「自身・右」を後回しにして、左部分木を優先処理します。',
+                    visual: 'ph1',
+                },
+                {
+                    step: 3,
+                    title: 'Ph2: スタックから取り出す',
+                    desc: 'stack.pop() でノードを取り出し、val を result に追記します。このタイミングで記録するのが中順（左処理後・根・右前）の定義に一致します。',
+                    visual: 'ph2',
+                },
+                {
+                    step: 4,
+                    title: 'Ph3: 右部分木へ移動',
+                    desc: 'cur = node.right に移動します。right が None なら次のループで即スタックからの pop（Ph2）が実行されます。',
+                    visual: 'ph3',
+                },
+                {
+                    step: 5,
+                    title: 'ループ終了条件',
+                    desc: 'cur が None かつ stack が空になった時点でループを抜け、result を返します。全ノードを一度ずつ push/pop するため O(N) で完了します。',
+                    visual: 'end',
+                },
+            ];
+
+            const TREE = [
+                { id: 1, val: 1, x: 280, y: 60, left: 2, right: 3, parent: null },
+                { id: 2, val: 2, x: 160, y: 140, left: 4, right: 5, parent: 1 },
+                { id: 3, val: 3, x: 400, y: 140, left: null, right: 6, parent: 1 },
+                { id: 4, val: 4, x: 100, y: 220, left: null, right: null, parent: 2 },
+                { id: 5, val: 5, x: 220, y: 220, left: null, right: null, parent: 2 },
+                { id: 6, val: 6, x: 460, y: 220, left: null, right: null, parent: 3 },
+            ];
+
+            const EDGES = [
+                [1, 2, 'left'],
+                [1, 3, 'right'],
+                [2, 4, 'left'],
+                [2, 5, 'right'],
+                [3, 6, 'right'],
+            ];
+
+            // Highlighted nodes per step
+            const STEP_HIGHLIGHT = {
+                1: { active: [], stack: [], result: [] },
+                2: { active: [4, 2, 1], stack: [1, 2, 4], result: [] },
+                3: { active: [4], stack: [1, 2], result: [4] },
+                4: { active: [5], stack: [1], result: [4, 2] },
+                5: { active: [], stack: [], result: [4, 2, 5, 1, 3, 6] },
+            };
+
+            function TreeViz({ stepIdx }) {
+                const hl = STEP_HIGHLIGHT[stepIdx] || STEP_HIGHLIGHT[1];
+
+                const getColor = (nodeId) => {
+                    if (hl.result.includes(nodeId))
+                        return { fill: '#d1fae5', stroke: '#10b981', text: '#065f46' };
+                    if (hl.stack.includes(nodeId))
+                        return { fill: '#fef3c7', stroke: '#f59e0b', text: '#78350f' };
+                    if (hl.active.includes(nodeId))
+                        return { fill: '#bfdbfe', stroke: '#3b82f6', text: '#1e40af' };
+                    return { fill: '#f1f5f9', stroke: '#94a3b8', text: '#475569' };
+                };
+
+                const nodeMap = Object.fromEntries(TREE.map((n) => [n.id, n]));
+
+                return (
+                    <svg
+                        viewBox="0 0 560 290"
+                        style={{
+                            width: '100%',
+                            maxWidth: '480px',
+                            display: 'block',
+                            margin: '0 auto',
+                        }}
+                    >
+                        {/* Edges */}
+                        {EDGES.map(([from, to]) => {
+                            const f = nodeMap[from],
+                                t = nodeMap[to];
+                            return (
+                                <line
+                                    key={`${from}-${to}`}
+                                    x1={f.x}
+                                    y1={f.y}
+                                    x2={t.x}
+                                    y2={t.y}
+                                    stroke="#94a3b8"
+                                    strokeWidth="2"
+                                />
+                            );
+                        })}
+                        {/* Nodes */}
+                        {TREE.map((node) => {
+                            const c = getColor(node.id);
+                            return (
+                                <g key={node.id}>
+                                    <circle
+                                        cx={node.x}
+                                        cy={node.y}
+                                        r="26"
+                                        fill={c.fill}
+                                        stroke={c.stroke}
+                                        strokeWidth="2.5"
+                                    />
+                                    <text
+                                        x={node.x}
+                                        y={node.y}
+                                        textAnchor="middle"
+                                        dominantBaseline="middle"
+                                        fontSize="16"
+                                        fontWeight="bold"
+                                        fill={c.text}
+                                        fontFamily="JetBrains Mono, monospace"
+                                    >
+                                        {node.val}
+                                    </text>
+                                </g>
+                            );
+                        })}
+                        {/* Legend */}
+                        <g>
+                            <circle
+                                cx="40"
+                                cy="268"
+                                r="8"
+                                fill="#bfdbfe"
+                                stroke="#3b82f6"
+                                strokeWidth="1.5"
+                            />
+                            <text
+                                x="55"
+                                y="272"
+                                fontSize="10"
+                                fill="#1e40af"
+                                fontFamily="Noto Sans JP, sans-serif"
+                            >
+                                注目中
+                            </text>
+                            <circle
+                                cx="110"
+                                cy="268"
+                                r="8"
+                                fill="#fef3c7"
+                                stroke="#f59e0b"
+                                strokeWidth="1.5"
+                            />
+                            <text
+                                x="125"
+                                y="272"
+                                fontSize="10"
+                                fill="#78350f"
+                                fontFamily="Noto Sans JP, sans-serif"
+                            >
+                                スタック
+                            </text>
+                            <circle
+                                cx="185"
+                                cy="268"
+                                r="8"
+                                fill="#d1fae5"
+                                stroke="#10b981"
+                                strokeWidth="1.5"
+                            />
+                            <text
+                                x="200"
+                                y="272"
+                                fontSize="10"
+                                fill="#065f46"
+                                fontFamily="Noto Sans JP, sans-serif"
+                            >
+                                訪問済み
+                            </text>
+                        </g>
+                    </svg>
+                );
+            }
+
+            function ResultBar({ stepIdx }) {
+                const hl = STEP_HIGHLIGHT[stepIdx] || { result: [] };
+                const allVals = [4, 2, 5, 1, 3, 6];
+                return (
+                    <div className="flex items-center gap-2 mt-3 flex-wrap">
+                        <span className="text-xs font-bold text-slate-500 mono">result:</span>
+                        <span className="text-xs font-mono text-slate-400">[</span>
+                        {hl.result.map((v, i) => (
+                            <span
+                                key={i}
+                                className="px-2 py-0.5 rounded-md text-xs font-bold mono bg-emerald-100 text-emerald-800 border border-emerald-300"
+                            >
+                                {v}
+                            </span>
+                        ))}
+                        {hl.result.length === 0 && (
+                            <span className="text-xs text-slate-400 mono">空</span>
+                        )}
+                        <span className="text-xs font-mono text-slate-400">]</span>
+                    </div>
+                );
+            }
+
+            function StepsApp() {
+                const [activeStep, setActiveStep] = useState(1);
+                const [isPlaying, setIsPlaying] = useState(false);
+                const timerRef = useRef(null);
+
+                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]);
+
+                const cur = stepsData.find((s) => s.step === activeStep) || stepsData[0];
+
+                return (
+                    <div className="grid grid-cols-1 md:grid-cols-[1fr_2fr] gap-8 mt-2">
+                        {/* Step list */}
+                        <div>
+                            <h3 className="mt-0 mb-4 text-teal-800 text-base font-bold outfit">
+                                ステップ一覧
+                            </h3>
+                            <div className="space-y-2">
+                                {stepsData.map((step) => {
+                                    const isActive = activeStep === step.step;
+                                    return (
+                                        <button
+                                            key={step.step}
+                                            type="button"
+                                            className={[
+                                                'w-full text-left text-[0.9rem] rounded-xl border-2 transition cursor-pointer px-4 py-3',
+                                                'bg-white border-slate-200 hover:border-emerald-400 hover:translate-x-1',
+                                                isActive
+                                                    ? 'bg-[linear-gradient(135deg,#d1fae5,#a7f3d0)] border-emerald-500 shadow-[0_4px_12px_rgba(16,185,129,0.20)]'
+                                                    : '',
+                                            ].join(' ')}
+                                            onClick={() => {
+                                                setActiveStep(step.step);
+                                                setIsPlaying(false);
+                                            }}
+                                            aria-label={`ステップ${step.step}: ${step.title}`}
+                                            aria-current={isActive ? 'step' : undefined}
+                                        >
+                                            <div
+                                                className={[
+                                                    'font-bold mb-0.5 text-sm',
+                                                    isActive ? 'text-emerald-900' : 'text-teal-800',
+                                                ].join(' ')}
+                                            >
+                                                Step {step.step}: {step.title}
+                                            </div>
+                                            <div className="text-slate-500 text-xs">
+                                                {step.desc.substring(0, 44)}
+                                                {step.desc.length > 44 ? '…' : ''}
+                                            </div>
+                                        </button>
+                                    );
+                                })}
+                            </div>
+                        </div>
+
+                        {/* Detail panel */}
+                        <div>
+                            <div className="rounded-2xl p-5 border-2 border-emerald-200 bg-[linear-gradient(135deg,#ecfdf5,#f0f9ff)] mb-4">
+                                <h3 className="mt-0 text-teal-800 text-base font-bold outfit">
+                                    Step {cur.step}: {cur.title}
+                                </h3>
+                                <p className="text-slate-600 leading-7 text-sm mt-2">{cur.desc}</p>
+                            </div>
+
+                            {/* Tree visualization */}
+                            <div className="rounded-xl border border-slate-200 bg-slate-50 p-4 mb-3">
+                                <p className="text-xs font-bold text-slate-500 mb-2">
+                                    二分木の状態（例: [1,2,3,4,5,null,6]）
+                                </p>
+                                <TreeViz stepIdx={activeStep} />
+                                <ResultBar stepIdx={activeStep} />
+                            </div>
+
+                            {/* Controls */}
+                            <div className="flex flex-wrap justify-center gap-2 mt-3">
+                                <button
+                                    type="button"
+                                    className="px-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-50 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-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-50 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-4 py-2 rounded-xl font-semibold text-white transition disabled:opacity-50 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-4 py-2 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>
+                        </div>
+                    </div>
+                );
+            }
+
+            const root = ReactDOM.createRoot(document.getElementById('react-steps-root'));
+            root.render(<StepsApp />);
+        </script>
+    </body>
+</html>
diff --git a/public/index.html b/public/index.html
index ce1d553..866c8b1 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">173 interactive lessons across 6 domains</p>
+        <p class="site-subtitle">175 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">173</span>
+            <span class="tab-icon">🌍</span> All <span class="tab-count">175</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">95</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="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>
@@ -467,11 +467,13 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/greedy%20algorithm/leetcode/45.%20Jump%20Game%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Jump Game II アルゴリズム解析</span></span><span class="file-path">Algorithm/greedy algorithm/leetcode/45. Jump Game II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/83.%20Remove%20Duplicates%20from%20Sorted%20List/Claude%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode #83 - Remove Duplicates from Sorted List</span></span><span class="file-path">Algorithm/Other/leetcode/83. Remove Duplicates from Sorted List/Claude 4.6 extended/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/100.%20Same%20Tree/claude%20sonnet%204.6%20extended/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 100 — Same Tree | 再帰DFS解説</span></span><span class="file-path">Algorithm/Other/leetcode/100. Same Tree/claude sonnet 4.6 extended/README_react.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/102.%20Binary%20Tree%20Level%20Order%20Traversal/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 102 · Binary Tree Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/103.%20Binary%20Tree%20Zigzag%20Level%20Order%20Traversal/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 103 – Binary Tree Zigzag Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/104.%20Maximum%20Depth%20of%20Binary%20Tree/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 104 · Maximum Depth of Binary Tree</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/README_React.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/105.%20Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 105 – Construct Binary Tree from Preorder and Inorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/README_React.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/106.%20Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/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/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/README_React.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/102.%20Binary%20Tree%20Level%20Order%20Traversal/claude%20sonnet%204.6%20extended/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 102 · Binary Tree Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order 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/BinaryTree/leetcode/103.%20Binary%20Tree%20Zigzag%20Level%20Order%20Traversal/claude%20sonnet%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 103 – Binary Tree Zigzag Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order 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/BinaryTree/leetcode/104.%20Maximum%20Depth%20of%20Binary%20Tree/claude%20sonnet%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 104 · Maximum Depth of Binary Tree</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README_React.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/105.%20Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/claude%20sonnet%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 105 – Construct Binary Tree from Preorder and Inorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder 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/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/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>
@@ -481,7 +483,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/7.%20Reverse%20Integer/claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 7: Reverse Integer - 文字列反転法</span></span><span class="file-path">Algorithm/Other/leetcode/7. Reverse Integer/claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Sort/MergeSort/leetcode/claude%204.6%20sonnet%20extended/88.%20Merge%20Sorted%20Array/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 88 – Merge Sorted Array</span></span><span class="file-path">Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Backtracking/leetcode/93.%20Restore%20IP%20Addresses/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 93: Restore IP Addresses - DFS + 枝刈り解説</span></span><span class="file-path">Algorithm/Backtracking/leetcode/93. Restore IP Addresses/Claude/README.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/94.%20Binary%20Tree%20Inorder%20Traversal/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 94 - Binary Tree Inorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/README_react.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/94.%20Binary%20Tree%20Inorder%20Traversal/claude%20sonnet%204.6%20extended/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 94 - Binary Tree Inorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder 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/96.%20Unique%20Binary%20Search%20Trees/claude%204.5%20sonnet/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 96: Unique Binary Search Trees - カタラン数解説</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/96. Unique Binary Search Trees/claude 4.5 sonnet/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/DynamicProgramming/leetcode/97.%20Interleaving%20String/Claude%20Sonnet%204.5/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 97: Interleaving String - 1D DP解説</span></span><span class="file-path">Algorithm/DynamicProgramming/leetcode/97. Interleaving String/Claude Sonnet 4.5/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/98.%20Validate%20Binary%20Search%20Tree/Claude%20Sonnet%204.5/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 98: Validate Binary Search Tree</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/98. Validate Binary Search Tree/Claude Sonnet 4.5/README_react.html</span></a></li>
@@ -647,11 +649,13 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/greedy%20algorithm/leetcode/45.%20Jump%20Game%20II/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">Jump Game II アルゴリズム解析</span></span><span class="file-path">Algorithm/greedy algorithm/leetcode/45. Jump Game II/Claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/83.%20Remove%20Duplicates%20from%20Sorted%20List/Claude%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode #83 - Remove Duplicates from Sorted List</span></span><span class="file-path">Algorithm/Other/leetcode/83. Remove Duplicates from Sorted List/Claude 4.6 extended/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/100.%20Same%20Tree/claude%20sonnet%204.6%20extended/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 100 — Same Tree | 再帰DFS解説</span></span><span class="file-path">Algorithm/Other/leetcode/100. Same Tree/claude sonnet 4.6 extended/README_react.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/102.%20Binary%20Tree%20Level%20Order%20Traversal/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 102 · Binary Tree Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/102. Binary Tree Level Order Traversal/README_react.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/103.%20Binary%20Tree%20Zigzag%20Level%20Order%20Traversal/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 103 – Binary Tree Zigzag Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/103. Binary Tree Zigzag Level Order Traversal/README_React.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/104.%20Maximum%20Depth%20of%20Binary%20Tree/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 104 · Maximum Depth of Binary Tree</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/104. Maximum Depth of Binary Tree/README_React.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/105.%20Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 105 – Construct Binary Tree from Preorder and Inorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/105. Construct Binary Tree from Preorder and Inorder Traversal/README_React.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/106.%20Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal/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/claude sonnet 4.6 extended/106. Construct Binary Tree from Inorder and Postorder Traversal/README_React.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/102.%20Binary%20Tree%20Level%20Order%20Traversal/claude%20sonnet%204.6%20extended/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 102 · Binary Tree Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/102. Binary Tree Level Order 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/BinaryTree/leetcode/103.%20Binary%20Tree%20Zigzag%20Level%20Order%20Traversal/claude%20sonnet%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 103 – Binary Tree Zigzag Level Order Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/103. Binary Tree Zigzag Level Order 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/BinaryTree/leetcode/104.%20Maximum%20Depth%20of%20Binary%20Tree/claude%20sonnet%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 104 · Maximum Depth of Binary Tree</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/104. Maximum Depth of Binary Tree/claude sonnet 4.6 extended/README_React.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/105.%20Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal/claude%20sonnet%204.6%20extended/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 105 – Construct Binary Tree from Preorder and Inorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/105. Construct Binary Tree from Preorder and Inorder 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/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/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>
@@ -661,7 +665,7 @@ <h1 class="site-title">
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Other/leetcode/7.%20Reverse%20Integer/claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 7: Reverse Integer - 文字列反転法</span></span><span class="file-path">Algorithm/Other/leetcode/7. Reverse Integer/claude/README.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Sort/MergeSort/leetcode/claude%204.6%20sonnet%20extended/88.%20Merge%20Sorted%20Array/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 88 – Merge Sorted Array</span></span><span class="file-path">Algorithm/Sort/MergeSort/leetcode/claude 4.6 sonnet extended/88. Merge Sorted Array/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/Backtracking/leetcode/93.%20Restore%20IP%20Addresses/Claude/README.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 93: Restore IP Addresses - DFS + 枝刈り解説</span></span><span class="file-path">Algorithm/Backtracking/leetcode/93. Restore IP Addresses/Claude/README.html</span></a></li>
-<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/claude%20sonnet%204.6%20extended/94.%20Binary%20Tree%20Inorder%20Traversal/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 94 - Binary Tree Inorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/claude sonnet 4.6 extended/94. Binary Tree Inorder Traversal/README_react.html</span></a></li>
+<li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinaryTree/leetcode/94.%20Binary%20Tree%20Inorder%20Traversal/claude%20sonnet%204.6%20extended/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 94 - Binary Tree Inorder Traversal</span></span><span class="file-path">Algorithm/BinaryTree/leetcode/94. Binary Tree Inorder 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/96.%20Unique%20Binary%20Search%20Trees/claude%204.5%20sonnet/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 96: Unique Binary Search Trees - カタラン数解説</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/96. Unique Binary Search Trees/claude 4.5 sonnet/README_react.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/DynamicProgramming/leetcode/97.%20Interleaving%20String/Claude%20Sonnet%204.5/README_React.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 97: Interleaving String - 1D DP解説</span></span><span class="file-path">Algorithm/DynamicProgramming/leetcode/97. Interleaving String/Claude Sonnet 4.5/README_React.html</span></a></li>
 <li class="file-item" data-category="algorithm"><a class="file-link" href="Algorithm/BinarySearch/leetcode/98.%20Validate%20Binary%20Search%20Tree/Claude%20Sonnet%204.5/README_react.html"><span class="card-header"><span class="card-icon">🧩</span><span class="card-title">LeetCode 98: Validate Binary Search Tree</span></span><span class="file-path">Algorithm/BinarySearch/leetcode/98. Validate Binary Search Tree/Claude Sonnet 4.5/README_react.html</span></a></li>
@@ -829,7 +833,7 @@ <h1 class="site-title">
 
     <footer>
         <span class="footer-icon">🧪</span>
-        Generated on 2026-05-07
+        Generated on 2026-05-08
     </footer>
 
     <script>