13 单线程 CPU----来源于陈C同学（CC）

---来源于陈C同学（CC）

---来源于陈C同学（CC）

---来源于陈C同学（CC）

13 单线程 CPU

作者: Turbo时间限制: 1S章节: 课程设计

问题描述 :

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

 

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

    如果 CPU 空闲，且任务队列中没有需要执行的任务，则 CPU 保持空闲状态。

    如果 CPU 空闲，但任务队列中有需要执行的任务，则 CPU 将会选择 执行时间最短 的任务开始执行。如果多个任务具有同样的最短执行时间，则选择下标最小的任务开始执行。

    一旦某项任务开始执行，CPU 在 执行完整个任务 前都不会停止。

    CPU 可以在完成一项任务后，立即开始执行一项新任务。

返回 CPU 处理任务的顺序。

 

示例 1：

输入：

4

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：

输入：

5

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 并进入空闲状态

 

输入说明 :

输入若干行：

第一行为一个整数n代表二维数组tasks的行数。

后面n行，每行输入两个整数代表enqueueTimei和processingTimei

提示：

    tasks.length == n

    1 <= n <= 10^5

    1 <= enqueueTimei, processingTimei <= 10^9

 

输出说明 :

输出一行整数表示结果，每个整数的后面跟一个空格。

输入范例 :

输出范例 :

#include <iostream>
#include <sstream>
#include<algorithm>
#include <cstring>
#include <vector>
#include <stdio.h>
#include<queue>
using namespace std;
vector<int> getOrder(vector<vector<int>>& tasks) {
        long nowtime = 0; // 当前时间
        //entry 按照进入时间排序 ready按照 执行时间排序 ready是动态的
        //entry {enqueuetime, i}
        //ready {processtime, i}
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> >entry, ready;
        int size = tasks.size();

        for (int i = 0; i < size; ++i){
            entry.push(make_pair(tasks[i][0], i));
        }
        vector<int> res;//用来返回
        while(!entry.empty() or !ready.empty()){ // 任务没全部执行完,任务需要entry-》ready-》完成
            if (ready.empty()){//没有待执行任务
                nowtime = entry.top().first;//时间快进到有任务放入ready
                while (!entry.empty() && nowtime == entry.top().first){ // ready是空，把同个时间的全部扔进来
                    ready.push(make_pair(tasks[entry.top().second][1], entry.top().second));
                    entry.pop();
                }
            }

            // ready 现在不为空, 运行优先级最高的任务，之后添加新任务。
            res.emplace_back(ready.top().second);
            nowtime += ready.top().first;
            ready.pop();

            while(!entry.empty() && entry.top().first <= nowtime){ //加入所有已经到达的任务
                ready.push(make_pair(tasks[entry.top().second][1], entry.top().second));
                entry.pop();
            }
        }

        return res;
    }
int main()
{
    int n;
    cin>>n;
    vector<vector<int>>task(n,vector<int>(2));
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<2;j++)
        {
            cin>>task[i][j];
        }
    }
    vector<int>ans=getOrder(task);
    for(int i=0;i<ans.size();i++)
    {
        cout<<ans[i]<<' ';
    }
}