LeetCode_区间问题_中等_1834. 单线程 CPU

红太狼 2023-10-06 22:42 43阅读 0赞

#### 目录 ####

*  1.题目
 *  2.思路
 *  3.代码实现（Java）

## 1.题目 ##

给你一个二维数组 tasks ，用于表示 n 项从 0 到 n - 1 编号的任务。其中 **tasks\[i\] = \[enqueueTimei, processingTimei\] 意味着第 i 项任务将会于 enqueueTimei 时进入任务队列，需要 processingTimei 的时长完成执行。**

现有一个单线程 CPU ，**同一时间只能执行最多一项任务**，该 CPU 将会按照下述方式运行：

如果 CPU 空闲，且任务队列中没有需要执行的任务，则 CPU 保持空闲状态。  
如果 CPU 空闲，但任务队列中有需要执行的任务，则 CPU 将会**选择执行时间最短的任务开始执行**。如果多个任务具有同样的最短执行时间，则选择下标最小的任务开始执行。  
一旦某项任务开始执行，CPU 在执行完整个任务前都不会停止。  
CPU 可以在完成一项任务后，立即开始执行一项新任务。  
**返回 CPU 处理任务的顺序。**

**示例 1：**

输入：tasks = [[1,2],[2,4],[3,2],[4,1]]
    输出：[0,2,3,1]
    解释：事件按下述流程运行： 
    - time = 1 ，任务 0 进入任务队列，可执行任务项 = {
        0}
    - 同样在 time = 1 ，空闲状态的 CPU 开始执行任务 0 ，可执行任务项 = {
        }
    - time = 2 ，任务 1 进入任务队列，可执行任务项 = {
        1}
    - time = 3 ，任务 2 进入任务队列，可执行任务项 = {
        1, 2}
    - 同样在 time = 3 ，CPU 完成任务 0 并开始执行队列中用时最短的任务 2 ，可执行任务项 = {
        1}
    - time = 4 ，任务 3 进入任务队列，可执行任务项 = {
        1, 3}
    - time = 5 ，CPU 完成任务 2 并开始执行队列中用时最短的任务 3 ，可执行任务项 = {
        1}
    - time = 6 ，CPU 完成任务 3 并开始执行任务 1 ，可执行任务项 = {
        }
    - time = 10 ，CPU 完成任务 1 并进入空闲状态

**示例 2：**

输入：tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]
    输出：[4,3,2,0,1]
    解释：事件按下述流程运行： 
    - time = 7 ，所有任务同时进入任务队列，可执行任务项  = {
        0,1,2,3,4}
    - 同样在 time = 7 ，空闲状态的 CPU 开始执行任务 4 ，可执行任务项 = {
        0,1,2,3}
    - time = 9 ，CPU 完成任务 4 并开始执行任务 3 ，可执行任务项 = {
        0,1,2}
    - time = 13 ，CPU 完成任务 3 并开始执行任务 2 ，可执行任务项 = {
        0,1}
    - time = 18 ，CPU 完成任务 2 并开始执行任务 0 ，可执行任务项 = {
        1}
    - time = 28 ，CPU 完成任务 0 并开始执行任务 1 ，可执行任务项 = {
        }
    - time = 40 ，CPU 完成任务 1 并进入空闲状态

**提示：**  
tasks.length == n  
1 <= n <= 105  
1 <= enqueueTimei, processingTimei <= 109

来源：力扣（LeetCode）  
链接：https://leetcode.cn/problems/single-threaded-cpu

## 2.思路 ##

（1）区间问题

## 3.代码实现（Java） ##

//思路1————区间问题
    public int[] getOrder(int[][] tasks) {
        
        //一共有 n 个任务
        int n = tasks.length;
        ArrayList<int[]> triples = new ArrayList<>();
        for (int i = 0; i < n; i++) {
        
            triples.add(new int[]{
        tasks[i][0], tasks[i][1], i});
        }
        //将任务按照其开始的时间进行升序排序
        triples.sort((a, b) -> {
        
            //若返回值为正数，则交换 a 和 b
            return a[0] - b[0];
        });
        //按照任务的执行时间进行升序排序，若执行时间相同，则按照下标进行升序排序
        PriorityQueue<int[]> pqueue = new PriorityQueue<>((a, b) -> {
        
            if (a[1] != b[1]) {
        
                //比较执行时间
                return a[1] - b[1];
            } else {
        
                //比较下标
                return a[2] - b[2];
            }
        });
        ArrayList<Integer> res = new ArrayList<>();
        //记录任务完成的时间线
        int timeline = 0;
        int i = 0;
        while (res.size() < n) {
        
            if (!pqueue.isEmpty()) {
        
                //完成队列中的一个任务
                int[] triple = pqueue.poll();
                res.add(triple[2]);
                timeline += triple[1];
            } else if (i < n && triples.get(i)[0] > timeline) {
        
                //队列为空可能因为还没到开始时间，故可直接把时间线推进到最近任务的开始时间
                timeline = triples.get(i)[0];
            }
            //由于时间线的推进，会产生可以开始执⾏的任务
            while (i < n && triples.get(i)[0] <= timeline) {
        
                pqueue.offer(triples.get(i));
                i++;
            }
        }
        //将 List 转换为 int[]
        return res.stream().mapToInt(Integer::valueOf).toArray();
    }