build

docs/chapter_backtracking/backtracking_algorithm.md

@@ -220,7 +220,16 @@ comments: true
 === "Ruby"
 
     ```ruby title="preorder_traversal_i_compact.rb"
-    [class]{}-[func]{pre_order}
+    ### 前序遍历：例题一 ###
+    def pre_order(root)
+      return unless root
+
+      # 记录解
+      $res << root if root.val == 7
+
+      pre_order(root.left)
+      pre_order(root.right)
+    end
     ```
 
 === "Zig"
@@ -522,7 +531,22 @@ comments: true
 === "Ruby"
 
     ```ruby title="preorder_traversal_ii_compact.rb"
-    [class]{}-[func]{pre_order}
+    ### 前序遍历：例题二 ###
+    def pre_order(root)
+      return unless root
+
+      # 尝试
+      $path << root
+
+      # 记录解
+      $res << $path.dup if root.val == 7
+
+      pre_order(root.left)
+      pre_order(root.right)
+
+      # 回退
+      $path.pop
+    end
     ```
 
 === "Zig"
@@ -866,7 +890,23 @@ comments: true
 === "Ruby"
 
     ```ruby title="preorder_traversal_iii_compact.rb"
-    [class]{}-[func]{pre_order}
+    ### 前序遍历：例题三 ###
+    def pre_order(root)
+      # 剪枝
+      return if !root || root.val == 3
+
+      # 尝试
+      $path.append(root)
+
+      # 记录解
+      $res << $path.dup if root.val == 7
+
+      pre_order(root.left)
+      pre_order(root.right)
+
+      # 回退
+      $path.pop
+    end
     ```
 
 === "Zig"
@@ -1203,7 +1243,27 @@ comments: true
 === "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"
@@ -1843,17 +1903,49 @@ comments: true
 === "Ruby"
 
     ```ruby title="preorder_traversal_iii_template.rb"
-    [class]{}-[func]{is_solution}
+    ### 判断当前状态是否为解 ###
+    def is_solution?(state)
+      !state.empty? && state.last.val == 7
+    end
 
-    [class]{}-[func]{record_solution}
+    ### 记录解 ###
+    def record_solution(state, res)
+      res << state.dup
+    end
 
-    [class]{}-[func]{is_valid}
+    ### 判断在当前状态下，该选择是否合法 ###
+    def is_valid?(state, choice)
+      choice && choice.val != 3
+    end
 
-    [class]{}-[func]{make_choice}
+    ### 更新状态 ###
+    def make_choice(state, choice)
+      state << choice
+    end
 
-    [class]{}-[func]{undo_choice}
+    ### 恢复状态 ###
+    def undo_choice(state, choice)
+      state.pop
+    end
 
-    [class]{}-[func]{backtrack}
+    ### 回溯算法：例题三 ###
+    def backtrack(state, choices, res)
+      # 检查是否为解
+      record_solution(state, res) if is_solution?(state)
+
+      # 遍历所有选择
+      for choice in choices
+        # 剪枝：检查选择是否合法
+        if is_valid?(state, choice)
+          # 尝试：做出选择，更新状态
+          make_choice(state, choice)
+          # 进行下一轮选择
+          backtrack(state, [choice.left, choice.right], res)
+          # 回退：撤销选择，恢复到之前的状态
+          undo_choice(state, choice)
+        end
+      end
+    end
     ```
 
 === "Zig"

docs/chapter_backtracking/n_queens_problem.md

@@ -710,9 +710,45 @@ comments: true
 === "Ruby"
 
     ```ruby title="n_queens.rb"
-    [class]{}-[func]{backtrack}
+    ### 回溯算法：n 皇后 ###
+    def backtrack(row, n, state, res, cols, diags1, diags2)
+      # 当放置完所有行时，记录解
+      if row == n
+        res << state.map { |row| row.dup }
+        return
+      end
 
-    [class]{}-[func]{n_queens}
+      # 遍历所有列
+      for col in 0...n
+        # 计算该格子对应的主对角线和次对角线
+        diag1 = row - col + n - 1
+        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
+        end
+      end
+    end
+
+    ### 求解 n 皇后 ###
+    def n_queens(n)
+      # 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
+      state = Array.new(n) { Array.new(n, "#") }
+      cols = Array.new(n, false) # 记录列是否有皇后
+      diags1 = Array.new(2 * n - 1, false) # 记录主对角线上是否有皇后
+      diags2 = Array.new(2 * n - 1, false) # 记录次对角线上是否有皇后
+      res = []
+      backtrack(0, n, state, res, cols, diags1, diags2)
+
+      res
+    end
     ```
 
 === "Zig"

docs/chapter_backtracking/permutations_problem.md

@@ -506,9 +506,36 @@ comments: true
 === "Ruby"
 
     ```ruby title="permutations_i.rb"
-    [class]{}-[func]{backtrack}
+    ### 回溯算法：全排列 I ###
+    def backtrack(state, choices, selected, res)
+      # 当状态长度等于元素数量时，记录解
+      if state.length == choices.length
+        res << state.dup
+        return
+      end
 
-    [class]{}-[func]{permutations_i}
+      # 遍历所有选择
+      choices.each_with_index do |choice, i|
+        # 剪枝：不允许重复选择元素
+        unless selected[i]
+          # 尝试：做出选择，更新状态
+          selected[i] = true
+          state << choice
+          # 进行下一轮选择
+          backtrack(state, choices, selected, res)
+          # 回退：撤销选择，恢复到之前的状态
+          selected[i] = false
+          state.pop
+        end
+      end
+    end
+
+    ### 全排列 I ###
+    def permutations_i(nums)
+      res = []
+      backtrack([], nums, Array.new(nums.length, false), res)
+      res
+    end
     ```
 
 === "Zig"
@@ -1032,9 +1059,38 @@ comments: true
 === "Ruby"
 
     ```ruby title="permutations_ii.rb"
-    [class]{}-[func]{backtrack}
+    ### 回溯算法：全排列 II ###
+    def backtrack(state, choices, selected, res)
+      # 当状态长度等于元素数量时，记录解
+      if state.length == choices.length
+        res << state.dup
+        return
+      end
 
-    [class]{}-[func]{permutations_ii}
+      # 遍历所有选择
+      duplicated = Set.new
+      choices.each_with_index do |choice, i|
+        # 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
+        if !selected[i] && !duplicated.include?(choice)
+          # 尝试：做出选择，更新状态
+          duplicated.add(choice)
+          selected[i] = true
+          state << choice
+          # 进行下一轮选择
+          backtrack(state, choices, selected, res)
+          # 回退：撤销选择，恢复到之前的状态
+          selected[i] = false
+          state.pop
+        end
+      end
+    end
+
+    ### 全排列 II ###
+    def permutations_ii(nums)
+      res = []
+      backtrack([], nums, Array.new(nums.length, false), res)
+      res
+    end
     ```
 
 === "Zig"

docs/chapter_backtracking/subset_sum_problem.md

@@ -470,9 +470,35 @@ comments: true
 === "Ruby"
 
     ```ruby title="subset_sum_i_naive.rb"
-    [class]{}-[func]{backtrack}
+    ### 回溯算法：子集和 I ###
+    def backtrack(state, target, total, choices, res)
+      # 子集和等于 target 时，记录解
+      if total == target
+        res << state.dup
+        return
+      end
 
-    [class]{}-[func]{subset_sum_i_naive}
+      # 遍历所有选择
+      for i in 0...choices.length
+        # 剪枝：若子集和超过 target ，则跳过该选择
+        next if total + choices[i] > target
+        # 尝试：做出选择，更新元素和 total
+        state << choices[i]
+        # 进行下一轮选择
+        backtrack(state, target, total + choices[i], choices, res)
+        # 回退：撤销选择，恢复到之前的状态
+        state.pop
+      end
+    end
+
+    ### 求解子集和 I（包含重复子集）###
+    def subset_sum_i_naive(nums, target)
+      state = [] # 状态（子集）
+      total = 0 # 子集和
+      res = [] # 结果列表（子集列表）
+      backtrack(state, target, total, nums, res)
+      res
+    end
     ```
 
 === "Zig"
@@ -1011,9 +1037,37 @@ comments: true
 === "Ruby"
 
     ```ruby title="subset_sum_i.rb"
-    [class]{}-[func]{backtrack}
+    ### 回溯算法：子集和 I ###
+    def backtrack(state, target, choices, start, res)
+      # 子集和等于 target 时，记录解
+      if target.zero?
+        res << state.dup
+        return
+      end
+      # 遍历所有选择
+      # 剪枝二：从 start 开始遍历，避免生成重复子集
+      for i in start...choices.length
+        # 剪枝一：若子集和超过 target ，则直接结束循环
+        # 这是因为数组已排序，后边元素更大，子集和一定超过 target
+        break if target - choices[i] < 0
+        # 尝试：做出选择，更新 target, start
+        state << choices[i]
+        # 进行下一轮选择
+        backtrack(state, target - choices[i], choices, i, res)
+        # 回退：撤销选择，恢复到之前的状态
+        state.pop
+      end
+    end
 
-    [class]{}-[func]{subset_sum_i}
+    ### 求解子集和 I ###
+    def subset_sum_i(nums, target)
+      state = [] # 状态（子集）
+      nums.sort! # 对 nums 进行排序
+      start = 0 # 遍历起始点
+      res = [] # 结果列表（子集列表）
+      backtrack(state, target, nums, start, res)
+      res
+    end
     ```
 
 === "Zig"
@@ -1598,9 +1652,41 @@ comments: true
 === "Ruby"
 
     ```ruby title="subset_sum_ii.rb"
-    [class]{}-[func]{backtrack}
+    ### 回溯算法：子集和 II ###
+    def backtrack(state, target, choices, start, res)
+      # 子集和等于 target 时，记录解
+      if target.zero?
+        res << state.dup
+        return
+      end
 
-    [class]{}-[func]{subset_sum_ii}
+      # 遍历所有选择
+      # 剪枝二：从 start 开始遍历，避免生成重复子集
+      # 剪枝三：从 start 开始遍历，避免重复选择同一元素
+      for i in start...choices.length
+        # 剪枝一：若子集和超过 target ，则直接结束循环
+        # 这是因为数组已排序，后边元素更大，子集和一定超过 target
+        break if target - choices[i] < 0
+        # 剪枝四：如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
+        next if i > start && choices[i] == choices[i - 1]
+        # 尝试：做出选择，更新 target, start
+        state << choices[i]
+        # 进行下一轮选择
+        backtrack(state, target - choices[i], choices, i + 1, res)
+        # 回退：撤销选择，恢复到之前的状态
+        state.pop
+      end
+    end
+
+    ### 求解子集和 II ###
+    def subset_sum_ii(nums, target)
+      state = [] # 状态（子集）
+      nums.sort! # 对 nums 进行排序
+      start = 0 # 遍历起始点
+      res = [] # 结果列表（子集列表）
+      backtrack(state, target, nums, start, res)
+      res
+    end
     ```
 
 === "Zig"

docs/chapter_divide_and_conquer/binary_search_recur.md

@@ -331,7 +331,7 @@ comments: true
         if i > j {
             return -1;
         }
-        let m: i32 = (i + j) / 2;
+        let m: i32 = i + (j - i) / 2;
         if nums[m as usize] < target {
             // 递归子问题 f(m+1, j)
             return dfs(nums, target, m + 1, j);

docs/chapter_hashing/hash_collision.md

@@ -2896,7 +2896,7 @@ comments: true
         hashMap->capacity = 4;
         hashMap->loadThres = 2.0 / 3.0;
         hashMap->extendRatio = 2;
-        hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);
+        hashMap->buckets = (Pair **)calloc(hashMap->capacity, sizeof(Pair *));
         hashMap->TOMBSTONE = (Pair *)malloc(sizeof(Pair));
         hashMap->TOMBSTONE->key = -1;
         hashMap->TOMBSTONE->val = "-1";
@@ -3015,7 +3015,7 @@ comments: true
         int oldCapacity = hashMap->capacity;
         // 初始化扩容后的新哈希表
         hashMap->capacity *= hashMap->extendRatio;
-        hashMap->buckets = (Pair **)malloc(sizeof(Pair *) * hashMap->capacity);
+        hashMap->buckets = (Pair **)calloc(hashMap->capacity, sizeof(Pair *));
         hashMap->size = 0;
         // 将键值对从原哈希表搬运至新哈希表
         for (int i = 0; i < oldCapacity; i++) {

docs/chapter_sorting/merge_sort.md

@@ -99,7 +99,7 @@ comments: true
         if left >= right:
             return  # 当子数组长度为 1 时终止递归
         # 划分阶段
-        mid = (left + right) // 2  # 计算中点
+        mid = (left + right) // 2 # 计算中点
         merge_sort(nums, left, mid)  # 递归左子数组
         merge_sort(nums, mid + 1, right)  # 递归右子数组
         # 合并阶段
@@ -142,7 +142,7 @@ comments: true
         if (left >= right)
             return; // 当子数组长度为 1 时终止递归
         // 划分阶段
-        int mid = (left + right) / 2;    // 计算中点
+        int mid = left + (right - left) / 2;    // 计算中点
         mergeSort(nums, left, mid);      // 递归左子数组
         mergeSort(nums, mid + 1, right); // 递归右子数组
         // 合并阶段
@@ -186,7 +186,7 @@ comments: true
         if (left >= right)
             return; // 当子数组长度为 1 时终止递归
         // 划分阶段
-        int mid = (left + right) / 2; // 计算中点
+        int mid = left + (right - left) / 2; // 计算中点
         mergeSort(nums, left, mid); // 递归左子数组
         mergeSort(nums, mid + 1, right); // 递归右子数组
         // 合并阶段
@@ -229,7 +229,7 @@ comments: true
         // 终止条件
         if (left >= right) return;       // 当子数组长度为 1 时终止递归
         // 划分阶段
-        int mid = (left + right) / 2;    // 计算中点
+        int mid = left + (right - left) / 2;    // 计算中点
         MergeSort(nums, left, mid);      // 递归左子数组
         MergeSort(nums, mid + 1, right); // 递归右子数组
         // 合并阶段
@@ -282,7 +282,7 @@ comments: true
             return
         }
         // 划分阶段
-        mid := (left + right) / 2
+        mid := left + (right - left) / 2
         mergeSort(nums, left, mid)
         mergeSort(nums, mid+1, right)
         // 合并阶段
@@ -335,7 +335,7 @@ comments: true
             return
         }
         // 划分阶段
-        let mid = (left + right) / 2 // 计算中点
+        let mid = left + (right - left) / 2 // 计算中点
         mergeSort(nums: &nums, left: left, right: mid) // 递归左子数组
         mergeSort(nums: &nums, left: mid + 1, right: right) // 递归右子数组
         // 合并阶段
@@ -381,7 +381,7 @@ comments: true
         // 终止条件
         if (left >= right) return; // 当子数组长度为 1 时终止递归
         // 划分阶段
-        let mid = Math.floor((left + right) / 2); // 计算中点
+        let mid = Math.floor(left + (right - left) / 2); // 计算中点
         mergeSort(nums, left, mid); // 递归左子数组
         mergeSort(nums, mid + 1, right); // 递归右子数组
         // 合并阶段
@@ -427,7 +427,7 @@ comments: true
         // 终止条件
         if (left >= right) return; // 当子数组长度为 1 时终止递归
         // 划分阶段
-        let mid = Math.floor((left + right) / 2); // 计算中点
+        let mid = Math.floor(left + (right - left) / 2); // 计算中点
         mergeSort(nums, left, mid); // 递归左子数组
         mergeSort(nums, mid + 1, right); // 递归右子数组
         // 合并阶段
@@ -470,7 +470,7 @@ comments: true
       // 终止条件
       if (left >= right) return; // 当子数组长度为 1 时终止递归
       // 划分阶段
-      int mid = (left + right) ~/ 2; // 计算中点
+      int mid = left + (right - left) ~/ 2; // 计算中点
       mergeSort(nums, left, mid); // 递归左子数组
       mergeSort(nums, mid + 1, right); // 递归右子数组
       // 合并阶段
@@ -525,7 +525,7 @@ comments: true
         }
 
         // 划分阶段
-        let mid = (left + right) / 2; // 计算中点
+        let mid = left + (right - left) / 2; // 计算中点
         merge_sort(nums, left, mid); // 递归左子数组
         merge_sort(nums, mid + 1, right); // 递归右子数组
 
@@ -574,7 +574,7 @@ comments: true
         if (left >= right)
             return; // 当子数组长度为 1 时终止递归
         // 划分阶段
-        int mid = (left + right) / 2;    // 计算中点
+        int mid = left + (right - left) / 2;    // 计算中点
         mergeSort(nums, left, mid);      // 递归左子数组
         mergeSort(nums, mid + 1, right); // 递归右子数组
         // 合并阶段
@@ -598,7 +598,7 @@ comments: true
         while (i <= mid && j <= right) {
             if (nums[i] <= nums[j])
                 tmp[k++] = nums[i++]
-            else 
+            else
                 tmp[k++] = nums[j++]
         }
         // 将左子数组和右子数组的剩余元素复制到临时数组中
@@ -619,7 +619,7 @@ comments: true
         // 终止条件
         if (left >= right) return  // 当子数组长度为 1 时终止递归
         // 划分阶段
-        val mid = (left + right) / 2 // 计算中点
+        val mid = left + (right - left) / 2 // 计算中点
         mergeSort(nums, left, mid) // 递归左子数组
         mergeSort(nums, mid + 1, right) // 递归右子数组
         // 合并阶段
@@ -671,7 +671,7 @@ comments: true
       # 当子数组长度为 1 时终止递归
       return if left >= right
       # 划分阶段
-      mid = (left + right) / 2 # 计算中点
+      mid = left + (right - left) / 2 # 计算中点
       merge_sort(nums, left, mid) # 递归左子数组
       merge_sort(nums, mid + 1, right) # 递归右子数组
       # 合并阶段
@@ -692,10 +692,10 @@ comments: true
         const mem_allocator = mem_arena.allocator();
         var tmp = try mem_allocator.alloc(i32, right + 1 - left);
         std.mem.copy(i32, tmp, nums[left..right+1]);
-        // 左子数组的起始索引和结束索引  
+        // 左子数组的起始索引和结束索引
         var leftStart = left - left;
         var leftEnd = mid - left;
-        // 右子数组的起始索引和结束索引       
+        // 右子数组的起始索引和结束索引
         var rightStart = mid + 1 - left;
         var rightEnd = right - left;
         // i, j 分别指向左子数组、右子数组的首元素
@@ -725,7 +725,7 @@ comments: true
         // 终止条件
         if (left >= right) return;              // 当子数组长度为 1 时终止递归
         // 划分阶段
-        var mid = (left + right) / 2;           // 计算中点
+        var mid = left + (right - left) / 2;    // 计算中点
         try mergeSort(nums, left, mid);         // 递归左子数组
         try mergeSort(nums, mid + 1, right);    // 递归右子数组
         // 合并阶段

docs/chapter_sorting/quick_sort.md

@@ -861,7 +861,7 @@ comments: true
     /* 哨兵划分（三数取中值） */
     func partitionMedian(nums: inout [Int], left: Int, right: Int) -> Int {
         // 选取三个候选元素的中位数
-        let med = medianThree(nums: nums, left: left, mid: (left + right) / 2, right: right)
+        let med = medianThree(nums: nums, left: left, mid: left + (right - left) / 2, right: right)
         // 将中位数交换至数组最左端
         nums.swapAt(left, med)
         return partition(nums: &nums, left: left, right: right)

docs/chapter_sorting/radix_sort.md

@@ -545,9 +545,7 @@ $$
             counter[d] -= 1; // 将 d 的数量减 1
         }
         // 使用结果覆盖原数组 nums
-        for i in 0..n {
-            nums[i] = res[i];
-        }
+        nums.copy_from_slice(&res);
     }
 
     /* 基数排序 */