leetcode(力扣) 406. 根据身高重建队列 (贪心)

题目描述

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。
请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

示例 1：
输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
解释：
编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。

示例 2：
输入：people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]
输出：[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]

简化题目

这题目我看了半天才看明白。
简化一下：

题目给你一个乱序二维数组，要你使得下面含义合法情况下重新排序：

含义：people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

思路分析

举例：
上了第一节体育课，老师给大家排好了体操的队伍，可是大家脑子都很笨，记不清自己在哪，老师说，你就看前面有几个比自己高的就行！就像这样：

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

该上第二节课的时候，大家记住了前面有几个比自己高的，却还是忘记了怎么排，老师见状让学生从高到低排好队，身高一样的，比自己高的越多，越往后面站，像这样：

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

每次让最高的学生出来找自己的位置，第一个高个子[7,0]自然站到了第一个位置：

[[7,0]]

而第二个高个子[7,1]知道有一个人大于等于自己的身高，站在了第一个人身后：

[[7,0],[7,1]]

第三个人[6,1]想了想，有一个人比自己高，那自己肯定站在第二位，于是就插队，现在也站到了第一个人身后：

[[7,0],[6,1],[7,1]]

第四个人[5,0]想了想，没人比自己高，那自己肯定站在第一位，于是就插队，站到了队头：

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

第五个人[5,2]想了想，有两个人比自己高，于是就插队，站到了第二个人后面，也就是第三个位置：

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

第六个人[4,4]看了看眼前的队伍，比自己高的人都在里面，他安心的数着前面有四个人比自己高，心安理得的站到了第四个人身后：

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

思路就是上面这样，转换成代码语言就行了。

唯一有一个细节，开头需要对所给数组进行排序，要按照h降序，k升序的方法进行排序。
假设有 [[5,0],[6,0],[7,0]] 此时要加入的是 [[5,2],[5,3]] 。
如果按照h降序，k也降序的话，就是[[5,3],[5,2]]。
先遍历到[5,3] 则： [[5,0],[6,0],[7,0],[5,3]]
再遍历到[5,2] 则： [[5,0],[6,0],[5,2],[7,0],[5,3]]
显然此时第一个插入的[5,3]出错了，应该变成[5,4]才对了。所以 k要升序。

完整代码

class Solution:
    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
        temp = sorted(people,key= lambda x:(-x[0],x[1]))

        res = [temp[0]]

        print(temp)
        for i in range(1,len(temp)):
            j = temp[i][1]
            insert = 0
            for p in range(len(res)):
                if j == 0:
                    break
                if res[p][0] >= temp[i][0]:
                    insert+=1
                    j-=1

            res.insert(insert,temp[i])

        print(res)
        return res 

二刷简化版

思路没变，还是那样排序，只不过在插入的时候，直接按照x[1]的数字当做重建队列的下标位置进行插入就对了。

这里比较容易想，比如[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
排序过后是：[[7,0],[7,1],[6,1],[5,0],[5,2],[4,4]]

假如遍历到[6,1]了，按照规则插入到下标为1的位置，前面就只有一个[7,0]。这里其实就是6前面都一定比他大或者等于，后面一定都是小于或者等于的，所以[6,1]前面有一个比他大的数或者等于他的数一定是已经加入到新数组里的了，所以这里直接把1当做下标插入到新数组就行了。

class Solution:
    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
            temp = sorted(people,key=lambda x:(-x[0],x[1]))
            res = []
            res.append(temp[0])
            for i in range(1,len(temp)):
                res.insert(temp[i][1],temp[i])
            return res