#include
using?namespace?std;

int?position_now=0;
int?scale_now=640;

typedef?struct?Work_node
{
	int?work;
	int?position;
	int?scale;
	struct?Work_node?*pNext;
	
}WORK_NODE*PWORK_NODE;//?WORK_NODE等價于struct?Work_node；PWORK_NODE等價于struct?Work_node*；數(shù)據(jù)類型

PWORK_NODE?work_first=（PWORK_NODE）malloc（sizeof（WORK_NODE））;
PWORK_NODE?work_tail=work_first;
int?work_count=0;?


void?Insert_List_work（int?workint?scale）
{
	
	PWORK_NODE?m=（PWORK_NODE）malloc（sizeof（WORK_NODE））;
	
	m->work=work;
	m->scale=scale;
	m->position=position_now;
	m->pNext=NULL;
	

if（work_count==0）
		work_first=work_tail=m;
	
	else
	{
		work_tail->pNext=m;
		work_tail=m;
	}
	
	
	work_count++;

	
}

void?Delete_List_work（int?work）
{
	PWORK_NODE?p=work_first;
	PWORK_NODE?m=work_first;
	while（p->work!=work）
	{
		m=p;
		p=p->pNext;		
	}
	position_now=p->position;
	scale_now=p->scale;	
	if（p==work_first）
	{
		work_first=p->pNext;
	}
	else
	{
		m->pNext=p->pNext;
		
	}

	work_count--;


}

typedef?struct?Space_node
{
	int?position;
	int?scale;
	struct?Space_node?*pNext;
	
}SPACE_NODE*PSPACE_NODE;//?SPACE_NODE等價于struct?Space_node；*PSPACE_NODE等價于struct?Space_node*；數(shù)據(jù)類型

PSPACE_NODE?space_first=（PSPACE_NODE）malloc（sizeof（SPACE_NODE））;
int?space_count=1;

void?Allocate_List（int?scale）
{

	if（scale_now==640）
	{
		PSPACE_NODE?m0=（PSPACE_NODE）malloc（sizeof（SPACE_NODE））;
		m0->position=0;
		m0->scale=640;
		m0->pNext=NULL;
		space_first=m0;
		
	}
	
	PSPACE_NODE?p=space_first;
	if（p->scale		p=p->pNext;

	p->position+=scale;
	p->scale-=scale;
	position_now=p->position;
	scale_now=p->scale;	?
	
	

}
////////////////首次適應算法///////////////////////
/*
void?Free_List（）
{
	
	PSPACE_NODE?m=（PSPACE_NODE）malloc（sizeof（Space_node））;
	m->position=position_now;
	m->scale=scale_now;

	PSPACE_NODE?p=space_first;
	PSPACE_NODE?n=space_first;

	while（p->position	{
		n=p;
		p=p->pNext;
		
	}	
	if（p==space_first）
	{
		if（m->position+m->scale==p->position）
		{
			p->position-=m->scale;
			p->scale+=m->scale;
		}
		else
		{
			space_first=m;
			m->pNext=p;
			space_count++;
		}
	}
	
	else?if（n->position+n->scale==m->position）
	{
		n->scale+=m->scale;
		free（m）;
	}
	else?if（n==space_first）
	{
		space_first=m;
		m->pNext=p;
		space_count++;
	}
	else?
	{
		m->pNext=p->pNext;
		n->pNext=m;
		space_count++;
	}		
}*/
/////////////////////////////////////////////

////////////////////最佳適應算法/////////////////////////
void?Free_List（）
{
	
	PSPACE_NODE?m=（PSPACE_NODE）malloc（sizeof（Space_node））;
	m->position=position_now;
	m->scale=scale_now;


	PSPACE_NODE?t=space_first;
	int?flag=