xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-27 00:46:29 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

build

Browse source
This commit is contained in:
krahets 2023-06-21 19:26:10 +08:00
parent 3a630c2887
commit 17e19ea4fe
2 changed files with 134 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
chapter_backtracking/backtracking_algorithm.md
View file

@ -621,7 +621,7 @@ comments: true
为了更清晰地分析算法问题，我们总结一下回溯算法中常用术语的含义，并对照例题三给出对应示例。
| 名词 | 定义 | 例题三 |
| ------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| ------------------- | ------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
| 解 Solution | 解是满足问题特定条件的答案。回溯算法的目标是找到一个或多个满足条件的解 | 根节点到节点 $7$ 的所有路径，且路径中不包含值为 $3$ 的节点 |
| 状态 State | 状态表示问题在某一时刻的情况，包括已经做出的选择 | 当前已访问的节点路径，即 `path` 节点列表 |
| 约束条件 Constraint | 约束条件是问题中限制解的可行性的条件，通常用于剪枝 | 要求路径中不能包含值为 $3$ 的节点 |
@ -1370,4 +1370,6 @@ comments: true
- 旅行商问题：在一个图中，从一个点出发，访问所有其他点恰好一次后返回起点，求最短路径。
- 最大团问题：给定一个无向图，找到最大的完全子图，即子图中的任意两个顶点之间都有边相连。
在接下来的章节中，我们将一起攻克几个经典的回溯算法问题。
请注意，回溯算法通常不是解决组合优化问题的最优方法。0-1 背包问题通常使用动态规划解决；旅行商是一个 NP-Hard 问题，常见的算法有遗传算法和蚁群算法等；最大团问题是图轮中的一个经典 NP-Hard 问题，通常用贪心算法等启发式算法来解决。
在接下来的章节中，我们将一起探讨几个经典的回溯算法问题：全排列、子集和、$n$ 皇后。

127
chapter_hashing/hash_algorithm.md
View file

@ -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"
@ -242,7 +308,7 @@ $$
直至目前，MD5 和 SHA-1 已多次被成功攻击，因此它们被各类安全应用弃用。SHA-2 系列中的 SHA-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常被用在各类安全应用与协议中。SHA-3 相较 SHA-2 的实现开销更低、计算效率更高，但目前使用覆盖度不如 SHA-2 系列。
| | MD5 | SHA-1 | SHA-2 | SHA-3 |
| -------- | ------------------------------ | -------------------- | ---------------------------- | -------------------- |
| -------- | ------------------------------ | ---------------- | ---------------------------- | -------------------- |
| 推出时间 | 1992 | 1995 | 2002 | 2008 |
| 输出长度 | 128 bits | 160 bits | 256 / 512 bits | 224/256/384/512 bits |
| 哈希冲突 | 较多 | 较多 | 很少 | 很少 |
@ -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"