build

chapter_backtracking/backtracking_algorithm.md

@@ -620,14 +620,14 @@ comments: true
 
 为了更清晰地分析算法问题，我们总结一下回溯算法中常用术语的含义，并对照例题三给出对应示例。
 
-| 名词                | 定义                                                         | 例题三                                                   |
+| 名词                | 定义                                                                                                   | 例题三                                                               |
-| ------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| ------------------- | ------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
-| 解 Solution         | 解是满足问题特定条件的答案。回溯算法的目标是找到一个或多个满足条件的解 | 根节点到节点 $7$ 的所有路径，且路径中不包含值为 $3$ 的节点   |
+| 解 Solution         | 解是满足问题特定条件的答案。回溯算法的目标是找到一个或多个满足条件的解                                 | 根节点到节点 $7$ 的所有路径，且路径中不包含值为 $3$ 的节点           |
-| 状态 State          | 状态表示问题在某一时刻的情况，包括已经做出的选择             | 当前已访问的节点路径，即 `path` 节点列表                     |
+| 状态 State          | 状态表示问题在某一时刻的情况，包括已经做出的选择                                                       | 当前已访问的节点路径，即 `path` 节点列表                             |
-| 约束条件 Constraint | 约束条件是问题中限制解的可行性的条件，通常用于剪枝           | 要求路径中不能包含值为 $3$ 的节点                            |
+| 约束条件 Constraint | 约束条件是问题中限制解的可行性的条件，通常用于剪枝                                                     | 要求路径中不能包含值为 $3$ 的节点                                    |
 | 尝试 Attempt        | 尝试是在搜索过程中，根据当前状态和可用选择来探索解空间的过程。尝试包括做出选择，更新状态，检查是否为解 | 递归访问左（右）子节点，将节点添加进 `path` ，判断节点的值是否为 $7$ |
-| 回退 Backtracking   | 回退指在搜索中遇到到不满足约束条件或无法继续搜索的状态时，撤销前面做出的选择，回到上一个状态 | 当越过叶结点、结束结点访问、遇到值为 $3$ 的节点时终止搜索，函数返回 |
+| 回退 Backtracking   | 回退指在搜索中遇到到不满足约束条件或无法继续搜索的状态时，撤销前面做出的选择，回到上一个状态           | 当越过叶结点、结束结点访问、遇到值为 $3$ 的节点时终止搜索，函数返回  |
-| 剪枝 Pruning        | 剪枝是根据问题特性和约束条件避免无意义的搜索路径的方法，可提高搜索效率 | 当遇到值为 $3$ 的节点时，则终止继续搜索                      |
+| 剪枝 Pruning        | 剪枝是根据问题特性和约束条件避免无意义的搜索路径的方法，可提高搜索效率                                 | 当遇到值为 $3$ 的节点时，则终止继续搜索                              |
 
 !!! tip
 
@@ -1370,4 +1370,6 @@ comments: true
 - 旅行商问题：在一个图中，从一个点出发，访问所有其他点恰好一次后返回起点，求最短路径。
 - 最大团问题：给定一个无向图，找到最大的完全子图，即子图中的任意两个顶点之间都有边相连。
 
-在接下来的章节中，我们将一起攻克几个经典的回溯算法问题。
+请注意，回溯算法通常不是解决组合优化问题的最优方法。0-1 背包问题通常使用动态规划解决；旅行商是一个 NP-Hard 问题，常见的算法有遗传算法和蚁群算法等；最大团问题是图轮中的一个经典 NP-Hard 问题，通常用贪心算法等启发式算法来解决。
+
+在接下来的章节中，我们将一起探讨几个经典的回溯算法问题：全排列、子集和、$n$ 皇后。

chapter_hashing/hash_algorithm.md

@@ -52,25 +52,91 @@ index = hash(key) % capacity
 === "Java"
 
     ```java title="simple_hash.java"
-    [class]{simple_hash}-[func]{addHash}
+    /* 加法哈希 */
+    int addHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
 
-    [class]{simple_hash}-[func]{mulHash}
+    /* 乘法哈希 */
+    int mulHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = (31 * hash + (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
 
-    [class]{simple_hash}-[func]{xorHash}
+    /* 异或哈希 */
+    int xorHash(String key) {
+        int hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            System.out.println((int)c);
+            hash ^= (int) c;
+        }
+        return hash & MODULUS;
+    }
 
-    [class]{simple_hash}-[func]{rotHash}
+    /* 旋转哈希 */
+    int rotHash(String key) {
+        long hash = 0;
+        final int MODULUS = 1000000007;
+        for (char c : key.toCharArray()) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (int) c) % MODULUS;
+        }
+        return (int) hash;
+    }
     ```
 
 === "C++"
 
     ```cpp title="simple_hash.cpp"
-    [class]{}-[func]{addHash}
+    /* 加法哈希 */
+    int addHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = (hash + (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
 
-    [class]{}-[func]{mulHash}
+    /* 乘法哈希 */
+    int mulHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = (31 * hash + (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
 
-    [class]{}-[func]{xorHash}
+    /* 异或哈希 */
+    int xorHash(string key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            cout<<(int)c<<endl;
+            hash ^= (int)c;
+        }
+        return hash & MODULUS;
+    }
 
-    [class]{}-[func]{rotHash}
+    /* 旋转哈希 */
+    int rotHash(string key) {
+        long long hash = 0;
+        const int MODULUS = 1000000007;
+        for (unsigned char c : key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ (int)c) % MODULUS;
+        }
+        return (int)hash;
+    }
     ```
 
 === "Python"
@@ -241,13 +307,13 @@ $$
 
 直至目前，MD5 和 SHA-1 已多次被成功攻击，因此它们被各类安全应用弃用。SHA-2 系列中的 SHA-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常被用在各类安全应用与协议中。SHA-3 相较 SHA-2 的实现开销更低、计算效率更高，但目前使用覆盖度不如 SHA-2 系列。
 
-|          | MD5                            | SHA-1                | SHA-2                        | SHA-3                |
+|          | MD5                            | SHA-1            | SHA-2                        | SHA-3                |
-| -------- | ------------------------------ | -------------------- | ---------------------------- | -------------------- |
+| -------- | ------------------------------ | ---------------- | ---------------------------- | -------------------- |
-| 推出时间 | 1992                           | 1995                 | 2002                         | 2008                 |
+| 推出时间 | 1992                           | 1995             | 2002                         | 2008                 |
-| 输出长度 | 128 bits                       | 160 bits             | 256 / 512 bits               | 224/256/384/512 bits |
+| 输出长度 | 128 bits                       | 160 bits         | 256 / 512 bits               | 224/256/384/512 bits |
-| 哈希冲突 | 较多                           | 较多                 | 很少                         | 很少                 |
+| 哈希冲突 | 较多                           | 较多             | 很少                         | 很少                 |
-| 安全等级 | 低，已被成功攻击           | 低，已被成功攻击 | 高                           | 高                   |
+| 安全等级 | 低，已被成功攻击               | 低，已被成功攻击 | 高                           | 高                   |
-| 应用     | 已被弃用，仍用于数据完整性检查 | 已被弃用             | 加密货币交易验证、数字签名等 | 可用于替代 SHA-2     |
+| 应用     | 已被弃用，仍用于数据完整性检查 | 已被弃用         | 加密货币交易验证、数字签名等 | 可用于替代 SHA-2     |
 
 ## 6.3.4. &nbsp; 数据结构的哈希值
 
@@ -258,16 +324,59 @@ $$
 - 元组的哈希值是对其中每一个元素进行哈希，然后将这些哈希值组合起来，得到单一的哈希值。
 - 对象的哈希值基于其内存地址生成。通过重写对象的哈希方法，可实现基于内容生成哈希值。
 
+!!! tip
+
+    请注意，不同编程语言的内置哈希值计算函数的定义和方法不同。
+
 === "Java"
 
     ```java title="built_in_hash.java"
+    int num = 3;
+    int hashNum = Integer.hashCode(num);
+    // 整数 3 的哈希值为 3
 
+    boolean bol = true;
+    int hashBol = Boolean.hashCode(bol);
+    // 布尔量 true 的哈希值为 1231
+
+    double dec = 3.14159;
+    int hashDec = Double.hashCode(dec);
+    // 小数 3.14159 的哈希值为 -1340954729
+
+    String str = "Hello 算法";
+    int hashStr = str.hashCode();
+    // 字符串 Hello 算法 的哈希值为 -727081396
+
+    Object[] arr = { 12836, "小哈" };
+    int hashTup = Arrays.hashCode(arr);
+    // 数组 [12836, 小哈] 的哈希值为 1151158
+
+    ListNode obj = new ListNode(0);
+    int hashObj = obj.hashCode();
+    // 节点对象 utils.ListNode@7dc5e7b4 的哈希值为 2110121908
     ```
 
 === "C++"
 
     ```cpp title="built_in_hash.cpp"
+    int num = 3;
+    size_t hashNum = hash<int>()(num);
+    // 整数 3 的哈希值为 3
 
+    bool bol = true;
+    size_t hashBol = hash<bool>()(bol);
+    // 布尔量 1 的哈希值为 1
+
+    double dec = 3.14159;
+    size_t hashDec = hash<double>()(dec);
+    // 小数 3.14159 的哈希值为 4614256650576692846
+
+    string str = "Hello 算法";
+    size_t hashStr = hash<string>()(str);
+    // 字符串 Hello 算法 的哈希值为 15466937326284535026
+
+    // 在 C++ 中，内置 std:hash() 仅提供基本数据类型的哈希值计算
+    // 数组、对象的哈希值计算需要自行实现
     ```
 
 === "Python"