排队-题解
排队-题解
《排队》是一道很优美的贪心题（我不知道它的来源，估计其难度提高+/省选），曾被出在了北京大学计算概论B的考试中。本文的受众主要是学习计算概论的同学以及老师，不假定读者有信息竞赛（OI）经验。
题目描述
有 N 名同学从左到右排成一排，第 i 名同学的身高为 hi。现在张老师想改变排队的顺序，他能进行任意多次（包括0次）如下操作：
- 如果两名同学相邻，并且他们的身高之差不超过 D，那么老师就能交换他俩的顺序。
请你帮张老师算一算，通过以上操作，字典序最小的所有同学（从左到右）身高序列是什么？
\((1<=N<=10^5, 1<=D<=10^9, 1<=h_i<=10^9)\)
初步分析
这是一个最优化问题，需要找到一个贪心准则，然后用其他算法辅助实现。一般的思路是，先找到一个贪心构造最优解的方法，先不管这个方法的复杂度，然后再寻找一些性质，进行优化。
任务：给定一个序列，通过交换元素的位置，找到其字典序最小的一个排列。
约束：任意身高差大于D的元素不对易（不对易的元素的先后关系永远不能改变）。
也就是，每个元素前面都有一些无法翻越的“大山”，这个元素必须排到“大山”的后面。前面没有“大山”的元素，我们称为“自由节点”。
一个显然的算法就是：每次找出所有的”自由节点“，找出其中最小的一个，排在前面，然后把它去掉。假如有多个相同大小的元素，它们必然会被连续地输出掉，所以先后顺序无影响。这个算法本身证明了其正确性（is self-proved）。
每次找出”自由节点“的代价为O(n)，只需要维护前缀最大值、最小值（最可能成为”大山“），就可以判断当前点是否自由了，判据为h[i] + D >= maxv and h[i] - D <= minv。
总时间复杂度为 \(O(N^2)\) 。代码如下
INF = int(1e9 + 7)
N, D = map(int, input().split())
h = [int(input()) for _ in range(N)]
used = [0] * N
for _ in range(N):
minv, maxv = INF, -INF
idx, val = 0, INF
for i in range(N):
if used[i]:
continue
minv = min(minv, h[i])
maxv = max(maxv, h[i])
if (h[i] + D >= maxv and h[i] - D <= minv and h[i] < val):
val = h[i]
idx = i
used[idx] = 1
print(h[idx])
寻找性质
贪心题的突破点往往在于一些性质。寻找性质最好的方法是写出几个样例，手动寻找最优解，然后总结自己不知不觉发现的贪心准则。
比如说这样一组数据
D=3
h=[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9]
按照刚才的贪心准则，最初的”自由节点“为
[3, 1, 4, 1]
执行初步分析得出的程序，得到的序列为
[1, 1, 3, 4, 5, 9, 2, 3, 5, 5, 6, 7, 8, 9, 9]
我们发现最初的”自由节点“恰好是答案的前4个。我们打印出每次选取时的自由节点列表
1 from [3, 1, 4, 1]
1 from [3, 4, 1]
3 from [3, 4, 5]
4 from [4, 5]
5 from [5]
9 from [9]
2 from [2, 5, 3, 5]
3 from [6, 5, 3, 5]
5 from [6, 5, 5, 8, 7]
5 from [6, 5, 8, 7]
6 from [6, 8, 9, 7, 9]
7 from [8, 9, 7, 9]
8 from [8, 9, 9]
9 from [9, 9]
9 from [9]
观察并分组，我们发现每找一次”自由节点“，就可以把所有的自由节点排序、输出、删掉。然后再找一波自由节点就行了。也就是说，这个序列是分层的。
1 from [3, 1, 4, 1]
1 from [3, 4, 1]
3 from [3, 4, 5]
4 from [4, 5]
5 from [5]
9 from [9]
2 from [2, 5, 3, 5]
3 from [6, 5, 3, 5]
5 from [6, 5, 5, 8, 7]
5 from [6, 5, 8, 7]
6 from [6, 8, 9, 7, 9]
7 from [8, 9, 7, 9]
8 from [8, 9, 9]
9 from [9, 9]
9 from [9]
再看一些数据（我们不妨把D改成2），我们发现以上准则依然成立。
1 from [3, 1]
3 from [3, 4]
4 from [4]
1 from [1]
5 from [5]
9 from [9]
2 from [2]
5 from [6, 5, 5]
5 from [6, 5]
6 from [6]
3 from [3]
7 from [8, 9, 7, 9]
8 from [8, 9, 9]
9 from [9, 9]
9 from [9]
于是我们可以扫描一次，输出一层。时间复杂度\(O(N\max(\log N,d))\)，其中d是图的层数，假如D很小，d可能接近N，复杂度还是太高。（ps：由于OJ数据比较弱，层数很小，这个方法写出的代码可以直接AC，并且速度秒杀正解）
我们可以不加证明地认为，这一准则是无比正确的（OI选手往往不会追求形式化的证明）。假如你不放心，我在这儿勉为其难地给出一个证明。
思路很简单：我们每次拎出所有的自由节点，只要证明它们会在被其他节点之前被输出就可以了。
首先，后面的因为”过高“被挡住的点肯定不急着输出，它们提前输出只会增大字典序。
然后考虑”太矮“而被限制的节点，它们前面有一个比较高的”大山“，只要这个”大山“被输出了，它们就可以排到前面，减小字典序了。但是按照我们最初的贪心准则，我们每次要输出最小的自由节点，所有比”大山“小的节点都得放在“大山”之前输出，比大山大的节点也可以把那个”太矮“的节点挡住（除非它在太矮的节点的后面，但那样它就会被挡住，从而不可能是自由节点）。所以这个”太矮“的节点必须等到这一时刻的所有自由节点输出完毕才会被输出。由于同一层的自由节点都是对易的，输出它们的顺序自然是从小到大。
可以看到，虽然这个性质的证明很简单，但我们是很难不做任何猜测，直接推导出这个性质的。所以做贪心题还是得找性质。这真的很难，这个题我想了几个月才做出来。
优化
我们还能发现一点，就是每一层元素都有一个”大山“来自于上一层元素。换句话说，我们只需要找到一个点的“大山”中最大的层数，将其层数+1就可以得到这个元素的层数。算出了每个元素的层数，就可以快速将其归类，然后分别排序输出了。
找”层数最大的大山的层数“，变成了一个求最大值问题，有很多数据结构可以以O(logN)的代价维护区间最大值。
我们定量描述一下”h[i]的层数最大的大山的层数“。”大山”意味着h>h[i]+D或h<h[i]-D，“最大层数”就在这两个区间求最大值就行了。我们确定下i的层数之后，再把h[i]位置的最大层数更新一下就行了。
我们需要一种数据结构，支持我们查询一个区间的最大值，并且可以修改一个点的值（支持“区间查询，单点修改”）。
法1：线段树
最直接的数据结构就是线段树了（支持区间修改，区间查询；上网搜，或者看老师的课件），不过由于h的范围很大，内存不支持我们开一个长达1e9的数组，我们必须使用“动态开点线段树”。时间复杂度\(O(N\log \text{MAXH})\)其中\(\text{MAXH}\)是H的值域宽度。代码如下：（面向对象的设计可能对初学者很不友好）
# 使用class写一棵线段树
class SegmentTreeNode:
def __init__(self, start, end, val):
self.start = start
self.end = end
self.val = val
self.lson = None
self.rson = None
class SegmentTree:
def __init__(self, start, end):
self.root = SegmentTreeNode(start, end, 0)
self.start = start
self.end = end
# 返回修改后的节点的对象。注意对象是浅拷贝，里面存储了一些指针。
# 改变了子对象的指针之后，需要重新赋值给父对象，不然子对象的子对象就会被释放
def modify(self, node, pos, value, start=None, end=None):
if (start is None):
start, end = self.start, self.end
if (node is None):
node = SegmentTreeNode(start, end, value)
if (start == end):
node.val = max(node.val, value)
return node
mid = (node.start + node.end) // 2
if pos <= mid:
node.lson = self.modify(node.lson, pos, value, start, mid)
else:
node.rson = self.modify(node.rson, pos, value, mid + 1, end)
node.val = max(node.val, value)
return node
def query(self, node, qstart, qend):
if ((node is None) or qstart > node.end or qend < node.start):
return 0
if (qstart <= node.start and node.end <= qend):
return node.val
ret = max(self.query(node.lson, qstart, qend), self.query(node.rson, qstart, qend))
return ret
# 主程序非常短
N, D = map(int, input().split())
h = [int(input()) for _ in range(N)]
# 求出每个点的层数，用一个线段树维护值域上的层数，这样就可以求出挡在前面的大山的最大的层数了
MAXH = max(h)
layers = SegmentTree(1, MAXH)
members = [[]] # 存储每一层里面的元素
for hi in h:
current_layer = max(layers.query(layers.root, 1, hi - D - 1), layers.query(layers.root, hi + D + 1, MAXH)) + 1
if (current_layer >= len(members)):
members.append([])
members[current_layer].append(hi)
layers.modify(layers.root, hi, current_layer)
# 直接一层层排序、输出即可
for layer in members:
for _ in sorted(layer):
print(_)
法2：树状数组
这种方法思路需要更多技巧，不过代码比较短，而且跑得更快。
树状数组支持维护前缀最大值，以及单点修改。我们要查询的恰好是前缀、后缀最大值（h>h[i]+D或h<h[i]-D），其中后缀最大值只需要把数列反过来就可以了。
还有一个问题，内存不允许我们开一个1e9的数组，树状数组也不能动态开点。所以我们必须使用另一个技巧——“离散化”。（离散化也可以用于线段树，这样就不需要动态开点了）
我们把所有h排序、去重，构造“权值序列”。然后所有h都可以替换成其在“权值序列”中的排位。比如说我们要查找<h[i]-D的点的最大层数，只需要查找到权值序列中比h[i]-D小的最大的元素的位置index，在树状数组中求出前缀最大值get_max(index)即可
代码如下：感谢23-数院-胡睿诚
# by 23-数院-胡睿诚
import bisect
def low_bit(n):
if n == 0:
return 0
elif n % 2 == 1:
return 1
else:
return 2*low_bit(n // 2)
low_bit_list = [low_bit(n) for n in range(10**5+1)]
class SearchMaxList:
def __init__(self,length):
self.list = [-1]*length
self.length = length
self.assistant_list = [-1]*length
def get_max(self,index):
output_max = -1
while index > 0:
output_max = max(self.assistant_list[index-1],output_max)
index -= low_bit_list[index]
return output_max
def update(self,index,new_value):
self.list[index-1] = new_value
while index <= self.length:
self.assistant_list[index-1] = max(self.assistant_list[index-1],new_value)
index += low_bit_list[index]
N,D = map(int,input().split())
heights = []
heights_dict = {}
classification_dict = {}
for i in range(N):
heights.append(int(input()))
sorted_heights_set = sorted(list(set(heights)))
reversed_heights_set = sorted(list(set(heights)),reverse=True)
M = len(sorted_heights_set)
for i in range(M):
heights_dict[sorted_heights_set[i]] = i
sorted_heights = SearchMaxList(M)
reversed_heights = SearchMaxList(M)
for height in heights:
sorted_index = bisect.bisect_right(sorted_heights_set,height-D-1)
reversed_index = M-bisect.bisect_left(sorted_heights_set,height+D+1)
max_1 = sorted_heights.get_max(sorted_index)
max_2 = reversed_heights.get_max(reversed_index)
path_length = max(max_1,max_2) + 1
sorted_heights.update(heights_dict[height]+1,path_length)
reversed_heights.update(M-heights_dict[height],path_length)
try:
classification_dict[path_length].append(height)
except KeyError:
classification_dict[path_length]=[height]
for path_length in sorted(classification_dict.keys()):
for height in sorted(classification_dict[path_length]):
print(height)
