P2278 [HNOI2003]操作系统 优先级队列

题目描述

写一个程序来模拟操作系统的进程调度。假设该系统只有一个CPU，每一个进程的到达时间，执行时间和运行优先级都是已知的。其中运行优先级用自然数表示，数字越大，则优先级越高。

如果一个进程到达的时候CPU是空闲的，则它会一直占用CPU直到该进程结束。除非在这个过程中，有一个比它优先级高的进程要运行。在这种情况下，这个新的（优先级更高的）进程会占用CPU，而老的只有等待。

如果一个进程到达时，CPU正在处理一个比它优先级高或优先级相同的进程，则这个（新到达的）进程必须等待。

一旦CPU空闲，如果此时有进程在等待，则选择优先级最高的先运行。如果有多个优先级最高的进程，则选择到达时间最早的。

输入输出格式

输入格式：

 

输入包含若干行，每一行有四个自然数（均不超过10^8），分别是进程号，到达时间，执行时间和优先级。不同进程有不同的编号，不会有两个相同优先级的进程同时到达。输入数据已经按到达时间从小到大排序。输入数据保证在任何时候，等待队列中的进程不超过15000个。

 

输出格式：

 

按照进程结束的时间输出每个进程的进程号和结束时间。

 

输入输出样例

输入样例#1： 复制

1 1 5 3 
2 10 5 1 
3 12 7 2 
4 20 2 3 
5 21 9 4 
6 22 2 4 
7 23 5 2 
8 24 2 4 

输出样例#1： 复制

1 6
3 19
5 30
6 32
8 34
4 35
7 40
2 42

主要思路:模拟，优先队列  

考虑维护一个优先队列，重载小于号，对于这个小于号的定义为如果两个工作等级相同，那么按照到达时间先后排序，否则按照工作等级高低排序

然后每输入一个工作，考虑在这个工作执行之前所有可以被完成的工作，当已经不存在可以被完成的工作但队列非空的时候，表示目前的工作只能被完成一部分，那么处理这个部分并更新当前时间和这个工作完成需要的时间

对于在输入结束后还没有被完成的工作，其已经在优先队列中按照顺序排序，只需要从队头开始完成并输出即可

注意点:

1.优先队列中定义的是小于号，相关大小比较需要相反

2.scanf在成功输入时的返回值是输入个数，失败时返回值是-1；

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
struct node {
	int id,rea,nee,lev;
	bool operator <(const node &rhs) const {
		return lev==rhs.lev?rea>rhs.rea:lev<rhs.lev;
	}
};
node pre;
int a,b,c,d,tnow=0;
priority_queue<node>q;
int main() {
	while(scanf("%d %d %d %d",&a,&b,&c,&d)!=EOF) {
		pre.id=a;
		pre.rea=b;
		pre.nee=c;
		pre.lev=d;
		while(!q.empty()&&tnow+q.top().nee<=pre.rea) {
			node fr=q.top();
			q.pop();
			printf("%d %d\n",fr.id,fr.nee+tnow);
			tnow+=fr.nee;
		}
		if(!q.empty()) {
			node fr=q.top();
			q.pop();
			fr.nee=fr.nee-pre.rea+tnow;
			q.push(fr);
		}
		q.push(pre);
		tnow=pre.rea;
	}
	while(!q.empty()) {
		node fr=q.top();
		q.pop();
		tnow+=fr.nee;
		printf("%d %d\n",fr.id,tnow);
	}
	return 0;
}

我的思路

#include<stdio.h> 
#include<functional> 
#include<queue> 
#include<vector>
#include<iostream> 
#include<sstream> 
using namespace std;

 
struct node { 
    int id; 
    int istart;
    int pri;
    int leftTimes;
    bool operator < (const node &a) const { 
        if(pri!=a.pri) return pri<a.pri;
        else return istart>a.istart;
    } 
};  
vector<node> vn;
int main()
{
    
    priority_queue<node>que;  
    int id1,is1,it1,pri1;
    node tnode;
    string line;
	getline(cin,line);
    while(!line.empty())
	{
            istringstream is(line);
            is>>id1>>is1>>it1>>pri1;
			tnode.id=id1;
	    	tnode.istart=is1;
	    	tnode.leftTimes=it1;
	    	tnode.pri=pri1;
	    	vn.push_back(tnode);
            getline(cin,line);
	}


	int ib=1,index=0;
	do{
		while(vn[index].istart<=ib)
		{
			que.push(vn[index]);
			index++;
		}
		ib++;
		if(!que.empty())
		{
		   tnode=que.top();
		   que.pop();
		   tnode.leftTimes-=1;
		   if(tnode.leftTimes>0)
		   {
		   	  que.push(tnode);
		   }
		   else
		   {
		   	 cout<<tnode.id<<" "<<ib<<endl;
		   }
		}
	}while(index<vn.size()||!que.empty());
    return 0;
}