贪心算法|406. 根据身高重建队列|先排序后插队

贪心算法|406. 根据身高重建队列|先排序后插队

406. 根据身高重建队列 - 力扣（LeetCode） (leetcode-cn.com)

题目

假设有打乱顺序的一群人站成一个队列，数组 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队列中[hi,ki]中第一个元素hi进行进行降序排序，对第二个元素ki进行升序排序的思想，形成一个初始序列，再逐一插队处理

• 第一个元素采用降序：根据题意，为了在返回队列queue每次插入的新元素的时候，插入到ki的下标上，必定前面的身高都大于等于新元素身高，因为是降序排序，直接插入到ki下标并不会对后面元素产生影响，因为插入的身高必定小于后面已经排好元素的身高
• 第二个元素采用升序：当身高相等时，第二个元素升序排序，ki小的放前面，大的放后面正好符合题意，为了减少插入的时候需要移动的元素个数

eg：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]

第一个元素降序，第二个元素升序后排列为：[[7,0],[7,1],[6,1],[5,0],[5,2],[4,4]]

注意：先以第一个元素降序，第一个元素相同时第二个升序

代码

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** reconstructQueue(int** people, int peopleSize, int* peopleColSize, int* returnSize, int** returnColumnSizes){
    int ** queue = (int**)malloc(peopleSize*sizeof(int*));
    int i,j;
    *returnSize=peopleSize;
    *returnColumnSizes = (int*)malloc(sizeof(int) * peopleSize);
    for(i=0;i<peopleSize;i++){
        queue[i]= (int*)malloc(sizeof(int)*2);//为返回指针数组中的指针分配存储空间，即[[1,2],[2,3]]中[1,2]的存储空间
        (*returnColumnSizes)[i]=2;//表示[[1,2],[2,3]]中的[1,2]有两个元素，如1，2
    }
    for(i=1;i<peopleSize;i++){//实现第一个元素降序排列，第二个元素升序排列，eg：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]---->[[7,0],[7,1],[6,1],[5,0],[5,2],[4,4]]
        j=i-1;
        if(people[i][0]>people[i-1][0]){//实现第一个元素降序
            int h = people[i][0];
            int k = people[i][1];
            for(j=i-1;j>=0&&h>people[j][0];j--){
                people[j+1][0]=people[j][0];
                people[j+1][1]=people[j][1];
            }    
            people[j+1][0]=h;
            people[j+1][1]=k;
        }
        if(j>=0&&people[j+1][0]==people[j][0]&&people[j+1][1]<people[j][1]){//实现第二个元素升序
            int temp = people[j+1][1];
            while(j>=0&&people[j+1][0]==people[j][0]&&people[j][1]>temp){
                people[j+1][1]=people[j][1];
                j--;
            }
            people[j+1][1]=temp;
        }
    }
    for(i=0;i<peopleSize;i++){//实现新元素插入返回指针数组的ki下标上，将ki下标后面的数组往后移，即实现插队
        for(j=i-1;j>=people[i][1];j--){
            queue[j+1][0]=queue[j][0];
            queue[j+1][1]=queue[j][1];
        }
        queue[j+1][0]=people[i][0];
        queue[j+1][1]=people[i][1];
    }
    // for(i=0;i<peopleSize;i++)
    //     printf("%d,%d\n",people[i][0],people[i][1]);
    //  printf("---------------\n");
    // for(i=0;i<peopleSize;i++)
    //     printf("%d,%d\n",queue[i][0],queue[i][1]);

    return queue;
}