CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-06-15 22:57:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

Re-translate the Japanese version (#1871)

Browse Source 
* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4
This commit is contained in:
Yudong Jin
2026-03-30 07:30:15 +08:00
committed by GitHub
parent fe6443235b
commit d7b2277d2b
1444 changed files with 83312 additions and 8363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
ja/codes/java/chapter_backtracking/n_queens.java
View File

@@ -9,10 +9,10 @@ package chapter_backtracking;
import java.util.*;
public class n_queens {
/* バックトラッキングアルゴリズム：n クイーン */
/* バックトラッキング：N クイーン */
public static void backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,
boolean[] cols, boolean[] diags1, boolean[] diags2) {
// すべての行が配置されたら、解を記録
// すべての行への配置が完了したら、解を記録する
if (row == n) {
List<List<String>> copyState = new ArrayList<>();
for (List<String> sRow : state) {
@@ -23,26 +23,26 @@ public class n_queens {
}
// すべての列を走査
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.get(row).set(col, "Q");
cols[col] = diags1[diag1] = diags2[diag2] = true;
// 次の行を配置
// 次の行に配置する
backtrack(row + 1, n, state, res, cols, diags1, diags2);
// 回退：セルを空のスポットに復元
// 戻す：そのマスを空きマスに戻す
state.get(row).set(col, "#");
cols[col] = diags1[diag1] = diags2[diag2] = false;
}
}
}
/* n クイーンを解く */
/* N クイーンを解く */
public static List<List<List<String>>> nQueens(int n) {
// n*n サイズのチェスボードを初期化、'Q' はクイーンを表し、'#' は空のスポットを表す
// n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
List<List<String>> state = new ArrayList<>();
for (int i = 0; i < n; i++) {
List<String> row = new ArrayList<>();
@@ -51,9 +51,9 @@ public class n_queens {
}
state.add(row);
}
boolean[] cols = new boolean[n]; // クイーンのある列を記録
boolean[] diags1 = new boolean[2 * n - 1]; // クイーンのある主対角線を記録
boolean[] diags2 = new boolean[2 * n - 1]; // クイーンのある副対角線を記録
boolean[] cols = new boolean[n]; // 列にクイーンがあるか記録
boolean[] diags1 = new boolean[2 * n - 1]; // 主対角線にクイーンがあるかを記録
boolean[] diags2 = new boolean[2 * n - 1]; // 副対角線にクイーンがあるかを記録
List<List<List<String>>> res = new ArrayList<>();
backtrack(0, n, state, res, cols, diags1, diags2);
@@ -65,8 +65,8 @@ public class n_queens {
int n = 4;
List<List<List<String>>> res = nQueens(n);
System.out.println("チェスボードの次元を " + n + " として入力");
System.out.println("クイーン配置解の総数 = " + res.size());
System.out.println("盤面の縦横サイズは " + n);
System.out.println("クイーンの配置方法は全部で " + res.size() + " 通り");
for (List<List<String>> state : res) {
System.out.println("--------------------");
for (List<String> row : state) {
@@ -74,4 +74,4 @@ public class n_queens {
}
}
}
}
}

16
ja/codes/java/chapter_backtracking/permutations_i.java
View File

@@ -9,9 +9,9 @@ package chapter_backtracking;
import java.util.*;
public class permutations_i {
/* バックトラッキングアルゴリズム：順列 I */
/* バックトラッキング：順列 I */
public static void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
// 状態の長さが要素数と等しくなったら、解を記録
// 状態の長さが要素数に等しければ、解を記録
if (state.size() == choices.length) {
res.add(new ArrayList<Integer>(state));
return;
@@ -19,21 +19,21 @@ public class permutations_i {
// すべての選択肢を走査
for (int i = 0; i < choices.length; i++) {
int choice = choices[i];
// 剪定：要素の重複選択を許可しない
// 枝刈り：要素の重複選択を許可しない
if (!selected[i]) {
// 試行：選択を行い、状態を更新
// 試行: 選択を行い、状態を更新
selected[i] = true;
state.add(choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, choices, selected, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
selected[i] = false;
state.remove(state.size() - 1);
}
}
}
/* 順列 I */
/* 全順列 I */
static List<List<Integer>> permutationsI(int[] nums) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
@@ -48,4 +48,4 @@ public class permutations_i {
System.out.println("入力配列 nums = " + Arrays.toString(nums));
System.out.println("すべての順列 res = " + res);
}
}
}

18
ja/codes/java/chapter_backtracking/permutations_ii.java
View File

@@ -9,9 +9,9 @@ package chapter_backtracking;
import java.util.*;
public class permutations_ii {
/* バックトラッキングアルゴリズム：順列 II */
/* バックトラッキング：順列 II */
static void backtrack(List<Integer> state, int[] choices, boolean[] selected, List<List<Integer>> res) {
// 状態の長さが要素数と等しくなったら、解を記録
// 状態の長さが要素数に等しければ、解を記録
if (state.size() == choices.length) {
res.add(new ArrayList<Integer>(state));
return;
@@ -20,22 +20,22 @@ public class permutations_ii {
Set<Integer> duplicated = new HashSet<Integer>();
for (int i = 0; i < choices.length; i++) {
int choice = choices[i];
// 剪定：要素の重複選択を許可せず、等しい要素の重複選択も許可しない
// 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
if (!selected[i] && !duplicated.contains(choice)) {
// 試行：選択を行い、状態を更新
duplicated.add(choice); // 選択された要素値を記録
// 試行: 選択を行い、状態を更新
duplicated.add(choice); // 選択済みの要素値を記録
selected[i] = true;
state.add(choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, choices, selected, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
selected[i] = false;
state.remove(state.size() - 1);
}
}
}
/* 順列 II */
/* 全順列 II */
static List<List<Integer>> permutationsII(int[] nums) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
backtrack(new ArrayList<Integer>(), nums, new boolean[nums.length], res);
@@ -50,4 +50,4 @@ public class permutations_ii {
System.out.println("入力配列 nums = " + Arrays.toString(nums));
System.out.println("すべての順列 res = " + res);
}
}
}

8
ja/codes/java/chapter_backtracking/preorder_traversal_i_compact.java
View File

@@ -12,7 +12,7 @@ import java.util.*;
public class preorder_traversal_i_compact {
static List<TreeNode> res;
/* 前順走査：例１ */
/* 前順走査：例題 1 */
static void preOrder(TreeNode root) {
if (root == null) {
return;
@@ -30,15 +30,15 @@ public class preorder_traversal_i_compact {
System.out.println("\n二分木を初期化");
PrintUtil.printTree(root);
// 前順走査
// 先行順走査
res = new ArrayList<>();
preOrder(root);
System.out.println("\n値7のノードをすべて出力");
System.out.println("\n値が 7 のノードをすべて出力");
List<Integer> vals = new ArrayList<>();
for (TreeNode node : res) {
vals.add(node.val);
}
System.out.println(vals);
}
}
}

12
ja/codes/java/chapter_backtracking/preorder_traversal_ii_compact.java
View File

@@ -13,12 +13,12 @@ public class preorder_traversal_ii_compact {
static List<TreeNode> path;
static List<List<TreeNode>> res;
/* 前順走査：例２ */
/* 前順走査：例題 2 */
static void preOrder(TreeNode root) {
if (root == null) {
return;
}
// 試行
// 試す
path.add(root);
if (root.val == 7) {
// 解を記録
@@ -26,7 +26,7 @@ public class preorder_traversal_ii_compact {
}
preOrder(root.left);
preOrder(root.right);
// 回退
// バックトラック
path.remove(path.size() - 1);
}
@@ -35,12 +35,12 @@ public class preorder_traversal_ii_compact {
System.out.println("\n二分木を初期化");
PrintUtil.printTree(root);
// 前順走査
// 先行順走査
path = new ArrayList<>();
res = new ArrayList<>();
preOrder(root);
System.out.println("\nルートからノード7までのすべてのパスを出力");
System.out.println("\n根ノードからノード 7 までのすべての経路を出力");
for (List<TreeNode> path : res) {
List<Integer> vals = new ArrayList<>();
for (TreeNode node : path) {
@@ -49,4 +49,4 @@ public class preorder_traversal_ii_compact {
System.out.println(vals);
}
}
}
}

14
ja/codes/java/chapter_backtracking/preorder_traversal_iii_compact.java
View File

@@ -13,13 +13,13 @@ public class preorder_traversal_iii_compact {
static List<TreeNode> path;
static List<List<TreeNode>> res;
/* 前順走査：例３ */
/* 前順走査：例題 3 */
static void preOrder(TreeNode root) {
// 剪定
// 枝刈り
if (root == null || root.val == 3) {
return;
}
// 試行
// 試す
path.add(root);
if (root.val == 7) {
// 解を記録
@@ -27,7 +27,7 @@ public class preorder_traversal_iii_compact {
}
preOrder(root.left);
preOrder(root.right);
// 回退
// バックトラック
path.remove(path.size() - 1);
}
@@ -36,12 +36,12 @@ public class preorder_traversal_iii_compact {
System.out.println("\n二分木を初期化");
PrintUtil.printTree(root);
// 前順走査
// 先行順走査
path = new ArrayList<>();
res = new ArrayList<>();
preOrder(root);
System.out.println("\nルートからノード7までのすべてのパスを出力、値3のノードは含まない");
System.out.println("\n根ノードからノード 7 までのすべての経路を出力し、経路には値が 3 のノードを含めない");
for (List<TreeNode> path : res) {
List<Integer> vals = new ArrayList<>();
for (TreeNode node : path) {
@@ -50,4 +50,4 @@ public class preorder_traversal_iii_compact {
System.out.println(vals);
}
}
}
}

22
ja/codes/java/chapter_backtracking/preorder_traversal_iii_template.java
View File

@@ -20,7 +20,7 @@ public class preorder_traversal_iii_template {
res.add(new ArrayList<>(state));
}
/* 現在の状態下で選択が合法かどうかを判定 */
/* 現在の状態で、この選択が有効かどうかを判定 */
static boolean isValid(List<TreeNode> state, TreeNode choice) {
return choice != null && choice.val != 3;
}
@@ -30,27 +30,27 @@ public class preorder_traversal_iii_template {
state.add(choice);
}
/* 状態を復元 */
/* 状態を元に戻す */
static void undoChoice(List<TreeNode> state, TreeNode choice) {
state.remove(state.size() - 1);
}
/* バックトラッキングアルゴリズム：例３ */
/* バックトラッキング：例題 3 */
static void backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {
// 解かどうかをチェック
// 解かどうかを確認
if (isSolution(state)) {
// 解を記録
recordSolution(state, res);
}
// すべての選択肢を走査
for (TreeNode choice : choices) {
// 剪定：選択が合法かどうかをチェック
// 枝刈り：選択が妥当かを確認する
if (isValid(state, choice)) {
// 試行：選択を行い、状態を更新
// 試行: 選択を行い、状態を更新
makeChoice(state, choice);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, Arrays.asList(choice.left, choice.right), res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
undoChoice(state, choice);
}
}
@@ -61,11 +61,11 @@ public class preorder_traversal_iii_template {
System.out.println("\n二分木を初期化");
PrintUtil.printTree(root);
// バックトラッキングアルゴリズム
// バックトラッキング法
List<List<TreeNode>> res = new ArrayList<>();
backtrack(new ArrayList<>(), Arrays.asList(root), res);
System.out.println("\nルートからノード7までのすべてのパスを出力、パスには値3のノードを含まないことが要求される");
System.out.println("\n根ノードからノード 7 までのすべての経路を出力し、経路に値が 3 のノードを含まないことを条件とする");
for (List<TreeNode> path : res) {
List<Integer> vals = new ArrayList<>();
for (TreeNode node : path) {
@@ -74,4 +74,4 @@ public class preorder_traversal_iii_template {
System.out.println(vals);
}
}
}
}

26
ja/codes/java/chapter_backtracking/subset_sum_i.java
View File

@@ -9,36 +9,36 @@ package chapter_backtracking;
import java.util.*;
public class subset_sum_i {
/* バックトラッキングアルゴリズム：部分集合和 I */
/* バックトラッキング：部分和 I */
static void backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {
// 部分集合の和がtargetと等しいとき、解を記録
// 部分集合の和が target に等しければ、解を記録
if (target == 0) {
res.add(new ArrayList<>(state));
return;
}
// すべての選択肢を走査
// 剪定二：startから走査を開始し、重複する部分集合の生成を回避
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
for (int i = start; i < choices.length; i++) {
// 剪定一：部分集合の和がtargetを超えた場合、即座にループを終了
// 配列がソートされているため、後の要素はさらに大きく、部分集合の和は必ずtargetを超える
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
if (target - choices[i] < 0) {
break;
}
// 試行：選択を行い、target、startを更新
// 試す：選択を行い、target と start を更新
state.add(choices[i]);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, target - choices[i], choices, i, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
state.remove(state.size() - 1);
}
}
/* 部分集合和 I を解く */
/* 部分和 I を解く */
static List<List<Integer>> subsetSumI(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状態（部分集合）
Arrays.sort(nums); // nums をソート
int start = 0; // 走査の開始点
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合リスト）
int start = 0; // 開始点を走査
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res);
return res;
}
@@ -50,6 +50,6 @@ public class subset_sum_i {
List<List<Integer>> res = subsetSumI(nums, target);
System.out.println("入力配列 nums = " + Arrays.toString(nums) + ", target = " + target);
System.out.println("和が " + target + " のすべての部分集合 res = " + res);
System.out.println("和が " + target + " に等しいすべての部分集合 res = " + res);
}
}
}

24
ja/codes/java/chapter_backtracking/subset_sum_i_naive.java
View File

@@ -9,33 +9,33 @@ package chapter_backtracking;
import java.util.*;
public class subset_sum_i_naive {
/* バックトラッキングアルゴリズム：部分集合和 I */
/* バックトラッキング：部分和 I */
static void backtrack(List<Integer> state, int target, int total, int[] choices, List<List<Integer>> res) {
// 部分集合の和がtargetと等しいとき、解を記録
// 部分集合の和が target に等しければ、解を記録
if (total == target) {
res.add(new ArrayList<>(state));
return;
}
// すべての選択肢を走査
for (int i = 0; i < choices.length; i++) {
// 剪定：部分集合の和がtargetを超えた場合、その選択をスキップ
// 枝刈り：部分和が target を超える場合はその選択をスキップする
if (total + choices[i] > target) {
continue;
}
// 試行：選択を行い、要素とtotalを更新
// 試行：選択を行い、要素と total を更新する
state.add(choices[i]);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, target, total + choices[i], choices, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
state.remove(state.size() - 1);
}
}
/* 部分集合和 I を解く（重複する部分集合を含む） */
/* 部分和 I を解く（重複部分集合を含む） */
static List<List<Integer>> subsetSumINaive(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状態（部分集合）
int total = 0; // 部分集合の和
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合リスト）
int total = 0; // 部分和
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合のリスト）
backtrack(state, target, total, nums, res);
return res;
}
@@ -47,7 +47,7 @@ public class subset_sum_i_naive {
List<List<Integer>> res = subsetSumINaive(nums, target);
System.out.println("入力配列 nums = " + Arrays.toString(nums) + ", target = " + target);
System.out.println("和が " + target + " のすべての部分集合 res = " + res);
System.out.println("この方法の結果には重複する集合が含まれています");
System.out.println("和が " + target + " に等しいすべての部分集合 res = " + res);
System.out.println("注意: この方法の出力結果には重複した集合が含まれます");
}
}
}

30
ja/codes/java/chapter_backtracking/subset_sum_ii.java
View File

@@ -9,41 +9,41 @@ package chapter_backtracking;
import java.util.*;
public class subset_sum_ii {
/* バックトラッキングアルゴリズム：部分集合和 II */
/* バックトラッキング：部分和 II */
static void backtrack(List<Integer> state, int target, int[] choices, int start, List<List<Integer>> res) {
// 部分集合の和がtargetと等しいとき、解を記録
// 部分集合の和が target に等しければ、解を記録
if (target == 0) {
res.add(new ArrayList<>(state));
return;
}
// すべての選択肢を走査
// 剪定二：startから走査を開始し、重複する部分集合の生成を回避
// 剪定三：startから走査を開始し、同じ要素の繰り返し選択を回避
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
// 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
for (int i = start; i < choices.length; 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.add(choices[i]);
// 次のラウンドの選択に進む
// 次の選択へ進む
backtrack(state, target - choices[i], choices, i + 1, res);
// 回退：選択を取り消し、前の状態に復元
// バックトラック：選択を取り消し、前の状態に戻す
state.remove(state.size() - 1);
}
}
/* 部分集合和 II を解く */
/* 部分和 II を解く */
static List<List<Integer>> subsetSumII(int[] nums, int target) {
List<Integer> state = new ArrayList<>(); // 状態（部分集合）
Arrays.sort(nums); // nums をソート
int start = 0; // 走査の開始点
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合リスト）
int start = 0; // 開始点を走査
List<List<Integer>> res = new ArrayList<>(); // 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res);
return res;
}
@@ -55,6 +55,6 @@ public class subset_sum_ii {
List<List<Integer>> res = subsetSumII(nums, target);
System.out.println("入力配列 nums = " + Arrays.toString(nums) + ", target = " + target);
System.out.println("和が " + target + " のすべての部分集合 res = " + res);
System.out.println("和が " + target + " に等しいすべての部分集合 res = " + res);
}
}
}