LeetCode_406. Queue Reconstruction by Height解题思路

题目如下：

Suppose you have a random list of people standing in a queue. Each person is described by a pair of integers (h, k), where h is the height of the person and k is the number of people in front of this person who have a height greater than or equal to h. Write an algorithm to reconstruct the queue.

Note:
The number of people is less than 1,100.


Example

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

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

简单的理解就是给定一个二维数组P，二维数组中的每个元素n, n[0] 表示高度，n[1] 表示位置，即在n前面有n[1]个元素，他们的高度都大于或等于n[0]

解题的思路：

一、不借鉴任何Java自带的容器：

　　1.遍历二维数组P，选择数组中的一个元素，其x[0]是所有元素中最大的，如果存在两个以上，[0]值是最大且相等，那么就根据[1]的值，选择[1]最小的那个元素

　　2.利用数组记录选中的元素在数组P中的下标，防止下一轮循环的时候又选到它，同时自己在实现的时候还加上了一个判断标志

　　3.使用插入排序算法，将选中的元素x,根据其 x[1] 的值作为在新数组中的下标，插入到新的数组中。（这里我的实现是重新生成一个临时数组TMP，大小是上一轮的“新”数组大小+1），优先插入选中的元素，

　　4.重复以上步骤，直到结束

以下是代码：

public int[][] reconstructQueue(int[][] people) {

    int[][] temp = new int[0][];
    int[] label = new int[people.length];
    //用于跳过已选择的元素
    boolean next = true;
    while (temp.length < people.length) {
      int[] t = {0,0};
      for (int i = 0; i < people.length; i++) {
        for (int j=0;j<temp.length;j++){
          if(label[j] == i){
            next=false;
            break;
          }
        }
        if (people[i][0] > t[0] && next) {
          t[0] = people[i][0];
          t[1] = people[i][1];
          label[temp.length] = i;
        }else if(people[i][0] == t[0] && next && t[1]>people[i][1] ){
          t[0] = people[i][0];
          t[1] = people[i][1];
          label[temp.length] = i;
        }
        next = true;
      }
      temp = this.sortPeople(temp, t);
    }
    return temp;
  }

  private int[][] sortPeople(int[][] temp,int[] t){
    int[][] temp2 = new int[temp.length+1][2];
    if(temp.length == 0){
      temp2[0][0] = t[0];
      temp2[0][1] = t[1];
      return temp2;
    }
    int label = 0 ;
    for (int i=0;i<temp2.length;i++){
      if(i == t[1]){
        temp2[i][0]=t[0];
        temp2[i][1]=t[1];
      }else {
        temp2[i][0] = temp[label][0];
        temp2[i][1] = temp[label][1];
        label ++;
      }

    }
    return temp2;
  }

以上是自己看到这道题目后的思路，现在看来其实只是做了一件事：将原来乱序的二维数组排好序，以高度【0】为第一排序规则做降序，以数量【1】为第二排序规则做升序

下面是提交后看的人家最优的答案，里面使用了优先级队列以及LinkedList，其中，优先级队列用于排序，LinkedList用于定位

优先级队列要重写compartor方法，根据之前说的顺序进行排序

代码很容易理解，只要想到了就一定会做，所以自己查的还是一种思维方式，还是需要继续认真的学习。。。

public int[][] bestReslveMethod(int[][] people){
    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(new Comparator<int[]>() {
      @Override
      public int compare(int[] a, int[] b) {
　　　　　//实现从小到大排序，方便确定位置时优先安排高度小的
        return a[0] != b[0]? Integer.compare(b[0],a[0]):Integer.compare(a[1],b[1]);
      }
    });

    LinkedList<int[]> linkedList = new LinkedList<>();

    for (int[] one : people){
      priorityQueue.offer(one);
    }

    while (!priorityQueue.isEmpty()){
      int[] one = priorityQueue.poll();
      //此处根据one[1]确定该元素的位置
      linkedList.add(one[1],one);
    }

    return linkedList.toArray(new int[people.length][2]);

  }