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++

class Solution {
public:

    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        // 根据自定义比较方法排序
        sort(people.begin(), people.end(), [](const vector<int>& u, const vector<int>& v) {
            return u[0] > v[0] || (u[0] == v[0] && u[1] < v[1]);
        });
        // list是链表实现，插入效率更高
        vector<vector<int>> ans;
        // 遍历元素
        for(const vector<int>& p : people) {
            // 根据k来重新插入排序
            ans.insert(ans.begin() + p[1], p);
        }
        return ans;
    }
};

2.2 Java 

第一种方法

class Solution {

    // 第一种方法
    /**
        * 解题思路：先排序后插入
        * 1.排序规则：按照先H高度降序，k个数升序排序
        * 2.遍历排序后的数组，根据k插入到K的位置上
        * 核心思想：高个子先站位，矮个子插入到K位置上，前面肯定有k个高个子，矮个子再插入前面也满足k的要求
    */
    /***
    Arrays.sort(people, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]);

    LinkedList<int[]> list = new LinkedList<>();
    for (int[] i : people) {
        list.add(i[1], i);
    }

    return list.toArray(new int[list.size()][2]);
    */
}

第二种方法

class Solution {
    // 第二种方法
    // 1.挖坑填数
    private int adjustArray(int[][] arr, int l, int r) {
        int[] p = arr[l];
        while(l < r) {
            // 从右开始找第一个  H_j大于或等于H_i，且k_j小于等于k_i的值
            while(l < r) {
                if(arr[r][0] > p[0] || arr[r][0] == p[0]  && arr[r][1] < p[1]) {
                    // 用arr[j]填到arr[i],
                    arr[l++] = arr[r];
                    break;
                }
                r--;
            }
            while(l < r) {
                if(arr[l][0] < p[0] || arr[l][0] == p[0] && arr[l][1] > p[1]) {
                    arr[r--] = arr[l];
                    break;
                }
                l++;
            }
        }
        // 退出时，i=j,将p填到这个坑来
        arr[l] = p;
        return l;
    }
    // 2.分治
    private void quickSort(int[][] arr, int left, int right) {
        if (left >= right) 
            return;
        int i = adjustArray(arr, left, right);
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }

    public int[][] reconstructQueue(int[][] people) {
        quickSort(people, 0, people.length - 1);
        List<int[]> list = new ArrayList<>();
        for (int[] p: people) list.add(p[1], p);
        return list.toArray(new int[0][2]);
    }
}

2.3 Python

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

3. 结语

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

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