leetcode 17. Letter Combinations of a Phone Number バックトラッキング（DFS探索）

Author: myoshi2891

DataStructures/Trees/BFS・DFS/leetcode/17. Letter Combinations of a Phone Number/LetterCombinationsofaPhoneNumber.py

@@ -0,0 +1,128 @@
+# 以下は、**LeetCode用の Python (CPython 3.11.4)** に準拠した
+# 「電話番号の文字列組み合わせ」問題の実装です。
+
+# ---
+
+# ## **実装内容**
+
+# * **アルゴリズム**：バックトラッキング（DFS探索）
+# * **時間計算量**：
+#   O(3^N × 4^M)
+
+#   * N：3文字キー（2,3,4,5,6,8）の個数
+#   * M：4文字キー（7,9）の個数
+# * **空間計算量**：
+#   O(出力サイズ + 再帰スタック)
+
+# ---
+
+# ## **Pythonコード（LeetCode提出形式）**
+
+# ```python
+from typing import List
+
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        """
+        与えられた数字文字列から、考えられる全ての文字列の組み合わせを返す
+
+        Parameters
+        ----------
+        digits : str
+            電話番号を表す数字文字列 (0 <= len(digits) <= 4)
+
+        Returns
+        -------
+        List[str]
+            数字文字列から作成される全ての文字列の組み合わせ
+
+        時間計算量: O(3^N × 4^M)
+        空間計算量: O(組み合わせ数 + 再帰スタック)
+        """
+        if not digits:
+            return []
+
+        phone_map: dict[str, str] = {
+            "2": "abc", "3": "def", "4": "ghi",
+            "5": "jkl", "6": "mno", "7": "pqrs",
+            "8": "tuv", "9": "wxyz"
+        }
+
+        res: List[str] = []
+
+        def backtrack(index: int, path: str) -> None:
+            """
+            再帰的に文字列の組み合わせを構築する
+
+            Parameters
+            ----------
+            index : int
+                digits内の現在の桁位置
+            path : str
+                現在までの組み合わせ文字列
+            """
+            # 全桁処理完了時に結果保存
+            if index == len(digits):
+                res.append(path)
+                return
+
+            # 現在の数字に対応する文字で探索
+            for letter in phone_map[digits[index]]:
+                backtrack(index + 1, path + letter)
+
+        backtrack(0, "")
+        return res
+
+# ## **動作例**
+
+# ```python
+# solution = Solution()
+# print(solution.letterCombinations("23"))
+# # 出力: ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']
+# ```
+
+# ---
+
+# ## **解説図（探索木）**
+
+# ```
+# digits = "23"
+
+#                    ""
+#           /         |         \
+#         "a"        "b"        "c"
+#       /   \       /   \       /   \
+#    "ad"  "ae"  "bd"  "be"  "cd"  "ce"
+#       \    \     \    \     \     \
+#      "af" "af"  "bf"  "bf"  "cf"  "cf"
+
+# 出力: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]
+# ```
+
+# ---
+
+# ## **時間計算量の詳細**
+
+# | 項目       | 内容                      |
+# | -------- | ----------------------- |
+# | 1桁の組み合わせ | O(3) or O(4)            |
+# | 2桁の組み合わせ | O(3×3) = 9 or O(4×3)=12 |
+# | 最大4桁     | O(3^N × 4^M)            |
+
+# ---
+
+# ## **空間計算量**
+
+# | 項目     | 内容                |
+# | ------ | ----------------- |
+# | 出力リスト  | O(組み合わせ数)         |
+# | 再帰スタック | O(最大深さ＝digitsの長さ) |
+
+# ---
+
+# ## **まとめ**
+
+# * LeetCode提出形式 ✅
+# * 型ヒント ✅
+# * 計算量解析 ✅
+# * 図解による動作説明 ✅

DataStructures/Trees/BFS・DFS/leetcode/17. Letter Combinations of a Phone Number/LetterCombinationsofaPhoneNumber.ts

@@ -0,0 +1,82 @@
+// ローカル実行や関数のみで使いたい場合は、**グローバル関数で実装**できます。
+// LeetCodeの制約を無視して「関数版」のコードを提供します。
+
+// ---
+
+// ## **TypeScript 関数実装（クラスなし）**
+
+// ```typescript
+/**
+ * 与えられた数字文字列から、考えられる全ての文字列の組み合わせを返す
+ * @param digits - 数字文字列（0 <= digits.length <= 4）
+ * @returns 可能な文字列組み合わせの配列
+ * 
+ * 時間計算量: O(3^N × 4^M)  
+ * 空間計算量: O(出力サイズ + 再帰スタック)
+ */
+function letterCombinations(digits: string): string[] {
+    if (digits.length === 0) return [];
+
+    const phoneMap: Record<string, string> = {
+        '2': "abc", '3': "def", '4': "ghi",
+        '5': "jkl", '6': "mno", '7': "pqrs",
+        '8': "tuv", '9': "wxyz"
+    };
+
+    const result: string[] = [];
+
+    function backtrack(index: number, path: string): void {
+        if (index === digits.length) {
+            result.push(path);
+            return;
+        }
+
+        const currentDigit = digits[index];
+        const letters = phoneMap[currentDigit];
+
+        for (const letter of letters) {
+            backtrack(index + 1, path + letter);
+        }
+    }
+
+    backtrack(0, "");
+    return result;
+}
+// ```
+
+// ---
+
+// ## **使い方（ローカル実行用）**
+
+// ```typescript
+// console.log(letterCombinations("23"));
+// // 出力例: ["ad","ae","af","bd","be","bf","cd","ce","cf"]
+
+// console.log(letterCombinations(""));
+// // 出力: []
+
+// console.log(letterCombinations("2"));
+// // 出力: ["a","b","c"]
+// ```
+
+// ---
+
+// ## **計算量**
+
+// | 項目    | 内容                                                     |
+// | ----- | ------------------------------------------------------ |
+// | 時間計算量 | O(3^N × 4^M)（N: '2', '3', ..., '8' の個数, M: '7'と'9'の個数） |
+// | 空間計算量 | O(出力サイズ + 再帰スタック)                                      |
+
+// ---
+
+// ## **用途に応じた使い分け**
+
+// | 用途              | 実装パターン                            |
+// | --------------- | --------------------------------- |
+// | LeetCode提出      | `class Solution` 必須               |
+// | Node.js / 関数テスト | `function letterCombinations` でOK |
+
+// ---
+
+// もし、**Node.jsでの実行コマンド（`ts-node`）や、最適化版実装**も必要でしたら教えてください！

DataStructures/Trees/BFS・DFS/leetcode/17. Letter Combinations of a Phone Number/README.md

@@ -0,0 +1,136 @@
+以下は **`letterCombinations` 関数の具体的な処理を図解しながら詳しく解説**します。
+
+---
+
+## **問題概要**
+
+### 入力：
+
+数字列 `"23"`
+
+### 電話キー対応：
+
+| 数字 | 対応文字    |
+| -- | ------- |
+| 2  | a, b, c |
+| 3  | d, e, f |
+
+---
+
+## **再帰（バックトラッキング）の動作イメージ**
+
+### 入力：`digits = "23"`
+
+以下のように、**木構造で全探索**しています。
+
+```
+                    ""
+           /         |         \
+         "a"        "b"        "c"
+       /   \       /   \       /   \
+    "ad"  "ae"  "bd"  "be"  "cd"  "ce"
+      |     |     |     |     |     |
+    "af"  "af"  "bf"  "bf"  "cf"  "cf"
+```
+
+---
+
+### **具体的な処理フロー**
+
+1. **初期呼び出し**
+
+```typescript
+backtrack(0, "")
+```
+
+* index: 0（最初の文字）
+* path: ""（現在の文字列は空）
+
+---
+
+2. **1段目（digits\[0] = '2'）**
+
+```typescript
+letters = "abc"
+```
+
+* "a" を選択 → 次の桁へ
+* "b" を選択 → 次の桁へ
+* "c" を選択 → 次の桁へ
+
+---
+
+3. **2段目（digits\[1] = '3'）**
+
+```typescript
+letters = "def"
+```
+
+各パターンごとに以下を繰り返す：
+
+| 文字列       | 動作      |
+| --------- | ------- |
+| "a" + "d" | "ad" 完成 |
+| "a" + "e" | "ae" 完成 |
+| "a" + "f" | "af" 完成 |
+| "b" + "d" | "bd" 完成 |
+| "b" + "e" | "be" 完成 |
+| "b" + "f" | "bf" 完成 |
+| "c" + "d" | "cd" 完成 |
+| "c" + "e" | "ce" 完成 |
+| "c" + "f" | "cf" 完成 |
+
+---
+
+## **全体の組み合わせ図**
+
+```
+2: [a, b, c]
+3: [d, e, f]
+
+全組み合わせ：
+[a] -> [d, e, f] => "ad", "ae", "af"
+[b] -> [d, e, f] => "bd", "be", "bf"
+[c] -> [d, e, f] => "cd", "ce", "cf"
+```
+
+---
+
+## **コード処理ごとの解説**
+
+| 処理                        | 内容           | 図解                        |
+| ------------------------- | ------------ | ------------------------- |
+| `backtrack(0, "")`        | 探索開始         | `""`                      |
+| `path + letter`           | 部分文字列を構築     | 例："a"、"b"、"c"             |
+| `index === digits.length` | 終端判定、組み合わせ確定 | "ad"など                    |
+| `result.push(path)`       | 結果保存         | `["ad", "ae", "af", ...]` |
+
+---
+
+## **時間・空間計算量**
+
+| 項目    | 内容                                                             |
+| ----- | -------------------------------------------------------------- |
+| 時間計算量 | O(3^N × 4^M) <br> N：3文字のキー（2,3,4,5,6,8）個数 <br> M：4文字のキー（7,9）個数 |
+| 空間計算量 | O(組み合わせ数 + 再帰スタック)                                             |
+
+---
+
+## **まとめ図（最終結果）**
+
+```
+Input: "23"
+
+出力: 
+["ad", "ae", "af",
+ "bd", "be", "bf",
+ "cd", "ce", "cf"]
+```
+
+---
+
+## **視覚化まとめ**
+
+* **木構造探索（バックトラッキング）**
+* **全探索（DFS）で全組み合わせ列挙**
+* **3文字×3文字 → 9パターン出力**