406. 根据身高重建队列

1. 题目描述

假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(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]]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/queue-reconstruction-by-height
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2. 解题思路

先排序后插入

1. 排序规则：按照先H高度降序，k个数升序排序。

2. 遍历排序后的数组，根据k插入到k的位置上。

2.1 C++

1 class Solution {
2 public:
3
4     vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
5         // 根据自定义比较方法排序
6         sort(people.begin(), people.end(), [](const vector<int>& u, const vector<int>& v) {
7             return u[0] > v[0] || (u[0] == v[0] && u[1] < v[1]);
8         });
9         // list是链表实现，插入效率更高
10         vector<vector<int>> ans;
11         // 遍历元素
12         for(const vector<int>& p : people) {
13             // 根据k来重新插入排序
14             ans.insert(ans.begin() + p[1], p);
15         }
16         return ans;
17     }
18 };

2.2 Java 

第一种方法

1 class Solution {
2
3     // 第一种方法
4     /**
5         * 解题思路：先排序后插入
6         * 1.排序规则：按照先H高度降序，k个数升序排序
7         * 2.遍历排序后的数组，根据k插入到K的位置上
8         * 核心思想：高个子先站位，矮个子插入到K位置上，前面肯定有k个高个子，矮个子再插入前面也满足k的要求
9     */
10     /***
11     Arrays.sort(people, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]);
12
13     LinkedList<int[]> list = new LinkedList<>();
14     for (int[] i : people) {
15         list.add(i[1], i);
16     }
17
18     return list.toArray(new int[list.size()][2]);
19     */
20 }

第二种方法

1 class Solution {
2     // 第二种方法
3     // 1.挖坑填数
4     private int adjustArray(int[][] arr, int l, int r) {
5         int[] p = arr[l];
6         while(l < r) {
7             // 从右开始找第一个  H_j大于或等于H_i，且k_j小于等于k_i的值
<
ad8
span style="color: rgba(0, 128, 128, 1)"> 8             while(l < r) {
9                 if(arr[r][0] > p[0] || arr[r][0] == p[0]  && arr[r][1] < p[1]) {
10                     // 用arr[j]填到arr[i],
11                     arr[l++] = arr[r];
12                     break;
13                 }
14                 r--;
15             }
16             while(l < r) {
17                 if(arr[l][0] < p[0] || arr[l][0] == p[0] && arr[l][1] > p[1]) {
18                     arr[r--] = arr[l];
19                     break;
20                 }
21                 l++;
22             }
23         }
24         // 退出时，i=j,将p填到这个坑来
25         arr[l] = p;
26         return l;
27     }
28     // 2.分治
29     private void quickSort(int[][] arr, int left, int right) {
30         if (left >= right)
31             return;
32         int i = adjustArray(arr, left, right);
33         quickSort(arr, left, i - 1);
34         quickSort(arr, i + 1, right);
35     }
36
37     public int[][] reconstructQueue(int[][] people) {
38         quickSort(people, 0, people.length - 1);
39         List<int[]> list = new ArrayList<>();
40         for (int[] p: people) list.add(p[1], p);
41         return list.toArray(new int[0][2]);
42     }
43 }

2.3 Python

1 class Solution:
2     def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
3         res = []
4         people = sorted(people, key = lambda x : (-x[0], x[1]))
5         for p in people:
6             # if len(res) <= p[1]:
7             #     res.append(p)
8             # else:
9             res.insert(p[1], p)
10         return res

3. 结语

 努力去爱周围的每一个人，付出，不一定有收获，但是不付出就一定没有收获！ 给街头卖艺的人零钱，不和深夜还在摆摊的小贩讨价还价。愿我的博客对你有所帮助(*^▽^*)(*^▽^*)！

 如果客官喜欢小生的园子，记得关注小生哟，小生会持续更新(#^.^#)(#^.^#)。