LeetCode 406.Queue Reconstruction by Height

最新推荐文章于 2022-10-03 21:45:05 发布

Infi_zc

最新推荐文章于 2022-10-03 21:45:05 发布

阅读量126

点赞数

分类专栏： LeetCode 数据结构与算法

本文链接：https://blog.youkuaiyun.com/lakersdf/article/details/88080159

版权

LeetCode 同时被 2 个专栏收录

29 篇文章

订阅专栏

数据结构与算法

25 篇文章

订阅专栏

本文深入探讨了一种解决特定队列重建问题的算法。该算法首先根据特定条件对人群进行排序，然后通过高效的插入策略重建原始队列。文章对比了两种方法：一种是基于高度和前方人数的排序和插入，另一种则是先按高度降序再按人数升序排序，最后直接插入。后者因其简洁高效而被推荐。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

假设有打乱顺序的一群人站成一个队列。每个人由一个整数对(h, k)表示，其中h是这个人的身高，k是排在这个人前面且身高大于或等于h的人数。编写一个算法来重建这个队列。

注意：
总人数少于1100人。

示例

输入:
[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]
    
输出:
[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

思路与代码

我的思路

这道题我自己根据我自己重建的步骤提炼出了算法，并accept了，但不幸的是我的算法太慢太慢，但作为记录先写出来吧。首先我先按照在前面有几个的标准从小到大排一遍，排完的结果是这样的：

[[[5, 0], [7, 0]], [[6, 1], [7, 1]], [[5, 2]], [], [[4, 4]], []] [[5, 0], [7, 0]]

接着我们按照顺序一个个插到最终的列表result中，首先插入[[5, 0], [7, 0]，这个顺序没有问题，之后一个一个插入，如[6,1]，从头遍历result，如果遇到比待插入元素大的就count+1，直到走到result末端（就插在末端），或者count已经比想要的大了1，那这个就要插在最后一个比它大的元素的位置，这个地方需要详细说一下因为这里遇到了bug，就是如果只要一满足count = 目标值 就插入的话会带来错误，这会让后插入的比它大的数插到它后面，因为大的看不见小的只会往后移动。解释的有点冗杂，看代码吧：

class Solution(object):
    def reconstructQueue(self, people):
        """
        :type people: List[List[int]]
        :rtype: List[List[int]]
        """
        if len(people)==1:
            return people
        if people == []:
            return []
        def takefirst(item):
            return item[0]

        length = len(people)
        record = [[] for i in range(length)]
        for i in range(length):
            record[people[i][1]].append(people[i])
        for i in range(length):
            if record[i] == [] or len(record[i]) == 1:
                continue
            record[i].sort(reverse=False, key=takefirst)
        for i in range(length):
            if record[i] != []:
                t = i + 1
                result = record[i]
                break
        #print(record, result)
        for i in range(t, length):
            if record[i] == []:
                continue
            for j in range(len(record[i])):
                count = 0
                l = len(result)
                for k in range(l):
                    if record[i][j][0] <= result[k][0]:
                        count += 1
                    if count == record[i][j][1]+1:
                        result.insert(k, record[i][j])
                    if k == len(result)-1 and count == record[i][j][1]:
                        result.append(record[i][j])
                    if count == record[i][j][1] and record[i][j][0] > result[k+1][0]:
                        continue

        return result

如上所示，三重循环完全GG，所以其实想不到好的方法宁愿不写，写时间复杂度高的没啥价值。

简单高效的方法

这个方法和我的思路相反，他也是先排个序，但是他排序是按照数值从大到小排，然后同一个值的话个数少的在前。排完序后直接按照index k进行插入。这里面最核心最精华的思想是：个子矮的人对于个子高的人不影响。先排高个后排矮个的话，每次插入矮个的时候，因为现在已经有的列表里全是比它大的，那为了满足他前面有k个人的需求，那它只好插在k的地方了。
lambda叫做匿名函数，通常是在需要一个函数但是又不想去命名一个函数的场合使用，一个例子：

add = lambda x, y : x+y
add(1,2)  # 结果为3

这里的lambda就是实现按照h降序，k升序的规则去排序。

class Solution(object):
    def reconstructQueue(self, people):
        people.sort(key=lambda (h, k): (-h, k))
        queue = []
        for p in people:
            queue.insert(p[1], p)
        return queue

这个方法真的非常棒