内存分配

内存分配

内存是计算机重要的资源之一，程序运行的过程中必须对内存进行分配。

经典的内存分配过程是这样进行的：

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();
}