CSP-J/S 复赛算法 并查集-Hash表

---

前言

在算法竞赛中，数据结构的灵活运用常常是制胜的关键，尤其是在复杂的题目中，合适的数据结构选择能够显著提高问题的解题效率。并查集（Union-Find）是一种常见且高效的数据结构，常用于解决动态连通性问题，而哈希表（Hash Table）则能够在常数时间内完成插入、删除和查找操作，广泛应用于各种需要高效查找的场景。在 CSP-J/S 复赛等高水平算法竞赛中，往往会出现结合并查集和哈希表的题目，通过这两种数据结构的协同配合解决图论、集合和查询等问题。

本篇文章将讨论如何在实际竞赛题目中使用并查集和哈希表，介绍它们的基本原理以及常见的应用场景，并通过实例展示如何巧妙运用这两种数据结构来提高算法的效率，帮助参赛选手在竞赛中获得优势。

---

并查集

并查集是什么？

并查集（Union-Find）是一种非常实用的数据结构，主要用于处理一些不相交的集合（也就是不重叠的组）。它可以高效地支持两个基本操作：

1. 合并（Union）：将两个集合合并成一个集合。
2. 查找（Find）：确定某个元素属于哪个集合。

可以把并查集想象成一个有很多“箱子”的工具，每个“箱子”里可以装很多物品（元素），并且每个物品都有一个标签（代表它属于哪个集合）。你可以把两个箱子合并成一个，也可以查看某个物品在哪个箱子里。

并查集的应用

并查集的应用非常广泛，特别是在图论和网络连接等领域。以下是一些常见的应用场景：

1. 网络连接：判断两个节点是否在同一个网络中，比如判断两个城市之间是否有直接的航班。
2. 社交网络：找出朋友之间的关系，比如判断两个人是否属于同一个朋友圈。
3. 连通性问题：在图中判断是否可以通过边连接到不同的节点。
4. 动态连通性：在不断添加边的情况下，实时判断两个节点是否连通。

举几个并查集的例子

1. 社交网络问题：

   • 假设你有一些朋友，朋友之间可以相互推荐。通过并查集，你可以很容易地判断某个人是否在你的朋友圈中。比如，Alice 和 Bob 是朋友，Bob 和 Charlie 也是朋友，那么 Alice 和 Charlie 也是间接朋友。

2. 网络连通性：

   • 在一个城市网络中，有一些直接的道路连接着城市。如果你想知道从城市 A 到城市 B 是否可达，你可以使用并查集。在每次修建新道路（合并两个城市）时，只需将这两个城市合并为一个集合，然后通过查找操作判断它们是否在同一个集合中。

3. 集合合并：

   • 假设有多个组的学生，你希望了解哪些学生属于同一个小组。通过并查集，你可以快速合并不同的小组，并在任何时候快速查询某个学生的组别。

更加详细的介绍

是的，你的理解是正确的！在并查集中，当我们把两个集合合并在一起时，意味着它们之间有关系。以下是更详细的解释：

合并两个集合

• 合并操作（Union）：当我们把两个集合合并时，比如集合 A 和集合 B，就会形成一个新的集合，这个新集合包含了 A 和 B 中的所有元素。

  • 比如，集合 A = {1, 2} 和集合 B = {3, 4}，合并后得到的新集合是 {1, 2, 3, 4}。

判断元素的关系

• 查找操作（Find）：每个元素在并查集中都有一个代表或“根”，通过查找操作可以确定某个元素属于哪个集合。

  • 如果元素 x 和元素 y 的根相同，说明它们属于同一个集合，这意味着它们之间是有关系的。

  • 例如，如果你查找元素 2，发现它的根是 A，那么你知道元素 2 属于集合 A。如果你再查找元素 3，发现它的根是 B，你就知道元素 2 和元素 3 是不属于同一个集合的。

并查集在树中的表示方法

并查集在树中的表示

并查集（Union-Find）是一种用于处理不相交集合的数据结构，常常通过树形结构来表示。每个节点代表一个元素，节点之间通过父节点（parent）链接起来，从而形成树的结构。

概念

1. 节点：树中的每个节点表示一个元素。在并查集中，节点的值通常是元素本身。

2. 父节点（Parent）：每个节点都有一个指向其父节点的指针。根节点的父节点指向自己，表示它是这个集合的代表。

3. 根节点（Root）：树的顶端节点，代表整个集合。通过查找操作可以快速找到某个元素所属的集合的根节点。

4. 路径压缩（Path Compression）：在执行查找操作时，沿途的节点都指向根节点，以加快未来的查找速度。

字符串图示例

假设我们有 5 个元素（0 到 4），初始状态下每个元素都是独立的集合：

初始状态

0      1      2      3      4
|      |      |      |      |
null   null   null   null   null

在树形结构中表示为：

  0        1        2        3        4
 /        /        /        /        /
null     null     null     null     null

合并操作示例

假设我们依次执行以下合并操作：

1. 合并 0 和 1（Union(0, 1)）：

   0
  /
 1      2      3      4
 |      |      |      |
null   null   null   null

2. 合并 1 和 2（Union(1, 2)）：

   0
  /
 1
 |
 2      3      4
 |      |      |
null   null   null

3. 合并 3 和 4（Union(3, 4)）：

   0
  /
 1
 |
 2      3
 |      |
null   null
         |
         4

最终结构

经过这些合并操作后，最终的结构可能如下所示：

    0
   /
  1
  |
  2      3
  |      |
null    null
          |
          4

查找操作和路径压缩示例

当执行查找操作 Find(4) 时，路径可能如下：

1. 从 4 查找其父节点，找到 3。
2. 从 3 查找其父节点，找到 0。

为了加速下一次查找，路径压缩会将节点 3 的父节点直接指向根节点 0，最终结构变为：

    0
   / \
  1   3
 |   /
2   4

并查集的工作原理

这个并查集就是构造树，然后通过查找root来判断是否在一个集合里面

1. 树的结构：在并查集中，每个元素都被视为树中的一个节点。所有节点通过父指针（parent pointer）连接，形成一棵树。每个集合都有一个根节点，根节点代表了这个集合。

2. 查找操作：当我们想知道某个元素是否属于某个集合时，我们可以通过查找操作找到这个元素的根节点。只需不断查找父节点，直到找到根节点。这个根节点标识了该元素所在的集合。

   • 例如，如果我们要查找元素 4，经过查找，我们可能会从 4 找到 3，再找到 0，最终发现根节点是 0。由此我们可以得知元素 4 属于以 0 为根的集合。

3. 合并操作：当我们需要将两个集合合并时，我们可以将一个集合的根节点的父节点指向另一个集合的根节点。这样，两个集合就通过根节点连接在一起了。

4. 路径压缩：为了提高效率，查找操作时可以进行路径压缩。即在查找过程中，将沿途的节点直接连接到根节点，这样下一次查找时，可以更快地找到根节点。

判断元素是否在同一个集合

通过查找根节点的方式，我们可以方便地判断两个元素是否属于同一个集合。具体步骤如下：

• 对于元素 A 和元素 B，分别执行查找操作 Find(A) 和 Find(B)。
• 如果两个操作的结果（根节点）相同，则元素 A 和元素 B 属于同一个集合。
• 如果根节点不同，则它们不在同一个集合中。

Hash表

哈希函数

什么是哈希函数？

哈希函数是一种将输入数据（通常是字符串或文件）转换为固定长度的散列值（哈希值）的函数。这个散列值是一个唯一的数字，用于表示原始数据。哈希函数的特点是相同的输入总是会产生相同的输出，而不同的输入通常会产生不同的输出。

哈希函数的作用

哈希函数在计算机科学中有很多重要的用途，主要包括：

1. 数据存储与检索：哈希函数常用于数据结构，如哈希表（Hash Table），它通过将数据映射到一个特定的索引（位置）来加速数据的查找、插入和删除操作。

2. 数据完整性验证：在数据传输中，哈希函数可以用来生成数据的唯一标识符，以便在接收时验证数据的完整性。

3. 加密：在密码学中，哈希函数用于确保数据的安全性，通过生成不可逆的哈希值，保护用户的敏感信息。

映射的概念

哈希函数的核心作用就是“映射”。它把输入的数据（例如字符串）映射到一个哈希值。例如，假设我们有一个简单的字符串：

输入： "hello"

使用某个哈希函数后，可能得到的输出是：

哈希值： 5d41402abc4b2a76b9719d911017c592

在这个例子中，“hello”被映射到了一个特定的哈希值。哈希函数的目的是将不同的输入映射到一个相对小的范围内，使得我们能够快速找到它们。

示例：哈希表的应用

假设我们有一个学生的姓名和成绩的列表，我们希望能够快速查找某个学生的成绩。我们可以使用哈希表来实现这一功能。

1. 构建哈希表：我们使用学生姓名作为输入，通过哈希函数计算出一个哈希值，然后将成绩存储在这个哈希值对应的位置。

2. 查找成绩：当我们想查找某个学生的成绩时，使用相同的哈希函数将姓名映射到哈希值，然后直接访问哈希表中该位置的成绩。
   

哈希函数的三个基本要求是

1. 确定性（Determinism）

哈希函数必须是确定性的，意思是对于同一个输入，哈希函数每次都要返回相同的输出。这个特性保证了哈希函数的稳定性和可靠性，例如在哈希表中查找数据时，如果两次输入相同的键值，却返回不同的哈希值，哈希表将无法正常工作。

例子：假设输入是 "apple"，那么哈希函数每次都应该返回相同的哈希值，比如 123456，否则哈希表将无法正确检索数据。

2. 高效计算（Efficiency）

哈希函数的计算应该非常快速，不能花费过多的时间或资源。因为哈希函数常用于查找、存储等高频操作场景，效率至关重要。如果哈希函数计算太慢，就无法提升效率，甚至会拖累整个程序的性能。

例子：在大型数据库系统或密码学中，哈希函数需要能够处理大数据集，因此必须在常数时间内给出结果。

3. 冲突最小化（Minimizing Collisions）

虽然不同的输入理论上可能会映射到相同的哈希值，这种现象叫哈希冲突（Hash Collision），但一个好的哈希函数应该尽量减少冲突的发生。理想情况下，每个不同的输入都会产生唯一的哈希值。这有助于提高数据存储和查找的效率，尤其是在哈希表等数据结构中。

例子：如果我们对 "cat" 和 "dog" 计算哈希值，但它们得出了相同的哈希值 123456，就是发生了冲突。哈希函数设计得越好，冲突发生的概率就越低。

---

总结：

1. 确定性：同一输入必须返回相同的输出。
2. 高效计算：哈希计算应尽可能快。
3. 冲突最小化：不同的输入应尽量映射到不同的哈希值。

这三个基本要求确保了哈希函数在数据处理中的准确性、效率和稳定性。如果这三个要求能够得到很好的满足，哈希函数将在多种应用中表现出色，如哈希表、密码学、数据完整性校验等。

解决冲突

哈希冲突是指两个不同的输入通过哈希函数得到了相同的哈希值。为了处理这种情况，有两种常用的方法：开放寻址法和链表法。我们来用通俗易懂的话解释一下它们的原理，并通过简单的字符串图来说明。

1. 开放寻址法（Open Addressing）

概念：
开放寻址法的意思是，当哈希表中某个位置已经被占用时，我们就寻找下一个空闲的位置来存放数据，而不是直接覆盖掉之前的数据。

步骤：

• 首先，用哈希函数找到元素应该存放的位置。
• 如果这个位置已经有其他数据（发生冲突），就按照一定规则（例如从当前位置向后一个个查找）找到下一个空的位置。

类比：
假设我们要将不同的玩具放入一排箱子（代表哈希表），每个玩具有一个编号（代表哈希值）。当我们按照编号要放入玩具时，如果目标箱子被占用，我们就去找附近的空箱子放进去。

示例图：

哈希表： [  _,  _,  _,  _,  _,  _  ]

插入“apple”哈希值是 2：

哈希表： [  _,  _,  apple,  _,  _,  _  ]

插入“banana”哈希值也是 2：

哈希表： [  _,  _,  apple,  banana,  _,  _  ]
           (找到下一个空位)

这里，“banana”本来应该放在位置2，但由于位置2已经有“apple”，我们就找了下一个空位，放在了位置3。这种方式有效地解决了冲突。

2. 链表法（Chaining）

概念：
链表法的意思是，每个哈希表中的位置不再只是存放一个数据，而是变成了一个链表。如果多个元素的哈希值相同，就把它们链接在一起，放在同一个位置。

步骤：

• 当多个元素发生哈希冲突时，不需要找其他位置，而是将它们都存放在同一个链表里。
• 查找时，如果链表里有多个元素，就遍历链表找到目标。

类比：
想象每个箱子（哈希表的位置）里不只是能放一个玩具，而是可以放多个玩具。当多个玩具要放进同一个箱子时，我们依次把它们串联起来放入这个箱子。

示例图：

哈希表： [  _,  _,  _ -> _,  _,  _,  _  ]

插入“apple”哈希值是 2：

哈希表： [  _,  _,  apple -> _,  _,  _,  _  ]

插入“banana”哈希值也是 2：

哈希表： [  _,  _,  apple -> banana,  _,  _,  _  ]
           (用链表存放多个元素)

在这个例子中，“apple”和“banana”有相同的哈希值 2，但我们不用寻找其他空位，而是把它们都放在同一个位置，依次链接起来形成一个链表。

---

总结：

1. 开放寻址法通过寻找空闲位置解决哈希冲突。

   • 优点：不需要额外的内存空间。
   • 缺点：当表快满时，查找速度会变慢。

2. 链表法通过在每个哈希表位置创建一个链表来解决冲突。

   • 优点：查找时不需要搬移数据，冲突的元素直接链接在一起。
   • 缺点：每个位置可能存放多个元素，会使用额外的内存。

这两种方法在处理哈希冲突时各有优劣，实际应用中会根据需求选择合适的方案。如果还想了解具体的代码实现，我也可以帮忙解释！

哈希字符串

字符串哈希是一种将字符串通过特定的算法转换为一个固定长度的数值（通常是整数）的技术。这种数值称为哈希值（hash value），它可以用来快速比较字符串，查找重复的字符串，或在哈希表中进行快速查找操作。哈希函数的核心目标是将任意长度的字符串映射为固定长度的值，同时确保不同的字符串尽量映射到不同的哈希值，以减少冲突。

字符串哈希的作用

1. 快速查找：通过将字符串映射为哈希值，可以实现O(1)的查找速度，常用于哈希表（如C++中的unordered_map、Python中的字典）中。
2. 字符串比较：在比较长字符串时，直接比较哈希值比逐字符比较要快得多。
3. 去重操作：用于检测重复的字符串，例如文本去重、文件完整性校验等。
4. 加密和安全：哈希函数在加密、数字签名等场景中也起到了至关重要的作用（如SHA、MD5等）。

常用的字符串哈希算法

1. 滚动哈希（Rolling Hash）：常用于模式匹配算法中，如 Rabin-Karp 算法。它通过增量计算可以在O(1)时间内更新哈希值。

2. 多项式哈希（Polynomial Hash）：定义如下：

   $$H(s)=s[0]\times p^0+s[1]\times p^1+s[2]\times p^2+\cdots +s[n-1]\times p^{n-1}(\text{mod}M)$$

   其中，$p$ 是一个质数，通常选择31或37，$M$ 是取模的一个大质数，用于防止溢出。

3. MD5/SHA：这些是密码学中的哈希算法，通常用于加密和验证数据的完整性，而不是用于常规的字符串查找。

示例：多项式哈希

假设我们有一个字符串 “abc”，并且选择 $p=31$，$M=10^9+7$，我们计算它的哈希值：

$$H("abc"){=}^{\prime }{a}^{\prime }\times 31^0{+}^{\prime }{b}^{\prime }\times 31^1{+}^{\prime }{c}^{\prime }\times 31^2$$

对应到ASCII码，‘a’ = 97, ‘b’ = 98, ‘c’ = 99：

$$H("abc")=97\times 31^0+98\times 31^1+99\times 31^2=97+98\times 31+99\times 31^2$$

通过哈希值，可以快速处理字符串的查找和比较问题。

---

总结

并查集和哈希表作为竞赛中的高效数据结构，能够应对大量关于集合操作、连通性判断及动态查询的问题。并查集通过路径压缩和按秩合并的优化，使得其复杂度接近常数；而哈希表则为处理离散化、查找等操作提供了接近 O(1) 的性能保障。在竞赛中，将并查集与哈希表相结合可以有效应对那些需要动态维护连通性或进行复杂查询的问题。

通过本文的介绍，读者应掌握如何在不同题目中选择并运用这两种数据结构，以便在高强度的算法竞赛中灵活应对挑战，提升解题速度和正确率。在实际比赛中，充分利用它们的优势，可以在短时间内快速解决复杂的问题，并提升自己的竞赛表现。