内存是计算机重要的资源之一，程序运行的过程中必须对内存进行分配。
经典的内存分配过程是这样进行的：
1、 内存以内存单元为基本单位，每个内存单元用一个固定的整数作为标识，称为地址。地址从0开始连续排列，地址相邻的内存单元被认为是逻辑上连续的。我们把从地址i开始的s个连续的内存单元称为首地址为i长度为s的地址片。
2、 运行过程中有若干进程需要占用内存，对于每个进程有一个申请时刻T，需要内存单元数M及运行时间P。在运行时间P内（即T时刻开始，T+P时刻结束），这M个被占用的内存单元不能再被其他进程使用。
3、假设在T时刻有一个进程申请M个单元，且运行时间为P，则：
若T时刻内存中存在长度为M的空闲地址片，则系统将这M个空闲单元分配给该进程。若存在多个长度为M个空闲地址片，则系统将首地址最小的那个空闲地址片分配给该进程。
如果T时刻不存在长度为M的空闲地址片，则该进程被放入一个等待队列。对于处于等待队列队头的进程，只要在任一时刻，存在长度为M的空闲地址片，系统马上将该进程取出队列，并为它分配内存单元。注意，在进行内存分配处理过程中，处于等待队列队头的进程的处理优先级最高，队列中的其它进程不能先于队头进程被处理。
现在给出一系列描述进程的数据，请编写一程序模拟系统分配内存的过程。
解
显然需要维护一个队列，处理不能被立即处理的进程，此外注意到数据范围只有10000,而有注意到我们需要查询每个进程能够使用的内存空间，（显然空间不能暴力存下来），我们可以考虑用三元组((l,r,b))表示一段空间([l,r])表示这段空间的位置,b表示这段内存是否被占用（１占用，０没占用）。
数据范围只有10000，于是可以暴力查询是否有空闲空间，而对于内存的合并和分离，我们就可以利用链表实现。
现在的问题是对于时间的处理，不可能取枚举时间，但是注意到整个题目，只有三个主体，队列中的等待元素，申请使用内存的程序，还有在占用内存的程序的结束，其中不难自我归纳出优先级为占用结束，等待元素，申请使用内存，而占用结束，显然不能一个数组保存下来，于是考虑优先队列，存储结束时间，每次能够知道哪个程序首先结束（注意一个细节，如果同时结束的话，需要特判，让它们先结束，再进行下一步）。
优先队列还要顺便维护它在链表中的位置，然后特判是否能够合并相邻的内存，再将其标记为０，然后再执行队列中的元素是否能够申请到内存，最后才是按正常顺序申请内存的程序，按照这个顺序，思维就不会乱了。（注意到结束的程序必然是在按正常顺序的程序申请开始时间之前）。
时间复杂度太玄学，不予分析。
参考代码：
#include <iostream>
#include <cstdio>
#include <queue>
#define il inline
#define ri register
#define Size 15000
using namespace std;
template<class free>
struct heap{
free a[Size];int n;
il void push(free x){
a[++n]=x;ri int p(n);
while(p>1)
if(a[p]<a[p>>1])
swap(a[p],a[p>>1]),
p>>=1;
else break;
}il void pop(){
a[1]=a[n--];ri int p(1),s(2);
while(s<=n){
if(s<n&&a[s+1]<a[s])++s;
if(a[s]<a[p])
swap(a[s],a[p]),
p=s,s<<=1;
else break;
}
}
};
template<class free>
struct list{
struct iter{
iter*pre,*next;free v;
}*head,*tail,*lt;
il void initialize(){
head=new iter(),tail=new iter();
head->next=tail,tail->pre=head;
}
il void insert(iter *p,free x){
lt=new iter{p->pre,p,x};
p->pre->next=lt,p->pre=lt;
}
il void erase(iter *p){
p->next->pre=p->pre;
p->pre->next=p->next;
delete p;
}
il void recycle(){
while(head!=tail)
head=head->next,
delete head->pre;
delete tail;
}
};
struct Wait{
int m,p;
};
struct mem{
int l,r;bool used;
};
struct take{
int t;list<mem>::iter *p;
il bool operator<(const take&x)const{
return t<x.t;
}
};
int tim;
queue<Wait>D;
list<mem>L;heap<take>H;
int t,m,p;
il bool give(int,int);
il void read(int&),release();
int main(){L.initialize();
int n,ans(0);read(n),L.insert(L.tail,{0,n-1});
while(read(t),read(m),read(p),t||m||p){
while(H.a[1].t<t&&H.n){
tim=H.a[1].t+1,release();if(H.n&&H.a[1].t+1==tim)continue;
while(D.size())if(give(D.front().m,D.front().p))D.pop();
else break;
}tim=t;if(!give(m,p))D.push({m,p}),++ans;
}while(H.n){
tim=H.a[1].t+1,release();if(H.n&&H.a[1].t+1==tim)continue;
while(D.size())if(give(D.front().m,D.front().p))D.pop();
else break;
}
printf("%d
%d",tim,ans),L.recycle();
return 0;
}
il void release(){
if(!H.n)return;
list<mem>::iter *i(H.a[1].p);
if(i->pre!=L.head&&!i->pre->v.used)
i->v.l=i->pre->v.l,L.erase(i->pre);
if(i->next!=L.tail&&!i->next->v.used)
i->v.r=i->next->v.r,L.erase(i->next);
i->v.used=0,H.pop();
}
il bool give(int m,int p){list<mem>::iter *i;
for(i=L.head->next;i!=L.tail;i=i->next)
if(!i->v.used&&i->v.r-i->v.l+1>=m){
int mid(i->v.l+m-1);
if(mid<i->v.r)
L.insert(i->next,{mid+1,i->v.r,0}),i->v.r=mid;
i->v.used=1,H.push({tim+p-1,i});return true;
}return false;
}
il void read(int &x){
x^=x;ri char c;while(c=getchar(),c<'0'||c>'9');
while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
}