【LEETCODE】73、根据身高重建队列 第406题

说实话，这道题我没想出来，但是看解题报告题解比较让人觉得眼前一亮，这里记录下来

package y2019.Algorithm.greedy.medium;
 
import java.util.Arrays;
import java.util.LinkedList;
 
/**
 * @Auther: xiaof
 * @Date: 2019/12/19 09:05
 * @Description: 406. 根据身高重建队列
 *
 * 假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(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
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 *
 */
public class ReconstructQueue {
 
    /**
     * https://leetcode-cn.com/problems/queue-reconstruction-by-height/solution/406-gen-ju-shen-gao-zhong-jian-dui-lie-pai-xu-hou-/
     * 执行用时 : 10 ms , 在所有 java 提交中击败了 76.85% 的用户
     * 内存消耗 : 40 MB , 在所有 java 提交中击败了 99.37% 的用户
     */
    public int[][] solution(int[][] people) {
        //1.思路就是先按照升高排序,先按照升高排序，升高相同的按照第二个前面几个人进行排序
        Arrays.sort(people, (v1, v2) -> v1[0] == v2[0] ? v1[1] - v2[1] : v2[0] - v1[0]);
        //2.然后遍历数组，依次吧中的升高添加到数据中，然后把
        //3.根据排好顺序的list，吧第二个参数作为下坐标add进入队列中
        LinkedList<int[]> res = new LinkedList<>();
        //因为已经加入linked的数据都是比当前遍历到的数据大的值，那么只要知道前面有几个比这个数大，直接插入即可
        for (int[] i : people) {
            res.add(i[1], i);
        }
 
        return res.toArray(new int[res.size()][2]);
 
    }
 
    public static void main(String[] args) {
        int[][] param1 = {{7,0}, {4,4}, {7,1}, {5,0}, {6,1}, {5,2}};
 
        ReconstructQueue fuc = new ReconstructQueue();
        System.out.println("需要添加对应的数据:");
        int[][] res = fuc.solution(param1);
        System.out.println("");
        System.out.println(res);
 
    }
 
}

2020年1月19日08:54:11 add  》》》》》》》》》》》》》》》》》

如果使用快排进行排序速度会更快

package y2019.Algorithm.greedy.medium;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
 
/**
 * @Auther: xiaof
 * @Date: 2019/12/19 09:05
 * @Description: 406. 根据身高重建队列  贪心算法
 *
 * 假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(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
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 *
 */
public class ReconstructQueue {
 
    //使用快排
 
    /**
     * 执行用时 : 5 ms , 在所有 Java 提交中击败了 99.95% 的用户
     * 内存消耗 : 43.1 MB , 在所有 Java 提交中击败了 93.71% 的用户
     * @param people
     * @return
     */
    public int[][] solution2(int[][] people) {
        //先进行快排
        quikSort(people, 0, people.length);
        //按照顺序插入list
//        List<int[]> res = new ArrayList();
        LinkedList<int[]> res = new LinkedList<>();
        for (int[] i : people) {
            res.add(i[1], i);
        }
 
        return res.toArray(new int[res.size()][]);
    }
 
    public void quikSort(int[][] people, int start, int end) {
        if (start < end) {
            int mid = midSite(people, start, end);
            quikSort(people, start, mid);
            quikSort(people, mid + 1, end);
        }
    }
 
    public int midSite(int[][] people, int start, int end) {
        if (start >= end) {
            return start;
        }
 
        int midValue[] = people[start], l = start, r = end;
        do {
            do {
                ++l;
            } while (l < end && compare(people[l], midValue));
 
            do {
                --r;
            } while (start < r && compare(midValue, people[r]));
 
            //如果没有超出范围，交换位置
            if (l < r) {
                int[] tmp = people[l];
                people[l] = people[r];
                people[r] = tmp;
            }
        } while (l < r);
 
        //最后吧之前中间位置数据交换回来
        people[start] = people[r];
        people[r] = midValue;
 
        return r;
    }
 
    //这里我们按照从大到小排序
    public boolean compare(int[] p1, int[] p2) {
        //比较，优先根据第二个数据比较，然后根据第一个数据比较大小
        if (p1[0] != p2[0]) {
            return p1[0] > p2[0];
        } else {
            //如果相等,第一个数据
            return p1[1] < p2[1];
        }
    }
 
    public static void main(String[] args) {
        int[][] param1 = {{7,0}, {4,4}, {7,1}, {5,0}, {6,1}, {5,2}};
 
        ReconstructQueue fuc = new ReconstructQueue();
        System.out.println("需要添加对应的数据:");
        int[][] res = fuc.solution2(param1);
        System.out.println("");
        System.out.println(res);
 
    }
}