docs: add Japanese translate documents (#1812)

* docs: add Japanese documents (`ja/docs`) * docs: add Japanese documents (`ja/codes`) * docs: add Japanese documents * Remove pythontutor blocks in ja/ * Add an empty at the end of each markdown file. * Add the missing figures (use the English version temporarily). * Add index.md for Japanese version. * Add index.html for Japanese version. * Add missing index.assets * Fix backtracking_algorithm.md for Japanese version. * Add avatar_eltociear.jpg. Fix image links on the Japanese landing page. * Add the Japanese banner. --------- Co-authored-by: krahets <krahets@163.com>
2026-07-15 08:26:06 +00:00 · 2025-10-17 06:04:43 +09:00
parent 2487a27036
commit 954c45864b
886 changed files with 33569 additions and 0 deletions
@@ -0,0 +1,509 @@
+# バックトラッキングアルゴリズム
+
+<u>バックトラッキングアルゴリズム</u>は全数探索によって問題を解決する方法です。その核心概念は、初期状態から開始してすべての可能な解を総当たりで探索することです。アルゴリズムは正しいものを記録し、解が見つかるか、すべての可能な解が試されたが解が見つからないまで続けます。
+
+バックトラッキングは通常「深さ優先探索」を使用して解空間を走査します。「二分木」の章で、前順、中順、後順走査はすべて深さ優先探索であることを述べました。次に、前順走査を使用してバックトラッキング問題を解決し、アルゴリズムの動作を段階的に理解していきます。
+
+!!! question "例1"
+
+    二分木が与えられた場合、値が $7$ のすべてのノードを検索して記録し、リストで返してください。
+
+この問題を解決するために、この木を前順で走査し、現在のノードの値が $7$ かどうかを確認します。そうであれば、ノードの値を結果リスト `res` に追加します。プロセスは以下の図に示されています：
+
+```src
+[file]{preorder_traversal_i_compact}-[class]{}-[func]{pre_order}
+```
+
+![前順走査でのノード検索](backtracking_algorithm.assets/preorder_find_nodes.png)
+
+## 試行と後退
+
+**解空間を探索する際に「試行」と「後退」戦略を使用するため、バックトラッキングアルゴリズムと呼ばれます**。探索中、満足のいく解を得るためにもはや進めない状態に遭遇するたびに、前の選択を取り消して前の状態に戻り、次の試行のために他の可能な選択を選択できるようにします。
+
+例1では、各ノードの訪問が「試行」を開始します。そして葉ノードを通過するか、`return` 文で親ノードに戻ることが「後退」を示唆します。
+
+**後退は単に関数の戻り値ではないことに注意してください**。例1の問題を少し拡張して、それが何を意味するかを説明します。
+
+!!! question "例2"
+
+    二分木で、値が $7$ のすべてのノードを検索し、すべてのマッチングノードについて、**ルートノードからそのノードまでのパスを返してください**。
+
+例1のコードに基づいて、訪問したノードパスを記録するために `path` というリストを使用する必要があります。値が $7$ のノードに到達すると、`path` をコピーして結果リスト `res` に追加します。走査後、`res` にはすべての解が保持されます。コードは以下の通りです：
+
+```src
+[file]{preorder_traversal_ii_compact}-[class]{}-[func]{pre_order}
+```
+
+各「試行」で、現在のノードを `path` に追加することでパスを記録します。「後退」が必要なときはいつでも、`path` からノードをポップして**この失敗した試行前の状態を復元します**。
+
+以下の図に示すプロセスを観察することで、**試行は「前進」のようで、後退は「元に戻す」のようです**。後者のペアは、対応するものに対する逆操作と見なすことができます。
+
+=== "<1>"
+    ![試行と後退](backtracking_algorithm.assets/preorder_find_paths_step1.png)
+
+=== "<2>"
+    ![preorder_find_paths_step2](backtracking_algorithm.assets/preorder_find_paths_step2.png)
+
+=== "<3>"
+    ![preorder_find_paths_step3](backtracking_algorithm.assets/preorder_find_paths_step3.png)
+
+=== "<4>"
+    ![preorder_find_paths_step4](backtracking_algorithm.assets/preorder_find_paths_step4.png)
+
+=== "<5>"
+    ![preorder_find_paths_step5](backtracking_algorithm.assets/preorder_find_paths_step5.png)
+
+=== "<6>"
+    ![preorder_find_paths_step6](backtracking_algorithm.assets/preorder_find_paths_step6.png)
+
+=== "<7>"
+    ![preorder_find_paths_step7](backtracking_algorithm.assets/preorder_find_paths_step7.png)
+
+=== "<8>"
+    ![preorder_find_paths_step8](backtracking_algorithm.assets/preorder_find_paths_step8.png)
+
+=== "<9>"
+    ![preorder_find_paths_step9](backtracking_algorithm.assets/preorder_find_paths_step9.png)
+
+=== "<10>"
+    ![preorder_find_paths_step10](backtracking_algorithm.assets/preorder_find_paths_step10.png)
+
+=== "<11>"
+    ![preorder_find_paths_step11](backtracking_algorithm.assets/preorder_find_paths_step11.png)
+
+## 剪定
+
+複雑なバックトラッキング問題は通常1つ以上の制約を含み、**これらは「剪定」によく使用されます**。
+
+!!! question "例3"
+
+    二分木で、値が $7$ のすべてのノードを検索し、ルートからこれらのノードまでのパスを返してください。**ただし、パスには値が $3$ のノードを含まないという制限があります**。
+
+上記の制約を満たすために、**剪定操作を追加する必要があります**：検索プロセス中に、値が $3$ のノードに遭遇した場合、そのパスを通じてさらに検索することを即座に中止します。コードは以下の通りです：
+
+```src
+[file]{preorder_traversal_iii_compact}-[class]{}-[func]{pre_order}
+```
+
+「剪定」は非常に生き生きとした名詞です。以下の図に示すように、検索プロセスで、**制約を満たさない検索分岐を「切り取り」ます**。さらなる不要な試行を避け、検索効率を向上させます。
+
+![制約に基づく剪定](backtracking_algorithm.assets/preorder_find_constrained_paths.png)
+
+## フレームワークコード
+
+今度は、バックトラッキングから「試行、後退、剪定」の主要なフレームワークを抽出して、コードの汎用性を向上させてみましょう。
+
+以下のフレームワークコードでは、`state` は問題の現在の状態を表し、`choices` は現在の状態で利用可能な選択肢を表します：
+
+=== "Python"
+
+    ```python title=""
+    def backtrack(state: State, choices: list[choice], res: list[state]):
+        """バックトラッキングアルゴリズムフレームワーク"""
+        # 解かどうかを確認
+        if is_solution(state):
+            # 解を記録
+            record_solution(state, res)
+            # 検索を停止
+            return
+        # すべての選択肢を反復
+        for choice in choices:
+            # 剪定：選択肢が有効かどうかを確認
+            if is_valid(state, choice):
+                # 試行：選択を行い、状態を更新
+                make_choice(state, choice)
+                backtrack(state, choices, res)
+                # 後退：選択を取り消し、前の状態に戻す
+                undo_choice(state, choice)
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    void backtrack(State *state, vector<Choice *> &choices, vector<State *> &res) {
+        // 解かどうかを確認
+        if (isSolution(state)) {
+            // 解を記録
+            recordSolution(state, res);
+            // 検索を停止
+            return;
+        }
+        // すべての選択肢を反復
+        for (Choice choice : choices) {
+            // 剪定：選択肢が有効かどうかを確認
+            if (isValid(state, choice)) {
+                // 試行：選択を行い、状態を更新
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 後退：選択を取り消し、前の状態に戻す
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    void backtrack(State state, List<Choice> choices, List<State> res) {
+        // 解かどうかを確認
+        if (isSolution(state)) {
+            // 解を記録
+            recordSolution(state, res);
+            // 検索を停止
+            return;
+        }
+        // すべての選択肢を反復
+        for (Choice choice : choices) {
+            // 剪定：選択肢が有効かどうかを確認
+            if (isValid(state, choice)) {
+                // 試行：選択を行い、状態を更新
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 後退：選択を取り消し、前の状態に戻す
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    void Backtrack(State state, List<Choice> choices, List<State> res) {
+        // 解かどうかを確認
+        if (IsSolution(state)) {
+            // 解を記録
+            RecordSolution(state, res);
+            // 検索を停止
+            return;
+        }
+        // すべての選択肢を反復
+        foreach (Choice choice in choices) {
+            // 剪定：選択肢が有効かどうかを確認
+            if (IsValid(state, choice)) {
+                // 試行：選択を行い、状態を更新
+                MakeChoice(state, choice);
+                Backtrack(state, choices, res);
+                // 後退：選択を取り消し、前の状態に戻す
+                UndoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    func backtrack(state *State, choices []Choice, res *[]State) {
+        // 解かどうかを確認
+        if isSolution(state) {
+            // 解を記録
+            recordSolution(state, res)
+            // 検索を停止
+            return
+        }
+        // すべての選択肢を反復
+        for _, choice := range choices {
+            // 剪定：選択肢が有効かどうかを確認
+            if isValid(state, choice) {
+                // 試行：選択を行い、状態を更新
+                makeChoice(state, choice)
+                backtrack(state, choices, res)
+                // 後退：選択を取り消し、前の状態に戻す
+                undoChoice(state, choice)
+            }
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    func backtrack(state: inout State, choices: [Choice], res: inout [State]) {
+        // 解かどうかを確認
+        if isSolution(state: state) {
+            // 解を記録
+            recordSolution(state: state, res: &res)
+            // 検索を停止
+            return
+        }
+        // すべての選択肢を反復
+        for choice in choices {
+            // 剪定：選択肢が有効かどうかを確認
+            if isValid(state: state, choice: choice) {
+                // 試行：選択を行い、状態を更新
+                makeChoice(state: &state, choice: choice)
+                backtrack(state: &state, choices: choices, res: &res)
+                // 後退：選択を取り消し、前の状態に戻す
+                undoChoice(state: &state, choice: choice)
+            }
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    function backtrack(state, choices, res) {
+        // 解かどうかを確認
+        if (isSolution(state)) {
+            // 解を記録
+            recordSolution(state, res);
+            // 検索を停止
+            return;
+        }
+        // すべての選択肢を反復
+        for (let choice of choices) {
+            // 剪定：選択肢が有効かどうかを確認
+            if (isValid(state, choice)) {
+                // 試行：選択を行い、状態を更新
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 後退：選択を取り消し、前の状態に戻す
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    function backtrack(state: State, choices: Choice[], res: State[]): void {
+        // 解かどうかを確認
+        if (isSolution(state)) {
+            // 解を記録
+            recordSolution(state, res);
+            // 検索を停止
+            return;
+        }
+        // すべての選択肢を反復
+        for (let choice of choices) {
+            // 剪定：選択肢が有効かどうかを確認
+            if (isValid(state, choice)) {
+                // 試行：選択を行い、状態を更新
+                makeChoice(state, choice);
+                backtrack(state, choices, res);
+                // 後退：選択を取り消し、前の状態に戻す
+                undoChoice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    void backtrack(State state, List<Choice>, List<State> res) {
+      // 解かどうかを確認
+      if (isSolution(state)) {
+        // 解を記録
+        recordSolution(state, res);
+        // 検索を停止
+        return;
+      }
+      // すべての選択肢を反復
+      for (Choice choice in choices) {
+        // 剪定：選択肢が有効かどうかを確認
+        if (isValid(state, choice)) {
+          // 試行：選択を行い、状態を更新
+          makeChoice(state, choice);
+          backtrack(state, choices, res);
+          // 後退：選択を取り消し、前の状態に戻す
+          undoChoice(state, choice);
+        }
+      }
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    fn backtrack(state: &mut State, choices: &Vec<Choice>, res: &mut Vec<State>) {
+        // 解かどうかを確認
+        if is_solution(state) {
+            // 解を記録
+            record_solution(state, res);
+            // 検索を停止
+            return;
+        }
+        // すべての選択肢を反復
+        for choice in choices {
+            // 剪定：選択肢が有効かどうかを確認
+            if is_valid(state, choice) {
+                // 試行：選択を行い、状態を更新
+                make_choice(state, choice);
+                backtrack(state, choices, res);
+                // 後退：選択を取り消し、前の状態に戻す
+                undo_choice(state, choice);
+            }
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    void backtrack(State *state, Choice *choices, int numChoices, State *res, int numRes) {
+        // 解かどうかを確認
+        if (isSolution(state)) {
+            // 解を記録
+            recordSolution(state, res, numRes);
+            // 検索を停止
+            return;
+        }
+        // すべての選択肢を反復
+        for (int i = 0; i < numChoices; i++) {
+            // 剪定：選択肢が有効かどうかを確認
+            if (isValid(state, &choices[i])) {
+                // 試行：選択を行い、状態を更新
+                makeChoice(state, &choices[i]);
+                backtrack(state, choices, numChoices, res, numRes);
+                // 後退：選択を取り消し、前の状態に戻す
+                undoChoice(state, &choices[i]);
+            }
+        }
+    }
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title=""
+    /* バックトラッキングアルゴリズムフレームワーク */
+    fun backtrack(state: State?, choices: List<Choice?>, res: List<State?>?) {
+        // 解かどうかを確認
+        if (isSolution(state)) {
+            // 解を記録
+            recordSolution(state, res)
+            // 検索を停止
+            return
+        }
+        // すべての選択肢を反復
+        for (choice in choices) {
+            // 剪定：選択肢が有効かどうかを確認
+            if (isValid(state, choice)) {
+                // 試行：選択を行い、状態を更新
+                makeChoice(state, choice)
+                backtrack(state, choices, res)
+                // 後退：選択を取り消し、前の状態に戻す
+                undoChoice(state, choice)
+            }
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
+    ### バックトラッキングアルゴリズムフレームワーク ###
+    def backtrack(state, choices, res)
+        # 解かどうかを確認
+        if is_solution?(state)
+            # 解を記録
+            record_solution(state, res)
+            return
+        end
+
+        # すべての選択肢を反復
+        for choice in choices
+            # 剪定：選択肢が有効かどうかを確認
+            if is_valid?(state, choice)
+                # 試行：選択を行い、状態を更新
+                make_choice(state, choice)
+                backtrack(state, choices, res)
+                # 後退：選択を取り消し、前の状態に戻す
+                undo_choice(state, choice)
+            end
+        end
+    end
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+
+    ```
+
+次に、フレームワークコードに基づいて例題 3 を解きます。状態 `state` はノードの走査経路を表し、選択肢 `choices` は現在ノードの左子ノードと右子ノード、結果 `res` は経路リストです：
+
+```src
+[file]{preorder_traversal_iii_template}-[class]{}-[func]{backtrack}
+```
+
+問題文の意味に従い、値が $7$ のノードを見つけた後も探索を続ける必要があります。**したがって、解を記録した後の `return` 文を削除する必要があります**。次の図は、`return` 文を保持する場合と削除する場合の探索過程の比較です。
+
+![returnを保持する場合と削除する場合の探索過程の比較](backtracking_algorithm.assets/backtrack_remove_return_or_not.png)
+
+前順走査に基づくコード実装と比べると、バックトラッキングアルゴリズムのフレームワークに基づく実装はやや冗長に見えますが、汎用性はより高いです。実際、**多くのバックトラッキング問題はこのフレームワークの下で解くことができます**。具体的な問題に応じて `state` と `choices` を定義し、フレームワーク内の各メソッドを実装すればよいのです。
+
+## よく使われる用語
+
+アルゴリズム問題をより明確に分析するために、バックトラッキングアルゴリズムでよく使われる用語の意味をまとめ、例題 3 の対応例を以下の表に示します。
+
+<p align="center"> 表 <id> &nbsp; バックトラッキングアルゴリズムでよく使われる用語 </p>
+
+| 名称                           | 定義                                                                                                         | 例題 3                                                                                    |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------- |
+| 解（solution）                 | 解は問題の特定条件を満たす答えであり、1 つまたは複数存在する可能性がある                                     | 根ノードからノード $7$ までの制約条件を満たすすべての経路                                 |
+| 制約条件（constraint）         | 制約条件は、解の実現可能性を制限する条件であり、通常は枝刈りに使用される                                     | 経路にノード $3$ を含まない                                                               |
+| 状態（state）                  | 状態は、ある時点での問題の状況を表し、これまでに行った選択を含む                                             | 現在訪問したノード経路、すなわち `path` ノードリスト                                      |
+| 試行（attempt）                | 試行は、利用可能な選択肢に基づいて解空間を探索する過程であり、選択を行い、状態を更新し、解かどうかを確認する | 左（右）子ノードを再帰的に訪問し、ノードを `path` に追加し、ノードの値が $7$ かを確認する |
+| バックトラック（backtracking） | 制約条件を満たさない状態に遭遇した場合、以前の選択を取り消して前の状態に戻ること                             | 葉ノードを越えたとき、探索終了、値が $3$ のノードに遭遇したとき探索を終了し、関数が戻る   |
+| 枝刈り（pruning）              | 問題の特性や制約条件に基づき、無意味な探索経路を避ける方法であり、探索効率を向上させる                       | 値が $3$ のノードに遭遇した場合、それ以上探索しない                                       |
+
+!!! tip
+
+    問題、解、状態などの概念は一般的なものであり、分割統治、バックトラッキング、動的計画法、貪欲法などのアルゴリズムにも関係します。
+
+## 長所と限界
+
+バックトラッキングアルゴリズムは本質的に深さ優先探索（DFS）アルゴリズムの一種であり、条件を満たす解を見つけるまであらゆる可能な解を試みます。この方法の利点は、すべての可能な解を見つけられる点であり、適切な枝刈りを行えば効率が高いことです。
+
+しかし、大規模または複雑な問題を扱う場合、**バックトラッキングアルゴリズムの実行効率は許容できないほど低下する可能性があります**。
+
+- **時間**：バックトラッキングアルゴリズムは通常、状態空間のすべての可能性を探索する必要があり、時間計算量は指数オーダーまたは階乗オーダーに達する可能性があります。
+- **空間**：再帰呼び出し中に現在の状態（例：経路、枝刈り用の補助変数など）を保存する必要があり、深さが大きい場合、空間の使用量が増加します。
+
+それでもなお、**バックトラッキングアルゴリズムは特定の探索問題や制約満足問題の最良の解法であることが多いです**。これらの問題では、どの選択が有効な解を生成するかを予測できないため、すべての可能な選択を試す必要があります。このような場合、**効率の最適化が鍵**となります。一般的な最適化手法は次の 2 つです。
+
+- **枝刈り**：解を生成しないことが確実な経路を避けることで、時間と空間を節約します。
+- **ヒューリスティック探索**：探索中に戦略や評価値を導入し、有効な解を生成する可能性が高い経路を優先的に探索します。
+
+## バックトラッキングの典型的な例題
+
+バックトラッキングアルゴリズムは、多くの探索問題、制約満足問題、組合せ最適化問題を解くのに使用できます。
+
+**探索問題**：この種の問題の目標は、特定の条件を満たす解を見つけることです。
+
+- 全順列問題：与えられた集合のすべての可能な順列を求める。
+- 部分和問題：与えられた集合と目標和に対して、和が目標値になるすべての部分集合を求める。
+- ハノイの塔：3 本の柱と異なるサイズの円盤があり、すべての円盤を 1 本の柱から別の柱に移す。1 回に 1 枚しか動かせず、大きな円盤を小さい円盤の上に置くことはできない。
+
+**制約満足問題**：この種の問題の目標は、すべての制約条件を満たす解を見つけることです。
+
+- $n$ クイーン問題：$n imes n$ のチェス盤に $n$ 個のクイーンを配置し、互いに攻撃しないようにする。
+- 数独：$9 imes 9$ のグリッドに数字 $1$ \~ $9$ を入力し、各行、列、$3 imes 3$ のサブグリッドに重複がないようにする。
+- グラフ彩色問題：与えられた無向グラフに対し、隣接頂点が異なる色になるように最小限の色で彩色する。
+
+**組合せ最適化問題**：この種の問題の目標は、組合せ空間内で特定の条件を満たす最適解を見つけることです。
+
+- 0-1 ナップサック問題：与えられた物品群とバックパックがあり、各物品には価値と重さが設定されている。バックパックの容量制限内で、総価値を最大化する物品の選択を求める。
+- 旅行セールスマン問題：グラフ上で、1 つの点から出発し、すべての他の点を 1 回ずつ訪問して出発点に戻る最短経路を求める。
+- 最大クリーク問題：与えられた無向グラフの中で、任意の 2 頂点間に辺が存在する最大の完全部分グラフを見つける。
+
+注意すべきは、多くの組合せ最適化問題に対して、バックトラッキングが最適解法ではないということです。
+
+- 0-1 ナップサック問題は、時間効率を高めるために動的計画法がよく使用されます。
+- 旅行セールスマン問題は有名な NP-Hard 問題であり、遺伝的アルゴリズムやアントコロニーアルゴリズムなどの手法がよく使われます。
+- 最大クリーク問題はグラフ理論の古典的な問題であり、貪欲法などのヒューリスティックアルゴリズムで解くことができます。
@@ -0,0 +1,9 @@
+# バックトラッキング
+
+![バックトラッキング](../assets/covers/chapter_backtracking.jpg)
+
+!!! abstract
+
+    迷路の探検家のように、私たちは前進する道で障害に遭遇することがあります。
+
+    バックトラッキングの力は、私たちに新しく始めること、試し続けること、そして最終的に光への出口を見つけることを可能にします。
@@ -0,0 +1,53 @@
+# Nクイーン問題
+
+!!! question
+
+    チェスのルールによると、クイーンは同じ行、列、または対角線上の駒を攻撃できます。$n$ 個のクイーンと $n \times n$ のチェスボードが与えられた場合、2つのクイーンが互いに攻撃できない配置を見つけてください。
+
+以下の図に示すように、$n = 4$ の場合、2つの解があります。バックトラッキングアルゴリズムの観点から、$n \times n$ のチェスボードには $n^2$ 個のマスがあり、すべての可能な選択肢 `choices` を示しています。チェスボードの状態 `state` は、各クイーンが配置されるにつれて継続的に変化します。
+
+![4クイーン問題の解](n_queens_problem.assets/solution_4_queens.png)
+
+以下の図は、この問題の3つの制約を示しています：**複数のクイーンは同じ行、列、または対角線を占有できません**。対角線は主対角線 `\` と副対角線 `/` に分かれることに注意することが重要です。
+
+![Nクイーン問題の制約](n_queens_problem.assets/n_queens_constraints.png)
+
+### 行ごとの配置戦略
+
+クイーンの数がチェスボードの行数と等しく、どちらも $n$ であるため、**チェスボードの各行には1つのクイーンのみが配置できることが**容易に結論付けられます。
+
+これは、行ごとの配置戦略を採用できることを意味します：最初の行から開始して、最後の行に到達するまで行ごとに1つのクイーンを配置します。
+
+以下の図は、4クイーン問題の行ごとの配置プロセスを示しています。スペースの制限により、図は最初の行の1つの検索分岐のみを展開し、列と対角線の制約を満たさない配置を剪定します。
+
+![行ごとの配置戦略](n_queens_problem.assets/n_queens_placing.png)
+
+本質的に、**行ごとの配置戦略は剪定関数として機能し**、同じ行に複数のクイーンを配置するすべての検索分岐を除去します。
+
+### 列と対角線の剪定
+
+列の制約を満たすために、長さ $n$ のブール配列 `cols` を使用して、各列にクイーンが占有されているかどうかを追跡できます。各配置決定の前に、`cols` を使用してすでにクイーンがある列を剪定し、バックトラッキング中に動的に更新されます。
+
+!!! tip
+
+    行列の原点は左上隅にあり、行インデックスは上から下に増加し、列インデックスは左から右に増加することに注意してください。
+
+対角線の制約はどうでしょうか？チェスボード上の特定のセルの行と列のインデックスを $(row, col)$ とします。特定の主対角線を選択することで、その対角線上のすべてのセルで差 $row - col$ が同じであることに気付きます。**つまり、$row - col$ は主対角線上で定数値です**。
+
+言い換えると、2つのセルが $row_1 - col_1 = row_2 - col_2$ を満たす場合、それらは確実に同じ主対角線上にあります。このパターンを使用して、以下の図に示す配列 `diags1` を利用して、クイーンが主対角線上にあるかどうかを追跡できます。
+
+同様に、**$row + col$ の和は副対角線上のすべてのセルで定数値です**。配列 `diags2` を使用して副対角線の制約も処理できます。
+
+![列と対角線の制約の処理](n_queens_problem.assets/n_queens_cols_diagonals.png)
+
+### コード実装
+
+$n$ 次元の正方行列では、$row - col$ の範囲は $[-n + 1, n - 1]$ で、$row + col$ の範囲は $[0, 2n - 2]$ であることに注意してください。したがって、主対角線と副対角線の数はどちらも $2n - 1$ で、配列 `diags1` と `diags2` の長さは $2n - 1$ です。
+
+```src
+[file]{n_queens}-[class]{}-[func]{n_queens}
+```
+
+$n$ 個のクイーンを行ごとに配置し、列の制約を考慮して、最初の行から最後の行まで、$n$、$n-1$、$\dots$、$2$、$1$ の選択肢があり、$O(n!)$ 時間を使用します。解を記録する際、行列 `state` をコピーして `res` に追加する必要があり、コピー操作は $O(n^2)$ 時間を使用します。したがって、**全体の時間計算量は $O(n! \cdot n^2)$ です**。実際には、対角線制約に基づく剪定により検索空間を大幅に削減できるため、多くの場合、検索効率は上記の時間計算量よりも優れています。
+
+配列 `state` は $O(n^2)$ 空間を使用し、配列 `cols`、`diags1`、`diags2` はそれぞれ $O(n)$ 空間を使用します。最大再帰深度は $n$ で、$O(n)$ のスタックフレーム空間を使用します。したがって、**空間計算量は $O(n^2)$ です**。
@@ -0,0 +1,95 @@
+# 順列問題
+
+順列問題は、バックトラッキングアルゴリズムの典型的な応用です。これは、配列や文字列などの与えられた集合から要素のすべての可能な配置（順列）を見つけることを含みます。
+
+以下の表は、入力配列とその対応する順列を含むいくつかの例を示しています。
+
+<p align="center"> 表 <id> &nbsp; 順列の例 </p>
+
+| 入力配列     | 順列                                                                |
+| :----------- | :----------------------------------------------------------------- |
+| $[1]$        | $[1]$                                                              |
+| $[1, 2]$     | $[1, 2], [2, 1]$                                                   |
+| $[1, 2, 3]$  | $[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]$ |
+
+## 重複要素がない場合
+
+!!! question
+
+    重複要素のない整数配列が与えられた場合、すべての可能な順列を返してください。
+
+バックトラッキングの観点から、**順列を生成するプロセスを一連の選択として見ることができます。** 入力配列が $[1, 2, 3]$ だとします。最初に $1$ を選択し、次に $3$、最後に $2$ を選択すると、順列 $[1, 3, 2]$ が得られます。「バックトラッキング」は前の選択を取り消して、代替オプションを探索することを意味します。
+
+コーディングの観点から、候補集合 `choices` は入力配列のすべての要素で構成され、`state` はこれまでに選択された要素を保持します。各要素は一度だけ選択できるため、**`state` のすべての要素は一意である必要があります**。
+
+以下の図に示すように、検索プロセスを再帰木に展開できます。各ノードは現在の `state` を表します。ルートノードから開始して、3回の選択の後、葉ノードに到達します—それぞれが順列に対応します。
+
+![順列の再帰木](permutations_problem.assets/permutations_i.png)
+
+### 重複選択の剪定
+
+各要素が一度だけ選択されることを保証するために、ブール配列 `selected` を導入します。ここで `selected[i]` は `choices[i]` が選択されたかどうかを示します。次に、この配列に基づいて剪定ステップを実行します：
+
+- `choice[i]` を選択した後、`selected[i]` を $\text{True}$ に設定して選択されたとマークします。
+- `choices` を反復処理する際、選択されたとマークされたすべての要素をスキップします（つまり、それらの分岐を剪定します）。
+
+以下の図に示すように、最初のラウンドで1を選択し、2番目のラウンドで3を選択し、最後のラウンドで2を選択するとします。2番目のラウンドで要素1の分岐と、3番目のラウンドで要素1と3の分岐を剪定する必要があります。
+
+![順列の剪定例](permutations_problem.assets/permutations_i_pruning.png)
+
+図から、この剪定プロセスが検索空間を $O(n^n)$ から $O(n!)$ に削減することがわかります。
+
+### コード実装
+
+この理解により、フレームワークコードの「空欄を埋める」ことができます。全体のコードを簡潔に保つため、フレームワークの各部分を個別に実装せず、代わりに `backtrack()` 関数ですべてを展開します：
+
+```src
+[file]{permutations_i}-[class]{}-[func]{permutations_i}
+```
+
+## 重複要素を考慮する場合
+
+!!! question
+
+    **重複要素を含む可能性のある**整数配列が与えられた場合、すべての一意の順列を返してください。
+
+入力配列が $[1, 1, 2]$ だとします。2つの同一要素 $1$ を区別するために、2番目を $\hat{1}$ とラベル付けします。
+
+以下の図に示すように、この方法で生成される順列の半分は重複です：
+
+![重複順列](permutations_problem.assets/permutations_ii.png)
+
+では、これらの重複順列をどのように除去できるでしょうか？一つの直接的なアプローチは、すべての順列を生成した後にハッシュセットを使用して重複を除去することです。しかし、これはあまり優雅ではありません。**重複を生成する分岐は本来不要であり、事前に剪定されるべきだからです**、これによりアルゴリズムの効率が向上します。
+
+### 等値要素の剪定
+
+以下の図を見ると、最初のラウンドで $1$ または $\hat{1}$ を選択すると同じ順列につながるため、$\hat{1}$ を剪定します。
+
+同様に、最初のラウンドで $2$ を選択した後、2番目のラウンドで $1$ または $\hat{1}$ を選択しても重複分岐につながるため、その時も $\hat{1}$ を剪定します。
+
+本質的に、**私たちの目標は、複数の同一要素が選択の各ラウンドで一度だけ選択されることを保証することです。**
+
+![重複順列の剪定](permutations_problem.assets/permutations_ii_pruning.png)
+
+### コード実装
+
+前の問題のコードに基づいて、各ラウンドでハッシュセット `duplicated` を導入します。このセットは、すでに試行した要素を追跡し、重複を剪定できるようにします：
+
+```src
+[file]{permutations_ii}-[class]{}-[func]{permutations_ii}
+```
+
+すべての要素が異なると仮定すると、$n$ 個の要素の順列は $n!$ （階乗）個あります。各結果を記録するには長さ $n$ のリストをコピーする必要があり、これには $O(n)$ 時間がかかります。**したがって、総時間計算量は $O(n!n)$ です。**
+
+最大再帰深度は $n$ で、$O(n)$ のスタック空間を使用します。`selected` 配列も $O(n)$ 空間が必要です。一度に最大 $n$ 個の個別の `duplicated` セットが存在する可能性があるため、それらは集合的に $O(n^2)$ 空間を占有します。**したがって、空間計算量は $O(n^2)$ です。**
+
+### 2つの剪定方法の比較
+
+`selected` と `duplicated` はどちらも剪定メカニズムとして機能しますが、異なる問題をターゲットにしています：
+
+- **重複選択の剪定**（`selected` 経由）：検索全体に単一の `selected` 配列があり、現在の状態にすでにある要素を示します。これにより、同じ要素が `state` に複数回現れることを防ぎます。
+- **等値要素の剪定**（`duplicated` 経由）：`backtrack` 関数の各呼び出しは独自の `duplicated` セットを使用し、その特定の反復（`for` ループ）ですでに選択された要素を記録します。これにより、等しい要素が選択の各ラウンドで一度だけ選択されることを保証します。
+
+以下の図は、これら2つの剪定戦略の範囲を示しています。木の各ノードは選択を表します。ルートから任意の葉への経路は、1つの完全な順列に対応します。
+
+![2つの剪定条件の範囲](permutations_problem.assets/permutations_ii_pruning_summary.png)
@@ -0,0 +1,95 @@
+# 部分集合和問題
+
+## 重複要素がない場合
+
+!!! question
+
+    正の整数の配列 `nums` とターゲット正整数 `target` が与えられた場合、組み合わせ内の要素の和が `target` に等しくなるようなすべての可能な組み合わせを見つけてください。与えられた配列には重複要素がなく、各要素は複数回選択できます。これらの組み合わせを重複する組み合わせを含まないリストとして返してください。
+
+例えば、入力集合 $\{3, 4, 5\}$ とターゲット整数 $9$ の場合、解は $\{3, 3, 3\}, \{4, 5\}$ です。以下の2点に注意してください。
+
+- 入力集合の要素は無制限に選択できます。
+- 部分集合は要素の順序を区別しません。例えば $\{4, 5\}$ と $\{5, 4\}$ は同じ部分集合です。
+
+### 順列解法の参考
+
+順列問題と同様に、部分集合の生成を一連の選択として想像でき、選択プロセス中に「要素和」をリアルタイムで更新できます。要素和が `target` に等しくなったとき、部分集合を結果リストに記録します。
+
+順列問題とは異なり、**この問題では要素は無制限に選択できるため**、要素が選択されたかどうかを記録するための `selected` ブール配列を使用する必要がありません。順列コードに軽微な修正を加えて、最初に問題を解決できます：
+
+```src
+[file]{subset_sum_i_naive}-[class]{}-[func]{subset_sum_i_naive}
+```
+
+配列 $[3, 4, 5]$ とターゲット要素 $9$ を上記のコードに入力すると、結果 $[3, 3, 3], [4, 5], [5, 4]$ が得られます。**和が $9$ のすべての部分集合を正常に見つけましたが、重複する部分集合 $[4, 5]$ と $[5, 4]$ が含まれています**。
+
+これは、検索プロセスが選択の順序を区別するためですが、部分集合は選択順序を区別しません。以下の図に示すように、$5$ の前に $4$ を選択することと $4$ の前に $5$ を選択することは異なる分岐ですが、同じ部分集合に対応します。
+
+![部分集合の検索と境界外の剪定](subset_sum_problem.assets/subset_sum_i_naive.png)
+
+重複する部分集合を除去するために、**直接的なアイデアは結果リストを重複除去することです**。しかし、この方法は2つの理由で非常に非効率的です。
+
+- 配列要素が多い場合、特に `target` が大きい場合、検索プロセスで大量の重複する部分集合が生成されます。
+- 部分集合（配列）の差異を比較することは非常に時間がかかり、まず配列をソートし、次に配列の各要素の差異を比較する必要があります。
+
+### 重複部分集合の剪定
+
+**剪定を通じて検索プロセス中に重複除去を検討します**。以下の図を観察すると、異なる順序で配列要素を選択するときに重複する部分集合が生成されます。例えば、以下の状況です。
+
+1. 最初のラウンドで $3$ を選択し、2番目のラウンドで $4$ を選択すると、これら2つの要素を含むすべての部分集合が生成され、$[3, 4, \dots]$ と表記されます。
+2. 後で、最初のラウンドで $4$ が選択されたとき、**2番目のラウンドは $3$ をスキップすべきです**。この選択によって生成される部分集合 $[4, 3, \dots]$ はステップ `1.` の部分集合と完全に重複するからです。
+
+検索プロセスでは、各層の選択が左から右に一つずつ試行されるため、右側の分岐ほどより多く剪定されます。
+
+1. 最初の2ラウンドで $3$ と $5$ を選択し、部分集合 $[3, 5, \dots]$ を生成します。
+2. 最初の2ラウンドで $4$ と $5$ を選択し、部分集合 $[4, 5, \dots]$ を生成します。
+3. 最初のラウンドで $5$ が選択された場合、**2番目のラウンドは $3$ と $4$ をスキップすべきです**。部分集合 $[5, 3, \dots]$ と $[5, 4, \dots]$ はステップ `1.` と `2.` で記述された部分集合と完全に重複するからです。
+
+![異なる選択順序による重複部分集合](subset_sum_problem.assets/subset_sum_i_pruning.png)
+
+要約すると、入力配列 $[x_1, x_2, \dots, x_n]$ が与えられた場合、検索プロセスでの選択シーケンスは $[x_{i_1}, x_{i_2}, \dots, x_{i_m}]$ であるべきで、$i_1 \leq i_2 \leq \dots \leq i_m$ を満たす必要があります。**この条件を満たさない選択シーケンスは重複を引き起こし、剪定されるべきです**。
+
+### コード実装
+
+この剪定を実装するために、変数 `start` を初期化し、これは走査の開始点を示します。**選択 $x_{i}$ を行った後、次のラウンドをインデックス $i$ から開始するように設定します**。これにより、選択シーケンスが $i_1 \leq i_2 \leq \dots \leq i_m$ を満たすことが保証され、部分集合の一意性が保証されます。
+
+さらに、コードに以下の2つの最適化を行いました。
+
+- 検索を開始する前に、配列 `nums` をソートします。すべての選択の走査で、**部分集合和が `target` を超えたときにループを直接終了します**。後続の要素はより大きく、それらの部分集合和は確実に `target` を超えるからです。
+- 要素和変数 `total` を除去し、**`target` に対して減算を実行して要素和をカウントします**。`target` が $0$ に等しくなったとき、解を記録します。
+
+```src
+[file]{subset_sum_i}-[class]{}-[func]{subset_sum_i}
+```
+
+以下の図は、配列 $[3, 4, 5]$ とターゲット要素 $9$ を上記のコードに入力した後の全体的なバックトラッキングプロセスを示しています。
+
+![部分集合和 I のバックトラッキングプロセス](subset_sum_problem.assets/subset_sum_i.png)
+
+## 重複要素がある場合を考慮
+
+!!! question
+
+    正の整数の配列 `nums` とターゲット正整数 `target` が与えられた場合、組み合わせ内の要素の和が `target` に等しくなるようなすべての可能な組み合わせを見つけてください。**与えられた配列には重複要素が含まれる可能性があり、各要素は一度だけ選択できます**。これらの組み合わせを重複する組み合わせを含まないリストとして返してください。
+
+前の問題と比較して、**この問題の入力配列には重複要素が含まれる可能性があり**、新しい問題が導入されます。例えば、配列 $[4, \hat{4}, 5]$ とターゲット要素 $9$ が与えられた場合、既存のコードの出力結果は $[4, 5], [\hat{4}, 5]$ となり、重複する部分集合が生成されます。
+
+**この重複の理由は、特定のラウンドで等しい要素が複数回選択されることです**。以下の図では、最初のラウンドに3つの選択肢があり、そのうち2つが $4$ であり、2つの重複する検索分岐を生成し、重複する部分集合を出力します。同様に、2番目のラウンドの2つの $4$ も重複する部分集合を生成します。
+
+![等しい要素による重複部分集合](subset_sum_problem.assets/subset_sum_ii_repeat.png)
+
+### 等値要素の剪定
+
+この問題を解決するために、**等しい要素がラウンドごとに一度だけ選択されるように制限する必要があります**。実装は非常に巧妙です：配列がソートされているため、等しい要素は隣接しています。これは、特定のラウンドの選択で、現在の要素がその左側の要素と等しい場合、それはすでに選択されていることを意味するため、現在の要素を直接スキップします。
+
+同時に、**この問題では各配列要素は一度だけ選択できると規定されています**。幸い、変数 `start` を使用してこの制約も満たすことができます：選択 $x_{i}$ を行った後、次のラウンドをインデックス $i + 1$ から前方に開始するように設定します。これにより、重複する部分集合が除去されるだけでなく、要素の重複選択も回避されます。
+
+### コード実装
+
+```src
+[file]{subset_sum_ii}-[class]{}-[func]{subset_sum_ii}
+```
+
+以下の図は、配列 $[4, 4, 5]$ とターゲット要素 $9$ のバックトラッキングプロセスを示し、4種類の剪定操作が含まれています。図とコードのコメントを組み合わせて、検索プロセス全体と各種類の剪定操作の動作を理解してください。
+
+![部分集合和 II のバックトラッキングプロセス](subset_sum_problem.assets/subset_sum_ii.png)
@@ -0,0 +1,23 @@
+# まとめ
+
+### 重要な復習
+
+- バックトラッキングアルゴリズムの本質は全数探索です。解空間の深さ優先走査を実行することで条件を満たす解を求めます。検索中に満足のいく解が見つかった場合、それを記録し、すべての解が見つかるか走査が完了するまで続けます。
+- バックトラッキングアルゴリズムの検索プロセスには試行と後退が含まれます。深さ優先探索を使用して様々な選択を探索し、選択が制約を満たさない場合、前の選択を取り消します。そして前の状態に戻って他のオプションを試し続けます。試行と後退は反対方向の操作です。
+- バックトラッキング問題には通常複数の制約が含まれます。これらの制約は剪定操作を実行するために使用できます。剪定は不要な検索分岐を事前に終了し、検索効率を大幅に向上させることができます。
+- バックトラッキングアルゴリズムは主に検索問題と制約満足問題を解決するために使用されます。組み合わせ最適化問題はバックトラッキングを使用して解決できますが、多くの場合、より効率的または効果的な解決方法が利用可能です。
+- 順列問題は、与えられた集合の要素のすべての可能な順列を検索することを目的とします。各要素が選択されたかどうかを記録するために配列を使用し、同じ要素の重複選択を避けます。これにより、各要素が一度だけ選択されることが保証されます。
+- 順列問題では、集合に重複要素が含まれている場合、最終結果に重複順列が含まれます。同一要素が各ラウンドで一度だけ選択できるように制限する必要があり、これは通常ハッシュセットを使用して実装されます。
+- 部分集合和問題は、与えられた集合でターゲット値に合計する全ての部分集合を見つけることを目的とします。集合は要素の順序を区別しませんが、検索プロセスでは重複する部分集合が生成される可能性があります。これは、アルゴリズムが異なる要素順序を独特のパスとして探索するために発生します。バックトラッキングの前に、データをソートし、各ラウンドの走査の開始点を示す変数を設定します。これにより、重複する部分集合を生成する検索分岐を剪定できます。
+- 部分集合和問題では、配列内の等しい要素は重複集合を生成する可能性があります。配列がすでにソートされているという前提条件を使用して、隣接する要素が等しいかどうかを判定することで剪定を行います。これにより、等しい要素がラウンドごとに一度だけ選択されることが保証されます。
+- $n$ クイーン問題は、2つのクイーンが互いに攻撃できないように $n \times n$ のチェスボードに $n$ 個のクイーンを配置する方案を見つけることを目的とします。問題の制約には行制約、列制約、および主対角線と副対角線の制約が含まれます。行制約を満たすために、行ごとに1つのクイーンを配置する戦略を採用し、各行に1つのクイーンが配置されることを保証します。
+- 列制約と対角線制約の処理は似ています。列制約については、各列にクイーンがあるかどうかを記録する配列を使用し、選択されたセルが合法かどうかを示します。対角線制約については、2つの配列を使用して主対角線と副対角線にそれぞれクイーンの存在を記録します。課題は、同じ主対角線または副対角線上のセルの行と列のインデックス間の関係を決定することです。
+
+### Q & A
+
+**Q**: バックトラッキングと再帰の関係をどのように理解すればよいですか？
+
+全体的に、バックトラッキングは「アルゴリズム戦略」であり、再帰はより「ツール」です。
+
+- バックトラッキングアルゴリズムは通常再帰に基づいています。しかし、バックトラッキングは再帰の応用シナリオの一つであり、特に検索問題においてです。
+- 再帰の構造は「部分問題分解」の問題解決パラダイムを反映します。分割統治、バックトラッキング、動的プログラミング（メモ化再帰）を含む問題の解決でよく使用されます。