Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/cpp/chapter_backtracking/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_executable(preorder_traversal_i_compact preorder_traversal_i_compact.cpp)
+add_executable(preorder_traversal_ii_compact preorder_traversal_ii_compact.cpp)
+add_executable(preorder_traversal_iii_compact preorder_traversal_iii_compact.cpp)
+add_executable(preorder_traversal_iii_template preorder_traversal_iii_template.cpp)
+add_executable(permutations_i permutations_i.cpp)
+add_executable(permutations_ii permutations_ii.cpp)
+add_executable(n_queens n_queens.cpp)
+add_executable(subset_sum_i_naive subset_sum_i_naive.cpp)
+add_executable(subset_sum_i subset_sum_i.cpp)
+add_executable(subset_sum_ii subset_sum_ii.cpp)

ja/codes/cpp/chapter_backtracking/n_queens.cpp

@@ -6,40 +6,40 @@
 
 #include "../utils/common.hpp"
 
-/* バックトラッキングアルゴリズム：n クイーン */
+/* バックトラッキング：N クイーン */
 void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
                vector<bool> &diags1, vector<bool> &diags2) {
-    // すべての行が配置されたら、解を記録
+    // すべての行への配置が完了したら、解を記録する
     if (row == n) {
         res.push_back(state);
         return;
     }
     // すべての列を走査
     for (int col = 0; col < n; col++) {
-        // セルに対応する主対角線と副対角線を計算
+        // このマスに対応する主対角線と副対角線を計算
         int diag1 = row - col + n - 1;
         int diag2 = row + col;
-        // 剪定：セルの列、主対角線、副対角線にクイーンを配置することを許可しない
+        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない
         if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
-            // 試行：セルにクイーンを配置
+            // 試行：そのマスにクイーンを置く
             state[row][col] = "Q";
             cols[col] = diags1[diag1] = diags2[diag2] = true;
-            // 次の行を配置
+            // 次の行に配置する
             backtrack(row + 1, n, state, res, cols, diags1, diags2);
-            // 回退：セルを空のスポットに復元
+            // 戻す：そのマスを空きマスに戻す
             state[row][col] = "#";
             cols[col] = diags1[diag1] = diags2[diag2] = false;
         }
     }
 }
 
-/* n クイーンを解く */
+/* N クイーンを解く */
 vector<vector<vector<string>>> nQueens(int n) {
-    // n*n サイズのチェスボードを初期化、'Q' はクイーンを表し、'#' は空のスポットを表す
+    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
     vector<vector<string>> state(n, vector<string>(n, "#"));
-    vector<bool> cols(n, false);           // クイーンのある列を記録
-    vector<bool> diags1(2 * n - 1, false); // クイーンのある主対角線を記録
-    vector<bool> diags2(2 * n - 1, false); // クイーンのある副対角線を記録
+    vector<bool> cols(n, false);           // 列にクイーンがあるか記録
+    vector<bool> diags1(2 * n - 1, false); // 主対角線にクイーンがあるかを記録
+    vector<bool> diags2(2 * n - 1, false); // 副対角線にクイーンがあるかを記録
     vector<vector<vector<string>>> res;
 
     backtrack(0, n, state, res, cols, diags1, diags2);
@@ -47,13 +47,13 @@ vector<vector<vector<string>>> nQueens(int n) {
     return res;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     int n = 4;
     vector<vector<vector<string>>> res = nQueens(n);
 
-    cout << "チェスボードの次元を " << n << " として入力" << endl;
-    cout << "クイーン配置解の総数 = " << res.size() << endl;
+    cout << "入力した盤面の縦横は " << n << endl;
+    cout << "クイーンの配置方法は全部で " << res.size() << " 通り" << endl;
     for (const vector<vector<string>> &state : res) {
         cout << "--------------------" << endl;
         for (const vector<string> &row : state) {
@@ -62,4 +62,4 @@ int main() {
     }
 
     return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/permutations_i.cpp

@@ -6,9 +6,9 @@
 
 #include "../utils/common.hpp"
 
-/* バックトラッキングアルゴリズム：順列 I */
+/* バックトラッキング：順列 I */
 void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
-    // 状態の長さが要素数と等しくなったら、解を記録
+    // 状態の長さが要素数に等しければ、解を記録
     if (state.size() == choices.size()) {
         res.push_back(state);
         return;
@@ -16,21 +16,21 @@ void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &sel
     // すべての選択肢を走査
     for (int i = 0; i < choices.size(); i++) {
         int choice = choices[i];
-        // 剪定：要素の重複選択を許可しない
+        // 枝刈り：要素の重複選択を許可しない
         if (!selected[i]) {
-            // 試行：選択を行い、状態を更新
+            // 試行: 選択を行い、状態を更新
             selected[i] = true;
             state.push_back(choice);
-            // 次のラウンドの選択に進む
+            // 次の選択へ進む
             backtrack(state, choices, selected, res);
-            // 回退：選択を取り消し、前の状態に復元
+            // バックトラック：選択を取り消し、前の状態に戻す
             selected[i] = false;
             state.pop_back();
         }
     }
 }
 
-/* 順列 I */
+/* 全順列 I */
 vector<vector<int>> permutationsI(vector<int> nums) {
     vector<int> state;
     vector<bool> selected(nums.size(), false);
@@ -39,7 +39,7 @@ vector<vector<int>> permutationsI(vector<int> nums) {
     return res;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     vector<int> nums = {1, 2, 3};
 
@@ -51,4 +51,4 @@ int main() {
     printVectorMatrix(res);
 
     return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/permutations_ii.cpp

@@ -6,9 +6,9 @@
 
 #include "../utils/common.hpp"
 
-/* バックトラッキングアルゴリズム：順列 II */
+/* バックトラッキング：順列 II */
 void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
-    // 状態の長さが要素数と等しくなったら、解を記録
+    // 状態の長さが要素数に等しければ、解を記録
     if (state.size() == choices.size()) {
         res.push_back(state);
         return;
@@ -17,22 +17,22 @@ void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &sel
     unordered_set<int> duplicated;
     for (int i = 0; i < choices.size(); i++) {
         int choice = choices[i];
-        // 剪定：要素の重複選択を許可せず、等しい要素の重複選択も許可しない
+        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
         if (!selected[i] && duplicated.find(choice) == duplicated.end()) {
-            // 試行：選択を行い、状態を更新
-            duplicated.emplace(choice); // 選択された要素値を記録
+            // 試行: 選択を行い、状態を更新
+            duplicated.emplace(choice); // 選択済みの要素値を記録
             selected[i] = true;
             state.push_back(choice);
-            // 次のラウンドの選択に進む
+            // 次の選択へ進む
             backtrack(state, choices, selected, res);
-            // 回退：選択を取り消し、前の状態に復元
+            // バックトラック：選択を取り消し、前の状態に戻す
             selected[i] = false;
             state.pop_back();
         }
     }
 }
 
-/* 順列 II */
+/* 全順列 II */
 vector<vector<int>> permutationsII(vector<int> nums) {
     vector<int> state;
     vector<bool> selected(nums.size(), false);
@@ -41,7 +41,7 @@ vector<vector<int>> permutationsII(vector<int> nums) {
     return res;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     vector<int> nums = {1, 1, 2};
 
@@ -53,4 +53,4 @@ int main() {
     printVectorMatrix(res);
 
     return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/preorder_traversal_i_compact.cpp

@@ -8,7 +8,7 @@
 
 vector<TreeNode *> res;
 
-/* 前順走査：例１ */
+/* 前順走査：例題 1 */
 void preOrder(TreeNode *root) {
     if (root == nullptr) {
         return;
@@ -21,23 +21,19 @@ void preOrder(TreeNode *root) {
     preOrder(root->right);
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
-    vector<int> arr = {1, 7, 3, 4, 5, 6, 7};
-    TreeNode *root = vecToTree(arr);
+    TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
     cout << "\n二分木を初期化" << endl;
     printTree(root);
 
-    // 前順走査
-    res.clear();
+    // 先行順走査
     preOrder(root);
 
-    cout << "\n値7のノードをすべて出力" << endl;
+    cout << "\n値が 7 のすべてのノードを出力" << endl;
     vector<int> vals;
     for (TreeNode *node : res) {
         vals.push_back(node->val);
     }
     printVector(vals);
-
-    return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/preorder_traversal_ii_compact.cpp

@@ -9,12 +9,12 @@
 vector<TreeNode *> path;
 vector<vector<TreeNode *>> res;
 
-/* 前順走査：例２ */
+/* 前順走査：例題 2 */
 void preOrder(TreeNode *root) {
     if (root == nullptr) {
         return;
     }
-    // 試行
+    // 試す
     path.push_back(root);
     if (root->val == 7) {
         // 解を記録
@@ -22,23 +22,20 @@ void preOrder(TreeNode *root) {
     }
     preOrder(root->left);
     preOrder(root->right);
-    // 回退
+    // バックトラック
     path.pop_back();
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
-    vector<int> arr = {1, 7, 3, 4, 5, 6, 7};
-    TreeNode *root = vecToTree(arr);
+    TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
     cout << "\n二分木を初期化" << endl;
     printTree(root);
 
-    // 前順走査
-    path.clear();
-    res.clear();
+    // 先行順走査
     preOrder(root);
 
-    cout << "\nルートからノード7までのすべてのパスを出力" << endl;
+    cout << "\n根ノードからノード 7 までのすべての経路を出力" << endl;
     for (vector<TreeNode *> &path : res) {
         vector<int> vals;
         for (TreeNode *node : path) {
@@ -46,6 +43,4 @@ int main() {
         }
         printVector(vals);
     }
-
-    return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/preorder_traversal_iii_compact.cpp

@@ -9,13 +9,13 @@
 vector<TreeNode *> path;
 vector<vector<TreeNode *>> res;
 
-/* 前順走査：例３ */
+/* 前順走査：例題 3 */
 void preOrder(TreeNode *root) {
-    // 剪定
+    // 枝刈り
     if (root == nullptr || root->val == 3) {
         return;
     }
-    // 試行
+    // 試す
     path.push_back(root);
     if (root->val == 7) {
         // 解を記録
@@ -23,23 +23,20 @@ void preOrder(TreeNode *root) {
     }
     preOrder(root->left);
     preOrder(root->right);
-    // 回退
+    // バックトラック
     path.pop_back();
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
-    vector<int> arr = {1, 7, 3, 4, 5, 6, 7};
-    TreeNode *root = vecToTree(arr);
+    TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
     cout << "\n二分木を初期化" << endl;
     printTree(root);
 
-    // 前順走査
-    path.clear();
-    res.clear();
+    // 先行順走査
     preOrder(root);
 
-    cout << "\nルートからノード7までのすべてのパスを出力、値3のノードは含まない" << endl;
+    cout << "\n根ノードからノード 7 までのすべての経路を出力し、経路に値 3 のノードを含めない" << endl;
     for (vector<TreeNode *> &path : res) {
         vector<int> vals;
         for (TreeNode *node : path) {
@@ -47,6 +44,4 @@ int main() {
         }
         printVector(vals);
     }
-
-    return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/preorder_traversal_iii_template.cpp

@@ -16,7 +16,7 @@ void recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res)
     res.push_back(state);
 }
 
-/* 現在の状態下で選択が合法かどうかを判定 */
+/* 現在の状態で、この選択が有効かどうかを判定 */
 bool isValid(vector<TreeNode *> &state, TreeNode *choice) {
     return choice != nullptr && choice->val != 3;
 }
@@ -26,47 +26,46 @@ void makeChoice(vector<TreeNode *> &state, TreeNode *choice) {
     state.push_back(choice);
 }
 
-/* 状態を復元 */
+/* 状態を元に戻す */
 void undoChoice(vector<TreeNode *> &state, TreeNode *choice) {
     state.pop_back();
 }
 
-/* バックトラッキングアルゴリズム：例３ */
+/* バックトラッキング：例題 3 */
 void backtrack(vector<TreeNode *> &state, vector<TreeNode *> &choices, vector<vector<TreeNode *>> &res) {
-    // 解かどうかをチェック
+    // 解かどうかを確認
     if (isSolution(state)) {
         // 解を記録
         recordSolution(state, res);
     }
     // すべての選択肢を走査
     for (TreeNode *choice : choices) {
-        // 剪定：選択が合法かどうかをチェック
+        // 枝刈り：選択が妥当かを確認する
         if (isValid(state, choice)) {
-            // 試行：選択を行い、状態を更新
+            // 試行: 選択を行い、状態を更新
             makeChoice(state, choice);
-            // 次のラウンドの選択に進む
+            // 次の選択へ進む
             vector<TreeNode *> nextChoices{choice->left, choice->right};
             backtrack(state, nextChoices, res);
-            // 回退：選択を取り消し、前の状態に復元
+            // バックトラック：選択を取り消し、前の状態に戻す
             undoChoice(state, choice);
         }
     }
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
-    vector<int> arr = {1, 7, 3, 4, 5, 6, 7};
-    TreeNode *root = vecToTree(arr);
+    TreeNode *root = vectorToTree(vector<int>{1, 7, 3, 4, 5, 6, 7});
     cout << "\n二分木を初期化" << endl;
     printTree(root);
 
-    // バックトラッキングアルゴリズム
+    // バックトラッキング法
     vector<TreeNode *> state;
     vector<TreeNode *> choices = {root};
     vector<vector<TreeNode *>> res;
     backtrack(state, choices, res);
 
-    cout << "\nルートからノード7までのすべてのパスを出力、パスには値3のノードを含まないことが要求される" << endl;
+    cout << "\n根ノードからノード 7 までのすべての経路を出力し、経路に値 3 のノードを含めない" << endl;
     for (vector<TreeNode *> &path : res) {
         vector<int> vals;
         for (TreeNode *node : path) {
@@ -74,6 +73,4 @@ int main() {
         }
         printVector(vals);
     }
-
-    return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/subset_sum_i.cpp

@@ -6,41 +6,41 @@
 
 #include "../utils/common.hpp"
 
-/* バックトラッキングアルゴリズム：部分集合和 I */
+/* バックトラッキング：部分和 I */
 void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
-    // 部分集合の和がtargetと等しいとき、解を記録
+    // 部分集合の和が target に等しければ、解を記録
     if (target == 0) {
         res.push_back(state);
         return;
     }
     // すべての選択肢を走査
-    // 剪定二：startから走査を開始し、重複する部分集合の生成を回避
+    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
     for (int i = start; i < choices.size(); i++) {
-        // 剪定一：部分集合の和がtargetを超えた場合、即座にループを終了
-        // 配列がソートされているため、後の要素はさらに大きく、部分集合の和は必ずtargetを超える
+        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
+        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
         if (target - choices[i] < 0) {
             break;
         }
-        // 試行：選択を行い、target、startを更新
+        // 試す：選択を行い、target と start を更新
         state.push_back(choices[i]);
-        // 次のラウンドの選択に進む
+        // 次の選択へ進む
         backtrack(state, target - choices[i], choices, i, res);
-        // 回退：選択を取り消し、前の状態に復元
+        // バックトラック：選択を取り消し、前の状態に戻す
         state.pop_back();
     }
 }
 
-/* 部分集合和 I を解く */
-vector<vector<int>> subsetSumI(vector<int> nums, int target) {
+/* 部分和 I を解く */
+vector<vector<int>> subsetSumI(vector<int> &nums, int target) {
     vector<int> state;              // 状態（部分集合）
     sort(nums.begin(), nums.end()); // nums をソート
-    int start = 0;                  // 走査の開始点
-    vector<vector<int>> res;        // 結果リスト（部分集合リスト）
+    int start = 0;                  // 開始点を走査
+    vector<vector<int>> res;        // 結果リスト（部分集合のリスト）
     backtrack(state, target, nums, start, res);
     return res;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     vector<int> nums = {3, 4, 5};
     int target = 9;
@@ -50,8 +50,8 @@ int main() {
     cout << "入力配列 nums = ";
     printVector(nums);
     cout << "target = " << target << endl;
-    cout << "和が " << target << " のすべての部分集合 res = " << endl;
+    cout << "合計が " << target << " に等しいすべての部分集合 res = " << endl;
     printVectorMatrix(res);
 
     return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/subset_sum_i_naive.cpp

@@ -6,38 +6,38 @@
 
 #include "../utils/common.hpp"
 
-/* バックトラッキングアルゴリズム：部分集合和 I */
+/* バックトラッキング：部分和 I */
 void backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {
-    // 部分集合の和がtargetと等しいとき、解を記録
+    // 部分集合の和が target に等しければ、解を記録
     if (total == target) {
         res.push_back(state);
         return;
     }
     // すべての選択肢を走査
-    for (int i = 0; i < choices.size(); i++) {
-        // 剪定：部分集合の和がtargetを超えた場合、その選択をスキップ
+    for (size_t i = 0; i < choices.size(); i++) {
+        // 枝刈り：部分和が target を超える場合はその選択をスキップする
         if (total + choices[i] > target) {
             continue;
         }
-        // 試行：選択を行い、要素とtotalを更新
+        // 試行：選択を行い、要素と total を更新する
         state.push_back(choices[i]);
-        // 次のラウンドの選択に進む
+        // 次の選択へ進む
         backtrack(state, target, total + choices[i], choices, res);
-        // 回退：選択を取り消し、前の状態に復元
+        // バックトラック：選択を取り消し、前の状態に戻す
         state.pop_back();
     }
 }
 
-/* 部分集合和 I を解く（重複する部分集合を含む） */
-vector<vector<int>> subsetSumINaive(vector<int> nums, int target) {
+/* 部分和 I を解く（重複部分集合を含む） */
+vector<vector<int>> subsetSumINaive(vector<int> &nums, int target) {
     vector<int> state;       // 状態（部分集合）
-    int total = 0;           // 部分集合の和
-    vector<vector<int>> res; // 結果リスト（部分集合リスト）
+    int total = 0;           // 部分和
+    vector<vector<int>> res; // 結果リスト（部分集合のリスト）
     backtrack(state, target, total, nums, res);
     return res;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     vector<int> nums = {3, 4, 5};
     int target = 9;
@@ -47,9 +47,8 @@ int main() {
     cout << "入力配列 nums = ";
     printVector(nums);
     cout << "target = " << target << endl;
-    cout << "和が " << target << " のすべての部分集合 res = " << endl;
+    cout << "合計が " << target << " に等しいすべての部分集合 res = " << endl;
     printVectorMatrix(res);
-    cout << "この方法の結果には重複する集合が含まれています" << endl;
 
     return 0;
-}
+}

ja/codes/cpp/chapter_backtracking/subset_sum_ii.cpp

@@ -6,46 +6,46 @@
 
 #include "../utils/common.hpp"
 
-/* バックトラッキングアルゴリズム：部分集合和 II */
+/* バックトラッキング：部分和 II */
 void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
-    // 部分集合の和がtargetと等しいとき、解を記録
+    // 部分集合の和が target に等しければ、解を記録
     if (target == 0) {
         res.push_back(state);
         return;
     }
     // すべての選択肢を走査
-    // 剪定二：startから走査を開始し、重複する部分集合の生成を回避
-    // 剪定三：startから走査を開始し、同じ要素の繰り返し選択を回避
+    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
+    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
     for (int i = start; i < choices.size(); i++) {
-        // 剪定一：部分集合の和がtargetを超えた場合、即座にループを終了
-        // 配列がソートされているため、後の要素はさらに大きく、部分集合の和は必ずtargetを超える
+        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
+        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
         if (target - choices[i] < 0) {
             break;
         }
-        // 剪定四：要素が左の要素と等しい場合、検索ブランチの重複を示すのでスキップ
+        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
         if (i > start && choices[i] == choices[i - 1]) {
             continue;
         }
-        // 試行：選択を行い、target、startを更新
+        // 試す：選択を行い、target と start を更新
         state.push_back(choices[i]);
-        // 次のラウンドの選択に進む
+        // 次の選択へ進む
         backtrack(state, target - choices[i], choices, i + 1, res);
-        // 回退：選択を取り消し、前の状態に復元
+        // バックトラック：選択を取り消し、前の状態に戻す
         state.pop_back();
     }
 }
 
-/* 部分集合和 II を解く */
-vector<vector<int>> subsetSumII(vector<int> nums, int target) {
+/* 部分和 II を解く */
+vector<vector<int>> subsetSumII(vector<int> &nums, int target) {
     vector<int> state;              // 状態（部分集合）
     sort(nums.begin(), nums.end()); // nums をソート
-    int start = 0;                  // 走査の開始点
-    vector<vector<int>> res;        // 結果リスト（部分集合リスト）
+    int start = 0;                  // 開始点を走査
+    vector<vector<int>> res;        // 結果リスト（部分集合のリスト）
     backtrack(state, target, nums, start, res);
     return res;
 }
 
-/* ドライバーコード */
+/* Driver Code */
 int main() {
     vector<int> nums = {4, 4, 5};
     int target = 9;
@@ -55,8 +55,8 @@ int main() {
     cout << "入力配列 nums = ";
     printVector(nums);
     cout << "target = " << target << endl;
-    cout << "和が " << target << " のすべての部分集合 res = " << endl;
+    cout << "合計が " << target << " に等しいすべての部分集合 res = " << endl;
     printVectorMatrix(res);
 
     return 0;
-}
+}