poj-1193内存管理

#include<iostream>
#include<list>
#include<queue>

int n,t,m,p;
int wt_num;

struct PEB
{
	friend bool operator<(const PEB& l,const PEB& r);
	int start;
	int mem;
	int st_m;
	int ed_m;
	int time;
	int cpu_time;
};

bool operator<(const PEB&l ,const PEB& r)
{
	return  l.cpu_time>r.cpu_time;
}

std::list<std::pair<int,int> > free_list;
std::queue<PEB> wait_que;
std::priority_queue<PEB> run_que;
std::priority_queue<std::pair<PEB,bool> > cpu_time;

typedef std::list<std::pair<int,int> >::iterator fl_itr;


void inti()
{
	free_list.push_back(std::make_pair(0,n-1));
}

bool alloc(int t,int m,int p,bool wait)
{
	PEB tmp;
	tmp.start=t;
	tmp.mem=m;
	tmp.time=p;
	fl_itr iter;
	for(iter=free_list.begin();iter!=free_list.end();iter++){
		if((iter->second-iter->first+1)>=m){
			tmp.st_m=iter->first;
			tmp.ed_m=iter->first+m-1;
			run_que.push(tmp);
			std::cout<<"运行"<<std::endl;
			if(iter->second-iter->first+1==m){
				free_list.erase(iter);
			}else{
				iter->first+=m;
			}
			return true;
			//break;
		}
	}
	if(iter==free_list.end()){
		wait_que.push(tmp);
		wt_num++;
		std::cout<<"等待"<<std::endl;
	}
	return false;
}

void free(int t,int m,int p)
{
	PEB tmp;
	fl_itr iter;
	while (!run_que.empty()){
		tmp=run_que.top();
		if(tmp.start+tmp.time<=t){
			run_que.pop();
			std::cout<<"释放"<<std::endl;
			for(iter=free_list.begin();iter!=free_list.end();iter++){
				if(iter->second+1==tmp.start){
					iter->second+=tmp.mem;
				}else if(iter->first-1==tmp.start+m){
					iter->first-=tmp.mem;
				}
			}
			if(iter==free_list.end()){
				free_list.push_back(std::make_pair(tmp.st_m,tmp.ed_m));
			}
		}else{
			break;
		}
	}

	while (!wait_que.empty())
	{
		tmp=wait_que.front();
		if(alloc(tmp.start,tmp.mem,tmp.time,true)){
			wait_que.pop();
		}else{
			break;
		}
	}


}


int main()
{
	PEB tmp;
	std::cin>>n;
	inti();
	while (std::cin>>t>>m>>p&&t&&m&&p){
		tmp.start=t-1;
		tmp.mem=m;
		tmp.time=p;
	    tmp.cpu_time=t-1;
		cpu_time.push(std::make_pair(tmp,true));
		tmp.cpu_time=t-1+p-1;
		cpu_time.push(std::make_pair(tmp,false));
	}
	while (!cpu_time.empty()){
		tmp=cpu_time.top().first;
		if(cpu_time.top().second==true){
			alloc(tmp.start,tmp.mem,tmp.time,false);
		}else{
			free(tmp.start,tmp.mem,tmp.time);
		
		}
		cpu_time.pop();
	}

	std::cout<<wt_num<<std::endl;
	getchar();
	getchar();
}