c++基础数据结构

基础数据结构

目录

• 线性结构

• 二叉堆

• 并查集

• 哈希表

• 应用举例 一、线性结构 基础知识

• 数组

• 带头结点的双链表

– He a d 结点 : 虚拟头结点

– Fir s t 结点 : 第一个有实际内容的结点

• 队列 : 循环队列与 Open-Close 表 例 1. 最小值

• 实现一个 n 个元素的线性表 A 。每次可以修

改其中一个元素，也可以询问闭区间 [p, q]

中元素的最小值。

• 1<=n,m<=100000 分析

• 利用二级检索的思想

– 设块长为 L, 则一共有 n/L 个块

– 维护数组 B, 保存每个块的最小值

• Modify(x, y)

– A[x] = y O(1)

– 重算 x 所在块的最小值 ( 更新 B) O(L)

9 10 11 12 13 14 15 16

8

7

6

5

4

3

1 2

13~16

9~12

5~8

1~4 Min 操作

• Min(a, b)

– 把区间 [a, b] 分成若干部分

– 完整块 : 一共最多 n/L 个块

O(n/L)

– 非完整块 : 首尾各最多 L-1 个元素

O(L)

• 每次操作时间复杂度 : O(n/L+L)

– 设 L=O(n 1/2 ) 则渐进时间复杂度为 O(n 1/2 )

√ √ √

√

√

√ 例 2. 最接近的值

• 给一个 n 个元素的线性表 A ，对于每个数 A i ，

找到它之前的数中，和它最接近的数。即

对于每个 i ，计算

C i =min{| A i - A j | | 1<= j < i }

• 规定 C 1 =0 。 分析

• 问题的关键 : 你只需要解决 离线 问题

– 在线问题 : 每输入一个 A i , 立刻输出 C i

– 离线问题 : 在给出任何输出之前得到所有 A i

• 预处理 : 用 O(nlogn) 时间给所有 A i 排序

– 很快就会学到了 ☺

• 主算法

– 根据从小到大的顺序构造双向链表

– 依次计算 C n , C n-1 , …, C 1 在线问题可能么 ? 主算法

• A={2, 6, 5, 10, 4, 7}, 依次计算 C 6 , C 5 , C 4

– 每次计算 C i 时 , 链表中恰好是 计算 C i 需要的元素

– 计算 C i 只需比较两个元素，然后删除 A i

O(1)

2 2

4 4

5 5

6 6

7 7

10 10

2 2

4 4

5 5

6 6

10 10

2 2

5 5

6 6

10 10 例 3. 移动窗口

• 有一个长度为 n 的数组，还有一个长度为

k<=n 的窗口。窗口一开始在最左边的位

置，能看到元素 1, 2, 3, …k 。每次把窗口往

右移动一个元素的位置，直到窗口的右边

界到达数组的元素 n 。 分析

• 考虑最小值。假设窗口从左往右移动

• 保存 5 是不明智的 , 因为从 现在 开始一直到 5

离开窗口 , 5 始终被 4“ 压制 ” ，永远都不可能

成为最小值。删除 5 不会影响 结果

• 启发 ：算最小值的 有用 元素形成一个递增

序列，最小值就是队首元素

• 关键： 窗口右移操作

…

4

5

3

… 2 分析

• 窗口右移： 队首出队，新元素入队，然后

在队列中删除它前面比它大的元素

• 实现

– 用链表储存窗口内 有用 元素

– 则窗口右移的时间和删除元素的 总 次数成正比

• 元素被删除后不会再次被插入，因此每个

元素最多被删除一次，总次数为 O(n), 即：

算法时间总复杂度为 O(n)

…

4

12

11

9

7

5

3

3

… 例 4. 程序复杂度

• 给出一段程序，计算它的时间复杂度。这段程序

只有三种语句：

– OP <x > ：执行一条时间耗费为 x 的指令。这里的 x 为不

超过 100 的正整数。

– LOOP <x> ：与 END 配套，中间的语句循环 x 次，其中

x 可以为规模 n ，也可以是不超过 100 的正整数。

– EN D ：与 LOOP 配套，循环终止。

• 注意： OP 语句的参数不能为变量 n ，而 LOOP 语

句的参数可以为变量 n ，但不允许有其他名字的变

量。这样，整个程序的时间复杂度应为 n 的多项

式。你的任务就是计算并显示出这个多项式。 例 4. 程序复杂度

• 输出仅包含一行，即时间复杂度的多项

式。这个多项式应该按通常的方式显示处

理，即不要输出 0n 这样的项， n 项也不要输

出为 n^1 ，等等。

OP 1

LOOP n

LOOP 10

LOOP n OP 7 END

OP 1

END

END

70n^2+10n+1 分析

• 考虑特殊情况：没有变量 n 只有常数的情况

• 两种思路

– 递归求解：不直接，附加开销大 /

– 基于栈的扫描算法：实现简单明了，效率高 ☺

• 扫描过程（基本想法）

– LO O P x 和 OP x, 把语句入栈

– END, 不断从栈里弹出语句，直到弹出 LOOP

• 弹出过程中累加操作数 x ，然后乘以循环次数 y

• 把 OP x*y 压入栈中，相当于用一条 OP 等效一个 LOOP 分析

• 栈扫描算法的直接推广

– 栈里的每个操作数不是数，而是多项式

– 多项式加法，多项式与整数的乘积

– 所有通过至少一个数据的同学都采用此法

• 问题

– 多项式如何表示

– 多项式操作的时间复杂度是怎样的？ 复杂性

• 大部分数据涉及到高精度整数运算

• 高精度运算的复杂性

– 写起来相对麻烦

– 时间复杂度： O(n 2 ) (nlogn is possible, but…)

– 空间复杂度

• 实际情况：所有使用了高精度运算的同学

在时间 “ 爆 ” 掉之前空间先 “ 爆 ” 掉

– 每个数 10000 位 , n 次数可达 10000 （或更多）

– 栈里面可以有 10000 个多项式， 10 12 =1T !!!!! 空间 … 空间 … 空间 …

• 是否可以找到一个空间需求比较小的算

法？ 哪怕时间效率略一点都可以

• 输出文件已经不小了，需要尽量少的保存

中间结果，因此最好不要栈！

– 只要有栈，最坏情况中间结果的空间大小就是

输出大小乘以栈的最大深度，而输出 … “ 把括号展开 ”

• 先想办法去掉所有 LOOP/END

• 借助 当前乘数 确定这次 OP 的 最终 效果

OP 1

LOOP n

LOOP 10

LOOP n

OP 7

END

OP 1

END

END

OP 1 * 1

OP (n*10*n) * 7

OP (n*10) * 1 基本算法

• 设当前乘数为 m, 结果多项式为 ans

– 初始化 m= 1, ans = 0

• 主循环：一条一条语句处理

– 遇到 LOOP x ， m = m * x

– 遇到 END ， m = m / x

– 遇到 OP x, ans = ans + m * x

• 数据结构：设 m = an b ，则用数对 (a, b) 表示

m ， a 是高精度整数， b 是 int 类型

• 除了结果多项式 ans 和 a ， 其他空间可忽略 二、二叉堆 堆

• 堆 (heap) 经常被用来实现优先队列 (priority

queue): 可以把元素加入到优先队列中 , 也

可以从队列中取出 优先级最高 的元素

– Insert(T, x): 把 x 加入优先队列中

– DeleteMin(T, x): 获取优先级最高的元素 x, 并

把它从优先队列中删除 堆的操作

• 除了实现优先队列 , 堆还有其他用途 , 因此

操作比优先队列多

– Getmin(T, x): 获得最小值

– Delete(T, x): 删除任意已知结点

– DecreaseKey(T, x, p): 把 x 的优先级降为 p

– Build(T, x): 把数组 x 建立成最小堆

• 显然 , 用堆很容易实现优先队列 堆的定义

• 堆是一个完全二叉树

– 所有叶子在同一层或者两个连续层

– 最后一层的结点占据尽量左的位置

• 堆性质

– 为空 , 或者最小元素在根上

– 两棵子树也是堆 存储方式

• 最小堆的元素保存在 heap[1..hs] 内

– 根在 heap[1]

– K 的左儿子是 2k, K 的右儿子是 2k+1,

– K 的父亲是 [k/2]

1 1

2 2

3 3

4 4

5 5

6 6

7 7

8 8

9 9

10 10

11 11 12 12

13 13 14 14 删除最小值元素

• 三步法

– 直接删除根

– 用最后一个元素代替根上元素

– 向下调整

13 13

2 2

3 3

4 4

5 5

6 6

7 7

8 8

9 9 10 10

11 11 12 12

1 1

2 2

3 3

4 4

5 5

6 6

7 7

8 8

9 9 10 10

11 11 12 12

13 13 向下调整

• 首先选取当前结点 p 的较大儿子 . 如果比 p 大 , 调整

停止 , 否则交换 p 和儿子 , 继续调整

13 13

2 2

3 3

4 4

5 5

6 6

7 7

8 8

9 9 10 10

11 11 12 12

2 2

13 13

3 3

4 4

5 5

6 6

7 7

8 8

9 9 10 10

11 11 12 12

void swim(int p){

int q = p>>1, a = heap[p];

while(q && a<heap[q]){ heap[p]=heap[q]; p=q; q=p>>1; }

heap[p] = a;

} 插入元素和向上调整

• 插入元素是先添加到末尾 , 再 向上调整

• 向上调整 : 比较当前结点 p 和父亲 , 如果父亲比 p

小，停止 ; 否则交换父亲和 p, 继续调整

void sink(int p){

int q=p<<1, a = heap[p];

while(q<=hs){

if(q<hs&&heap[q+1]<heap[q])q++;

if(heap[q]>=a) break;

heap[p]=heap[q]; p=q; q=p<<1;

}

heap[p] = a;

} 堆的建立

• 从 下往上逐层 向下调整 . 所有的叶子无需调整 ,

因此从 hs/2 开始 . 可用数学归纳法证明循环变量

为 i 时 , 第 i+1, i+2, …n 均为最小堆的根

void insert(int a)

{ heap[++hs]=a; swim(hs); }

int getmin()

{ int r=heap[1]; heap[1]=heap=[hs--];

sink(1); return r; }

int decreaseKey(int p, int a )

{ heap[p]=a; swim(p); }

void build()

{ for(int i=hs/2;i>0;i--) sink(i); } 时间复杂度分析

• 向上调整 / 向下调整

– 每层是常数级别 , 共 logn 层 , 因此 O(logn)

• 插入 / 删除

– 只调用一次向上或向下调整 , 因此都是 O(logn)

• 建堆

– 高度为 h 的结点有 n/2 h+1 个 , 总时间为

lo

g

l o g

1

0 0

( )

2 2

n n

h h

h h

n h

O h O

n

⎢ ⎥

⎢ ⎥

⎣ ⎦

⎣ ⎦

+

= =

⎛ ⎞

⎡ ⎤

× =

⎜ ⎟

⎢ ⎥

⎜ ⎟

⎢ ⎥

⎝ ⎠

∑ ∑ 例 1. k 路归并问题

• 把 k 个有序表合并成一个有序表 .

• 元素共有 n 个 . 分析

• 每个表的元素都是从左到右移入新表

• 把每个表的当前元素放入二叉堆中 , 每次删

除最小值并放入新表中 , 然后加入此序列的

下一个元素

• 每次操作需要 logk 时间 , 因此总共需要 nlogk

的时间 例 2. 序列和的前 n 小元素

• 给出两个长度为 n 的有序表 A 和 B, 在 A 和 B 中

各任取一个 , 可以得到 n 2 个和 . 求这些和最

小的 n 个 分析

• 可以把这些和看成 n 个有序表 :

– A[1]+B[1] <= A[1]+B[2] <= A[1]+B[3] <=…

– A[2]+B[1] <= A[2]+B[2] <= A[2]+B[3] <=…

– …

– A[n]+B[1] <= A[n]+B[2] <= A[n]+B[3] <=…

• 类似刚才的算法 , 每次 O(logn), 共取 n 次最

小元素 , 共 O(nlogn) 例 3. 轮廓线

• 每一个建筑物用一个三元组表示 (L, H, R), 表示

左边界 , 高度和右边界

• 轮廓线用 X, Y, X, Y… 这样的交替式表示

• 右图的轮廓线为 : (1, 11, 3, 13, 9, 0, 12, 7, 16,

3, 19, 18, 22, 3, 23, 13, 29, 0)

• 给 N 个建筑，求轮廓线 分析

• 算法一 : 用数组记录每一个元线段的高度

– 离散化 , 有 n 个元线段

– 每次插入可能影响 n 个元线段 , O(n), 共 O(n 2 )

– 从左到右扫描元线段高度 , 得轮廓线

• 算法二：每个建筑的左右边界为事件点

– 把事件点排序 , 从左到右扫描

– 维护建筑物集合 , 事件点为线段的插入删除

– 需要求最高建筑物 , 用堆 , 共 O(nlogn) 例 4. 丑数

• 素因子都在集合 {2, 3, 5, 7} 的数称为 ugly

number

• 求第 n 大的丑数 分析

• 初始：把 1 放入优先队列中

• 每次从优先队列中取出一个元素 k ，把 2k,

3k, 5k, 7k 放入优先队列中

• 从 2 开始算，取出的第 n 个元素就是第 n 大的

丑数

• 每取出一个数，插入 4 个数，因此任何堆里

的元素是 O(n) 的，时间复杂度为 O(nlogn) 例 5. 赛车

• 有 n 辆赛车从各不相同的地方以各种的速度 ( 速度

0<v i <100) 开始往右行驶，不断有超车现象发生。

• 给出 n 辆赛车的描述（位置 x i ，速度 v i ），赛车已

按照位置排序（

x 1 <x 2 <…<x n ）

• 输出超车总数以及按时间顺序的前 m 个超车事件

V 3

V 4

V 1

V 2

X 2 X 3

X 4

X 1 分析

• 事件个数 O(n 2 ), 因此只能一个一个求

• 给定两辆车，超越时刻预先可算出

• 第一次 超车 可能 在哪些辆车之间？

– 维护所有车的前方相邻车和追上时刻

• 局部：此时刻不一定是该车下个超车时刻！

• 全局：所有时刻的 最小值 就是下次真实超车时刻

• 维护：超车以后有什么变化？

– 相对顺序变化 … 改变三个车的前方相邻车

– 重新算追上时刻，调整三个权

– 简单的处理方法：删除三个再插入三个 例 6. 可怜的奶牛

• 农夫 John 有 n （

n ≤ 100 000 ）头奶牛，可是由于

它们产的奶太少，农夫对它们很不满意，决定每

天把产奶最少的一头做成牛肉干吃掉。但还是有

一点舍不得， John 打算如果不止有一头奶牛产奶

最少，当天就大发慈悲，放过所有的牛。

• 由于 John 的奶牛产奶是周期性的， John 在一开始

就能可以了解所有牛的最终命运，不过他的数学

很差，所以请你帮帮忙，算算最后有多少头奶牛

可以幸免于难。每头奶牛的产奶周期 T i 可能不

同，但不会超过 10 。在每个周期中，奶牛每天产

奶量不超过 200 。 分析

• 如果采用最笨的方法，每次先求出每头牛的产奶

量，再求最小值，则每天的复杂度为 O(n) ，总复

杂度为 O(Tn) ，其中 T 是模拟的总天数。由于周期

不超过 10 ，如果有的牛永远也不会被吃掉，那么

我们需要多模拟 2520 天（ 1 ， 2 ， 3 ， … ， 10 的最

小公倍数）才能确定

• 周期同为 t 的奶牛在没有都被吃掉之前，每天的最

小产奶量也是以 t 为周期的。因此如果把周期相同

的奶牛合并起来，每天只需要比较 10 类奶牛中每

类牛的 最小产奶量就可以了，每天的复杂度为

O(k) ，其中 k 为最长周期 分析

• 假设周期为 6 的牛有 4 头，每次只需要比较 k

组牛的 “ 代表 ” 就可以了，每天模拟的时间复

杂度为 O ( k ) 。

项

目

第 6 n + 1 天 第 6 n + 2 天 第 6 n + 3 天 第 6 n + 4 天 第 6 n + 5 天 第 6 n + 6 天

牛 1

2

5

3

5

7

4

牛 2

3

1

6

7

5

4

牛 3

5

3

3

5

3

9

牛 4

4

4

3

8

8

2

合 并 结 果

2 （ 牛 1 ）

1 （ 牛 2 ）

3 （ 多 ）

5 （ 多 ）

3 （ 牛 3 ）

2 （ 牛 4 ） 分析

• 只要周期为 6 的牛都不被吃掉， 这个表一直是有效

的 。但是在吃掉一头奶牛后，我们需要修改这个

表，使它仍然记录着每天的最小产奶量

– 方法一 : 重新计算，时间 O(h) ，其中 h 是该组的牛数

– 方法二 : 把 一个周期中每天 的最小产奶量组织成堆，每

次删除操作的复杂度是 O(klogh)

• 由于每头奶牛最多被吃掉一次，因此用在维护 “ 最

小产奶量结构 ” 的总复杂度不超过 O(nklogn) 。每

天复杂度为 O(k) ，总复杂度为 O(Tk+nklogn) 例 7. 黑匣子

• 我们使用黑匣子的一个简单模型。它能存

放一个整数序列和一个特别的变量 i 。在初

始时刻，黑匣子为空且 i 等于 0 。这个黑匣子

执行一序列的命令。有两类命令：

• AD D ( x ) ：把元素 x 放入黑匣子；

• GE T ： i 增 1 的同时，输出黑匣子内所有整数

中第 i 小的数。牢记第 i 小的数是当黑匣子中

的元素以非降序排序后位于第 i 位的元素 例 7. 黑匣子

编 号

命 令

i

黑 匣 子 内 容

输 出

1

A D D ( 3 )

0

3

2

G E T

1

3

3

3

A D D ( 1 )

1

1, 3

4

G E T

2

1, 3

3

5

A D D ( - 4 )

2

- 4, 1, 3

6

A D D ( 2 )

2

- 4, 1, 2, 3

7

A D D ( 8 )

2

- 4, 1, 2, 3, 8

8

A D D ( - 1 0 0 0 )

2

- 1 0 0 0, - 4, 1, 2, 3, 8

9

G E T

3

- 1 0 0 0, - 4, 1 , 2, 3, 8

1

1 0

G E T

4

- 1 0 0 0, - 4, 1, 2 , 3, 8

2

1 1

A D D ( 2 )

4

- 1 0 0 0, - 4, 1, 2, 2, 3, 8 分析

• 降序堆 H ≥ 和升序堆 H ≤ 如图放置

• H ≥ 根节点的值 H ≥ [1] 在堆 H ≥ 中最大，

H ≤ 根节点的值 H ≤ [1] 在堆 H ≤ 中最小 ,

并满足

– H ≥ [1] ≤ H ≤ [1]

– siz e [ H ≥ ]= i

• ADD( x ): 比较 x 与 H ≥ [1] ，若 x ≥

H ≥ [1] ，则将 x 插入 H ≤ ，否则从 H ≥ 中

取出 H ≥ [1] 插入 H ≤ ，再将 x 插入 H ≥

• GE T: H ≤ [1] 就是待获取的对象。输

出 H ≤ [1] ，同时从 H ≤ 中取出 H ≤ [1] 插入

H ≥ ，以维护条件 (2) 三、并查集 并查集

• 并查集维护一些不相交集合 S={S 1 , S 2 , …,

S r }, 每个集合 S r 都有一个特殊元素 rep[S i ],

称为集合代表 . 并查集支持三种操作

– Make-Set(x): 加入一个集合 {x} 到 S, 且 rep[{x}]

= x. 注意 , x 不能被包含在任何一个 S i 中 , 因为 S

里任何两个集合应是不相交的

– Union(x, y): 把 x 和 y 所在的两个不同集合合并 .

相当于从 S 中删除 S x 和 S y 并加入 S x US y

– Find-Set(x): 返回 x 所在集合 S x 的代表 rep[S x ] 链结构

• 每个集合用双向链表表示 , rep[S i ] 在链表首部

• Make-Set(x): 显然是 O(1) 的

• Find-Set(x): 需要不断往左移 , 直到移动到首部 .

最坏情况下是 O(n) 的

• Union(x, y): 把 S y 接在 S x 的尾部 , 代表仍是

rep[S x ]. 为了查找链表尾部 , 需要 O(n) 增强型链结构

• 给每个结点增加一个指回 rep 的指针

• Make-Set(x): 仍为常数

• Find-Set(x): 降为常数 ( 直接读 rep)

• Union(x, y): 变得复杂 : 需要把 S y 里所有元素的 rep

指针设为 rep[Sx]! 增强型链结构的合并

• 可以把 x 合并到 y 中，也可以把 y 合并在 x 中 技巧 1: 小的合并到大的中

• 显然 , 把小的合并到大的中 , 这一次 Union 操

作会比较节省时间 , 更精确的分析 ?

• 用 n, m, f 分别表示 Make-Set 的次数 , 总操作

次数和 Find-Set 的次数 , 则有

• 定理 : 所有 Union 的总时间为 O(nlogn)

• 推论 : 所有时间为 O(m + nlogn)

• 证明 : 单独考虑每个元素 x, 设所在集合为 S x ,

则修改 rep[x] 时 , S x 至少加倍 . 由于 S x 不超过

n, 因此修改次数不超过 log 2 n, 总 nlogn 树结构

• 每个集合用一棵树表示 , 根为集合代表 树结构的合并

• 和链结构类似 , 小的合并到大的中 技巧 2: 路径压缩

• 查找结束后顺便把父亲

设置为根 , 相当于有选择

的设置 rep 指针而不像链

结构中强制更新 所有 rep 路径压缩的分析

• 设 w[x] 为 x 的子树的结点数 , 定义势能函数

• Union(x i , x j ) 增加势能 . 最多会让 w[rep[xi]] 增加

w[rep[xj]]<=n, 因此势能增加不超过 logn

• Find-Set(x) 减少势能 . 把路径压缩看作是从根到

结点 x 的向下走过程 , 则除了第一次外的其他向下

走的步骤 p Æ c 会让 c 的子树从 p 的子树中移出 , 即

w[p] 减少 w[c], 而其他点的 w 值保持不变 路径压缩的分析

• Find-Set 除了第一次外的其他向下走的步骤

p Æ c 会让 c 的子树从 p 的子树中移出

– 情况一 : w[c]>=w[p]/2, 则势能将至少减少 1

– 情况二 : w[c]<w[p]/2, 这种情况最多出现 logn 次 ,

因为 w[p] 最多进行 logn 次除 2 操作就会得到 1

• Union 操作积累起来的 mlogn 的势能将被

Find-Set 消耗 , 情况一最多消耗 mlogn 次 , 情

况二本身不超过 mlogn 次 , 因此

• 定理 : Find-Set 的总时间为 O(mlogn) 路径压缩的分析

• 定理 : 如果所有 Union 发生在 Find-Set 之前 ,

则所有操作的时间复杂度为 O(m)

• 证明 : 每次 Find-Set 将会让路径上除了根的

所有结点为根的儿子 . 所有结点只会有一次

改变，因此总时间复杂度为 O(m)

• 也就是说

– 只使用技巧 1( 启发式合并 ): O(m+nlogn)

– 只使用技巧 2( 路径压缩 ): O(mlogn)

• 同时使用呢 ? Ackermann 函数及其反函数 树结构的完整结论

• 定理 : m 个操作的总时间复杂度为 ( (

) )

O m

α n

void makeset(int x){ rank[x] = 0; p[x]=x; }

int findset(int x){

int i, px = x;

while (px != p[px]) px = p[px];

while (x != px) { i = p[x]; p[x] = px; x = i; }

return px;

}

void unionset (int x , int y){

x = findset(x); y = findset(y);

if(rank[x] > rank[y]) p[y] = x;

else { p[x] = y; if(rank[x] == rank[y]) rank[y]++; }

} 例 1. 亲戚

• 或许你并不知道，你的某个朋友是你的亲戚。他

可能是你的曾祖父的外公的女婿的外甥女的表姐

的孙子。如果能得到完整的家谱，判断两个人是

否亲戚应该是可行的，但如果两个人的最近公共

祖先与他们像个好几代，使得家谱十分庞大，那

么检验亲戚关系实非人力所能及。在这种情况

下，最好的帮手就是计算机。

• 为了将问题简化，你将得到一些亲戚关系的信

息，如同 Marry 和 Tom 是亲戚， Tom 和 Ben 是亲

戚，等等。从这些信息中，你可以推出 Marry 和

Ben 是亲戚。请写一个程序，对于我们的关于亲

戚关系的提问，以最快的速度给出答案。 分析

• 本质 : 是否在图的同一个连通块

• 问题 : 图太庞大 , 每次还需要遍历

• 解决 : 用并查集 例 2. 矩形

• 在平面上画了 N 个长方形，每个长方形的边平行

于坐标轴并且顶点坐标为整数。我们用以下方式

定义印版：

– 每个长方形是一个印版；

– 如果两个印版有公共的边或内部，那么它们组成新的

印版，否则这些印版是分离的

• 数出印版的个数 . 左图有两个，右图只有一个 分析

• 把矩形看作点，有公共边的矩形连边，问

题转化为求连通分量的个数

• 判断方法：

Y

( X 2 , Y 2 )

)

,

(

2

2

′

′ Y

X

( X 1 , Y 1 )

)

,

(

1

1

′

′ Y

X

X 例 3. 代码等式

• 由元素 0 和 1 组成的非空的序列称为一个二进制代

码。一个代码等式就是形如 x 1 x 2 .. x l = y 1 y 2 .. y r , 这里 x i

和 y j 是二进制的数字（

0 或 1 ）或者是一个变量（如

英语中的小写字母）

• 每一个变量都是一个有固定长度的二进制代码，

它可以在代码等式中取代变量的位置。我们称这

个长度为变量的长度

• 对于每一个给出的等式，计算一共有多少组解。

• 例 : a,b,c,d,e 的长度分别是 4,2,4,4,2, 则 1bad1 = acbe

有 16 组解 分析

• 长度为 k 的变量拆成 k 个长度为 1 的变量

• 每位得到一个等式

– 1=1 或者 0=0 ：冗余等式

– 1=0 或者 0=1 ：无解

– a=b ： a 和 b 相等（

a 为变量 b 可以为常数）

• 相等关系用并查集处理，最后统计集合数

为 n ，答案为 2 n 。 例 4. 围墙

• 按顺序给出 M 个整点组成的线段，找到最小

的 k ，使得前 k 条线段构成了封闭图形。

（任意两条线段只可能在端点相交） 分析

• 将所有出现过的坐标用整数表示，初始时

候每个独立成树。读入连接 A 和 B 的线段

后，将 A 、 B 所在的树和并。如果 A 、 B 在同

一棵树，那么就出现了封闭图形（因为 x 个

点 x 条边的图必定出现圈）

• 把坐标转换成编号的步骤，可以通过对坐

标进行排序，再删除重复。

• 时间 : O(MlogM) 例 5. 可爱的猴子

• 树上挂着 n 只可爱的猴子（

n ≤ 2*10 5 ）。

• 猴子 1 的尾巴挂在树上

• 每只猴子有两只手，每只手可以抓住最多一只猴

子的尾巴，也可以不抓。猴子想抓谁一定抓得到

• 所有猴子都是悬空的，因此如果一旦脱离了树，

猴子会立刻掉到地上。

• 第 0 ， 1 ， … ， m （ 1 ≤ m ≤ 400 000 ）秒中每一秒

都有某个猴子把他的某只手松开，因此常有猴子

掉在地上

• 请计算出每个猴子掉到地上的时间 分析

• 并查集？

• “ 时光倒流 ”

• 如何标记每只猴子的时间？

– 枚举并查集的元素

– 需要访问兄弟 / 儿子？

– 链表即可

– 不用指针 例 6. 奇数偶数

• 你的朋友写下一个由 0 和 1 组成的字符串，并

告诉你一些信息，即某个连续的子串中 1 的个

数是奇数还是偶数。你的目标是找到尽量小

的 i ，使得前 i+1 条不可能同时满足

– 例如，序列长度为 10 ，信息条数为 5

– 5 条信息分别为 1 2 even ， 3 4 odd ， 5 6 even ， 1

6 even ， 7 10 odd

• 正确答案是 3 ，因为存在序列 (0,0,1,0,1,1) 满

足前 3 条信息，但是不存在满足前 4 条的序列 分析

• 部分序列

– 可以从 s 的奇偶性恢复整个序列

– a b even 等价于 s[b], s[a-1] 同奇偶

– a b odd 等价于 s[b], s[a-1] 不同奇偶

• 一开始每个 s[i] 自成一集合

– a b even Æ 合并 s[b], s[a-1]

– a b odd Æ ???

• 矛盾的标志？ 例 7. 团伙

• 如果两个认识 , 那么他们要么是朋友要么是

敌人 , 规则如下

– 朋友的朋友是朋友

– 敌人的敌人是敌人

• 给出一些人的关系 ( 朋友、敌人 ), 判断一共

最多可能有多少个团伙 例 8. 船

• 给一个 01 矩阵 , 黑色代

表船 . 右图有一个 29 吨

的 , 3 个 7 吨的 , 两个 4 吨

的和三个一吨的 .

• 输入行数 N(<30000) 和

每行的黑色格子 ( 区间

数和每个区间 )

• 输出每种重量的个数

• 一共不超过 1000 个船 ,

每个的重量不超过 1000 例 9. 离线最大值

• 设计一个集合 , 初始为空，每次可以插入一

个 1~n 的数 (1~n 各恰好被插入一次 ), 也可以

删除最大值 , 要求 m 次操作的总时间尽量小 . 分析

• 在最后加入 n-m 次虚拟的 MAX 操作 , 并记第 i

个 MAX 操作为 M i , 记 M 1 之前的插入序列为 S 1,

M i-1 (1<i<=m) 和 M i 之间的插入序列为 S i

• 如果 n 在 S j 中被插入，则 M j 的输出一定是 n.

然后删除 M j ，即 把 S j 合并到 S j+1 中 ，然后再

查找 n-1 所在的序列 S k ，则 M k 的输出为 n-

1… 如此下去，从 n 到 1 依次查找每个数所在

序列，就可以得到它后面的 MAX 操作的结

果 , 并把它和紧随其后的序列合并 例 10. 合并队列

• 初始时 n 个数 1~n 各在单独的一列中 , 需要执

行两个操作

– Move(i, j): 把 i 所在列接到 j 所在列的尾部

– Check(i, j): 询问 i 和 j 是否在同一列 , 如果是 , 输

出二者之间的元素个数 分析

• 每个数 i 的 p[i] 表示 i 和 p[i] 在同一队列 , 且 p[i]

是 i 之前的第 d[i] 个元素

• 对于队首 x, 有 p[x]=x, 附加变量 tot[x] 表示以

x 为首的队列一共有多少个元素

– Mo v e 需要进行两次查找和一次合并

– Ch e c k 需要两次查找

• FIN D: 修改 p[i] 时要修改 d[i]

• ME R G E: 可以启发式合并么 ??? 四、哈希表 哈希表

• 哈希表 (Hash table) 经常被用来做字典 (dictionary),

或称符号表 (symbol-table) 直接存取表

• 直接存取表 (Direct-access table) 的基本思

想是 : 如果 key 的范围为 0~m-1 而且所有 key

都不相同 , 那么可以设计一个数组 T[0..m-1],

让 T[k] 存放 key 为 k 的元素 , 否则为空 (NIL)

• 显然 , 所有操作都是 O(1) 的

• 问题 : key 的范围可能很大 ! 64 位整数有

18,446,744,073,709,551,616 种可能 , 而字

符串的种类将会更多 ! 解决方案 : 哈希函数 哈希函数的选取

• 严格均匀分布的哈希函数很难寻找 , 但一般

说来有三种方法在实际使用中效果不错

– 取余法 : 取 h(k) = k mod m

– 乘积法 : 取 h(k) = (A*k mod 2 w ) rsh (w-r)

– 点积法 : 随机向量 a 和 k 的 m 进制向量做点积

• 实践中经常采用取余法 取余法

• 一般来说不要取 m=2 r , 因为它只取决于 k 的后 r 位

• 一般取 m 为不太接近 2 或 10 的幂 乘积法

• 取 m=2 r , 计算机字长为 w, 则

H(k) = (A*k mod 2 w ) rsh (w-r)

• 其中 rsh 表示右移位 , A 是满足 2 w-1 <A<2 w 的

奇数 . 注意 : A 不应该太接近于 2 w . 由于乘法

并对 2 w 取余是很快的 ( 自然就会丢弃高位 ),

而算术右移也很快，因此函数计算开销小 冲突解决

• 不同的 key 映射到同一个数 , 称为冲突

(collision), 冲突的两个元素显然不可能放在

哈希表的同一个位置

• 通常有两种冲突解决方案 (resolving

collisions)

– 链方法 (chaining): 把 key 相同的串成链表

– 开放地址法 (open addressing): 自己的位置被

占了 , 就去占别人的 链地址法

• Ke y 相同的元素形成一个链表 链地址法的查找效率

• 链地址法的时间效率取决于 hash 函数的分布 . 我

们假设每个 k 将等可能的被映射到任意一个 slot,

不管其他 key 被映射到什么地方

• 设 n 为 key 的数目 , m 为不同的 slot 数 , 装载因子α

= n/m, 即每个 slot 平均的 key 数 , 则

• n=O(m) 时期望搜索时间是 O(1) 的 开放地址法

• 开发地址法只使用表内的空间 . 如果冲突产生 , 计

算出第二个可能的位置 , 如果那里也有其他元素 ,

再看第三个可能的位置 … 即按一个 探测序列 查找

• 位置应该是 key 和探测的次数 (probe number) 的函

数 , 第 i 次探测位置为 slot = h(k,i)

• 每个 slot 都应能被探测到 , 因此每个 k 的探测序列

<h(k,0), h(k,1), h(k,2), …,h(k,m-1)>

• 都应是 {0,1,…,m-1} 的排列

• 注意 : 开放地址法不容易 删除 元素 开放地址法示例 探测方法

• 线性探测 :

• 虽然很简单 , 但是容易形成元素堆积

• 二次哈希 : 组合两个哈希函数

• 一般效果会好很多，但应保证 h 2 (k) 和 m 互素 , 比如

取 m 为 2 的幂而让 h 2 (k) 只产生奇数 开放地址法的查找效率

• 假设每个 key 等概率的把 m! 个排列中的任何

一个作为它的探测序列 , 则有

• 定理 : 装载因子α <1 时 , 不成功查找的期望

探测次数为 1/ (1- α)

• 证明 : 第 i 次探测到非空 slot 的概率为

(n-i)/(m-i) < n/m = α

• 下面各种情况按概率加权计算期望 开放地址法的查找效率

• 各种情况按概率加权 , 得期望的探测次数为 查找效率比较

• 把开放地址法说通俗一点，就是

– 装载因子为常数时 , 期望查找次数为常数

– 一半装满时 , 期望查找次数为 1/(1-0.5)=2

– 装满 90% 时 , 期望查找次数为 1/(1-0.9)=10

• 装得比较满 ( 尤其是 n>m) 时 , 使用链地址法

– 在哈希表里保存每个 key 的第一个元素

first[0..m-1],

– 在一个数组 data[1..n] 里装着所有元素和下一个

元素 next[1..n] 链地址法参考代码

• 在实际应用中，推荐使用链地址法

– first[i] 表示 哈希函数值为 i 的第一个数据下标

– ke y [i] 和 next[i] 表示 第 i 个 数据的 key 和下一个

int find(int k){

int h = hash(k);

int p = first[h];

while (p){ if(key[p] == k) return p; p = next [p]; }

return 0;

}

void insert(int x){

int h = hash(key[x]); next[x] = first[h]; first[h] = x;

}