Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/swift/chapter_backtracking/n_queens.swift

@@ -0,0 +1,67 @@
+/**
+ * File: n_queens.swift
+ * Created Time: 2023-05-14
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* バックトラッキング：N クイーン */
+func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {
+    // すべての行への配置が完了したら、解を記録する
+    if row == n {
+        res.append(state)
+        return
+    }
+    // すべての列を走査
+    for col in 0 ..< n {
+        // このマスに対応する主対角線と副対角線を計算
+        let diag1 = row - col + n - 1
+        let diag2 = row + col
+        // 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない
+        if !cols[col] && !diags1[diag1] && !diags2[diag2] {
+            // 試行：そのマスにクイーンを置く
+            state[row][col] = "Q"
+            cols[col] = true
+            diags1[diag1] = true
+            diags2[diag2] = true
+            // 次の行に配置する
+            backtrack(row: row + 1, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+            // 戻す：そのマスを空きマスに戻す
+            state[row][col] = "#"
+            cols[col] = false
+            diags1[diag1] = false
+            diags2[diag2] = false
+        }
+    }
+}
+
+/* N クイーンを解く */
+func nQueens(n: Int) -> [[[String]]] {
+    // n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
+    var state = Array(repeating: Array(repeating: "#", count: n), count: n)
+    var cols = Array(repeating: false, count: n) // 列にクイーンがあるか記録
+    var diags1 = Array(repeating: false, count: 2 * n - 1) // 主対角線にクイーンがあるかを記録
+    var diags2 = Array(repeating: false, count: 2 * n - 1) // 副対角線にクイーンがあるかを記録
+    var res: [[[String]]] = []
+
+    backtrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2)
+
+    return res
+}
+
+@main
+enum NQueens {
+    /* Driver Code */
+    static func main() {
+        let n = 4
+        let res = nQueens(n: n)
+
+        print("入力された盤面の縦横は \(n)")
+        print("クイーンの配置方法は全部で \(res.count) 通り")
+        for state in res {
+            print("--------------------")
+            for row in state {
+                print(row)
+            }
+        }
+    }
+}

ja/codes/swift/chapter_backtracking/permutations_i.swift

@@ -0,0 +1,50 @@
+/**
+ * File: permutations_i.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* バックトラッキング：順列 I */
+func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+    // 状態の長さが要素数に等しければ、解を記録
+    if state.count == choices.count {
+        res.append(state)
+        return
+    }
+    // すべての選択肢を走査
+    for (i, choice) in choices.enumerated() {
+        // 枝刈り：要素の重複選択を許可しない
+        if !selected[i] {
+            // 試行: 選択を行い、状態を更新
+            selected[i] = true
+            state.append(choice)
+            // 次の選択へ進む
+            backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+            // バックトラック：選択を取り消し、前の状態に戻す
+            selected[i] = false
+            state.removeLast()
+        }
+    }
+}
+
+/* 全順列 I */
+func permutationsI(nums: [Int]) -> [[Int]] {
+    var state: [Int] = []
+    var selected = Array(repeating: false, count: nums.count)
+    var res: [[Int]] = []
+    backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+    return res
+}
+
+@main
+enum PermutationsI {
+    /* Driver Code */
+    static func main() {
+        let nums = [1, 2, 3]
+
+        let res = permutationsI(nums: nums)
+
+        print("入力配列 nums = \(nums)")
+        print("すべての順列 res = \(res)")
+    }
+}

ja/codes/swift/chapter_backtracking/permutations_ii.swift

@@ -0,0 +1,52 @@
+/**
+ * File: permutations_ii.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* バックトラッキング：順列 II */
+func backtrack(state: inout [Int], choices: [Int], selected: inout [Bool], res: inout [[Int]]) {
+    // 状態の長さが要素数に等しければ、解を記録
+    if state.count == choices.count {
+        res.append(state)
+        return
+    }
+    // すべての選択肢を走査
+    var duplicated: Set<Int> = []
+    for (i, choice) in choices.enumerated() {
+        // 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
+        if !selected[i], !duplicated.contains(choice) {
+            // 試行: 選択を行い、状態を更新
+            duplicated.insert(choice) // 選択済みの要素値を記録
+            selected[i] = true
+            state.append(choice)
+            // 次の選択へ進む
+            backtrack(state: &state, choices: choices, selected: &selected, res: &res)
+            // バックトラック：選択を取り消し、前の状態に戻す
+            selected[i] = false
+            state.removeLast()
+        }
+    }
+}
+
+/* 全順列 II */
+func permutationsII(nums: [Int]) -> [[Int]] {
+    var state: [Int] = []
+    var selected = Array(repeating: false, count: nums.count)
+    var res: [[Int]] = []
+    backtrack(state: &state, choices: nums, selected: &selected, res: &res)
+    return res
+}
+
+@main
+enum PermutationsII {
+    /* Driver Code */
+    static func main() {
+        let nums = [1, 2, 3]
+
+        let res = permutationsII(nums: nums)
+
+        print("入力配列 nums = \(nums)")
+        print("すべての順列 res = \(res)")
+    }
+}

ja/codes/swift/chapter_backtracking/preorder_traversal_i_compact.swift

@@ -0,0 +1,43 @@
+/**
+ * File: preorder_traversal_i_compact.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+var res: [TreeNode] = []
+
+/* 前順走査：例題 1 */
+func preOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    if root.val == 7 {
+        // 解を記録
+        res.append(root)
+    }
+    preOrder(root: root.left)
+    preOrder(root: root.right)
+}
+
+@main
+enum PreorderTraversalICompact {
+    /* Driver Code */
+    static func main() {
+        let root = TreeNode.listToTree(arr: [1, 7, 3, 4, 5, 6, 7])
+        print("\n二分木を初期化")
+        PrintUtil.printTree(root: root)
+
+        // 先行順走査
+        res = []
+        preOrder(root: root)
+
+        print("\n値が 7 のすべてのノードを出力")
+        var vals: [Int] = []
+        for node in res {
+            vals.append(node.val)
+        }
+        print(vals)
+    }
+}

ja/codes/swift/chapter_backtracking/preorder_traversal_ii_compact.swift

@@ -0,0 +1,51 @@
+/**
+ * File: preorder_traversal_ii_compact.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+var path: [TreeNode] = []
+var res: [[TreeNode]] = []
+
+/* 前順走査：例題 2 */
+func preOrder(root: TreeNode?) {
+    guard let root = root else {
+        return
+    }
+    // 試す
+    path.append(root)
+    if root.val == 7 {
+        // 解を記録
+        res.append(path)
+    }
+    preOrder(root: root.left)
+    preOrder(root: root.right)
+    // バックトラック
+    path.removeLast()
+}
+
+@main
+enum PreorderTraversalIICompact {
+    /* Driver Code */
+    static func main() {
+        let root = TreeNode.listToTree(arr: [1, 7, 3, 4, 5, 6, 7])
+        print("\n二分木を初期化")
+        PrintUtil.printTree(root: root)
+
+        // 先行順走査
+        path = []
+        res = []
+        preOrder(root: root)
+
+        print("\n根ノードからノード 7 までのすべての経路を出力")
+        for path in res {
+            var vals: [Int] = []
+            for node in path {
+                vals.append(node.val)
+            }
+            print(vals)
+        }
+    }
+}

ja/codes/swift/chapter_backtracking/preorder_traversal_iii_compact.swift

@@ -0,0 +1,52 @@
+/**
+ * File: preorder_traversal_iii_compact.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+var path: [TreeNode] = []
+var res: [[TreeNode]] = []
+
+/* 前順走査：例題 3 */
+func preOrder(root: TreeNode?) {
+    // 枝刈り
+    guard let root = root, root.val != 3 else {
+        return
+    }
+    // 試す
+    path.append(root)
+    if root.val == 7 {
+        // 解を記録
+        res.append(path)
+    }
+    preOrder(root: root.left)
+    preOrder(root: root.right)
+    // バックトラック
+    path.removeLast()
+}
+
+@main
+enum PreorderTraversalIIICompact {
+    /* Driver Code */
+    static func main() {
+        let root = TreeNode.listToTree(arr: [1, 7, 3, 4, 5, 6, 7])
+        print("\n二分木を初期化")
+        PrintUtil.printTree(root: root)
+
+        // 先行順走査
+        path = []
+        res = []
+        preOrder(root: root)
+
+        print("\n根ノードからノード 7 までのすべての経路を出力し、経路に値が 3 のノードを含まない")
+        for path in res {
+            var vals: [Int] = []
+            for node in path {
+                vals.append(node.val)
+            }
+            print(vals)
+        }
+    }
+}

ja/codes/swift/chapter_backtracking/preorder_traversal_iii_template.swift

@@ -0,0 +1,76 @@
+/**
+ * File: preorder_traversal_iii_template.swift
+ * Created Time: 2023-04-30
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+import utils
+
+/* 現在の状態が解かどうかを判定 */
+func isSolution(state: [TreeNode]) -> Bool {
+    !state.isEmpty && state.last!.val == 7
+}
+
+/* 解を記録 */
+func recordSolution(state: [TreeNode], res: inout [[TreeNode]]) {
+    res.append(state)
+}
+
+/* 現在の状態で、この選択が有効かどうかを判定 */
+func isValid(state: [TreeNode], choice: TreeNode?) -> Bool {
+    choice != nil && choice!.val != 3
+}
+
+/* 状態を更新 */
+func makeChoice(state: inout [TreeNode], choice: TreeNode) {
+    state.append(choice)
+}
+
+/* 状態を元に戻す */
+func undoChoice(state: inout [TreeNode], choice: TreeNode) {
+    state.removeLast()
+}
+
+/* バックトラッキング：例題 3 */
+func backtrack(state: inout [TreeNode], choices: [TreeNode], res: inout [[TreeNode]]) {
+    // 解かどうかを確認
+    if isSolution(state: state) {
+        recordSolution(state: state, res: &res)
+    }
+    // すべての選択肢を走査
+    for choice in choices {
+        // 枝刈り：選択が妥当かを確認する
+        if isValid(state: state, choice: choice) {
+            // 試行: 選択を行い、状態を更新
+            makeChoice(state: &state, choice: choice)
+            // 次の選択へ進む
+            backtrack(state: &state, choices: [choice.left, choice.right].compactMap { $0 }, res: &res)
+            // バックトラック：選択を取り消し、前の状態に戻す
+            undoChoice(state: &state, choice: choice)
+        }
+    }
+}
+
+@main
+enum PreorderTraversalIIITemplate {
+    /* Driver Code */
+    static func main() {
+        let root = TreeNode.listToTree(arr: [1, 7, 3, 4, 5, 6, 7])
+        print("\n二分木を初期化")
+        PrintUtil.printTree(root: root)
+
+        // バックトラッキング法
+        var state: [TreeNode] = []
+        var res: [[TreeNode]] = []
+        backtrack(state: &state, choices: [root].compactMap { $0 }, res: &res)
+
+        print("\n根ノードからノード 7 までのすべての経路を出力し、経路に値が 3 のノードを含まない")
+        for path in res {
+            var vals: [Int] = []
+            for node in path {
+                vals.append(node.val)
+            }
+            print(vals)
+        }
+    }
+}

ja/codes/swift/chapter_backtracking/subset_sum_i.swift

@@ -0,0 +1,53 @@
+/**
+ * File: subset_sum_i.swift
+ * Created Time: 2023-07-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* バックトラッキング：部分和 I */
+func backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {
+    // 部分集合の和が target に等しければ、解を記録
+    if target == 0 {
+        res.append(state)
+        return
+    }
+    // すべての選択肢を走査
+    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
+    for i in choices.indices.dropFirst(start) {
+        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
+        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
+        if target - choices[i] < 0 {
+            break
+        }
+        // 試す：選択を行い、target と start を更新
+        state.append(choices[i])
+        // 次の選択へ進む
+        backtrack(state: &state, target: target - choices[i], choices: choices, start: i, res: &res)
+        // バックトラック：選択を取り消し、前の状態に戻す
+        state.removeLast()
+    }
+}
+
+/* 部分和 I を解く */
+func subsetSumI(nums: [Int], target: Int) -> [[Int]] {
+    var state: [Int] = [] // 状態（部分集合）
+    let nums = nums.sorted() // nums をソート
+    let start = 0 // 開始点を走査
+    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）
+    backtrack(state: &state, target: target, choices: nums, start: start, res: &res)
+    return res
+}
+
+@main
+enum SubsetSumI {
+    /* Driver Code */
+    static func main() {
+        let nums = [3, 4, 5]
+        let target = 9
+
+        let res = subsetSumI(nums: nums, target: target)
+
+        print("入力配列 nums = \(nums), target = \(target)")
+        print("和が \(target) に等しいすべての部分集合 res = \(res)")
+    }
+}

ja/codes/swift/chapter_backtracking/subset_sum_i_naive.swift

@@ -0,0 +1,51 @@
+/**
+ * File: subset_sum_i_naive.swift
+ * Created Time: 2023-07-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* バックトラッキング：部分和 I */
+func backtrack(state: inout [Int], target: Int, total: Int, choices: [Int], res: inout [[Int]]) {
+    // 部分集合の和が target に等しければ、解を記録
+    if total == target {
+        res.append(state)
+        return
+    }
+    // すべての選択肢を走査
+    for i in choices.indices {
+        // 枝刈り：部分和が target を超える場合はその選択をスキップする
+        if total + choices[i] > target {
+            continue
+        }
+        // 試行：選択を行い、要素と total を更新する
+        state.append(choices[i])
+        // 次の選択へ進む
+        backtrack(state: &state, target: target, total: total + choices[i], choices: choices, res: &res)
+        // バックトラック：選択を取り消し、前の状態に戻す
+        state.removeLast()
+    }
+}
+
+/* 部分和 I を解く（重複部分集合を含む） */
+func subsetSumINaive(nums: [Int], target: Int) -> [[Int]] {
+    var state: [Int] = [] // 状態（部分集合）
+    let total = 0 // 部分和
+    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）
+    backtrack(state: &state, target: target, total: total, choices: nums, res: &res)
+    return res
+}
+
+@main
+enum SubsetSumINaive {
+    /* Driver Code */
+    static func main() {
+        let nums = [3, 4, 5]
+        let target = 9
+
+        let res = subsetSumINaive(nums: nums, target: target)
+
+        print("入力配列 nums = \(nums), target = \(target)")
+        print("和が \(target) に等しいすべての部分集合 res = \(res)")
+        print("この方法の出力結果には重複した集合が含まれることに注意してください")
+    }
+}

ja/codes/swift/chapter_backtracking/subset_sum_ii.swift

@@ -0,0 +1,58 @@
+/**
+ * File: subset_sum_ii.swift
+ * Created Time: 2023-07-02
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+/* バックトラッキング：部分和 II */
+func backtrack(state: inout [Int], target: Int, choices: [Int], start: Int, res: inout [[Int]]) {
+    // 部分集合の和が target に等しければ、解を記録
+    if target == 0 {
+        res.append(state)
+        return
+    }
+    // すべての選択肢を走査
+    // 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
+    // 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
+    for i in choices.indices.dropFirst(start) {
+        // 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
+        // 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
+        if target - choices[i] < 0 {
+            break
+        }
+        // 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
+        if i > start, choices[i] == choices[i - 1] {
+            continue
+        }
+        // 試す：選択を行い、target と start を更新
+        state.append(choices[i])
+        // 次の選択へ進む
+        backtrack(state: &state, target: target - choices[i], choices: choices, start: i + 1, res: &res)
+        // バックトラック：選択を取り消し、前の状態に戻す
+        state.removeLast()
+    }
+}
+
+/* 部分和 II を解く */
+func subsetSumII(nums: [Int], target: Int) -> [[Int]] {
+    var state: [Int] = [] // 状態（部分集合）
+    let nums = nums.sorted() // nums をソート
+    let start = 0 // 開始点を走査
+    var res: [[Int]] = [] // 結果リスト（部分集合のリスト）
+    backtrack(state: &state, target: target, choices: nums, start: start, res: &res)
+    return res
+}
+
+@main
+enum SubsetSumII {
+    /* Driver Code */
+    static func main() {
+        let nums = [4, 4, 5]
+        let target = 9
+
+        let res = subsetSumII(nums: nums, target: target)
+
+        print("入力配列 nums = \(nums), target = \(target)")
+        print("和が \(target) に等しいすべての部分集合 res = \(res)")
+    }
+}