课 程 设 计
课程名称 数据结构
题目名称 电梯模拟(难度1.4)
学生学院
专业班级
学 号
学生姓名
指导教师
2019 年 1 月 9日
本程序是实现电梯的模拟运行，同时还包含模拟多梯运行的实现：
1 、基本要求
（1）模拟某校五层教学楼的电梯系统。该楼有一个自动电梯，能在每层停留。五个楼层由下至上依次称为地下层、第一层、第二层、第三层和第四层，其中第一层是大楼的进出层，即是电梯的“本垒层”，电梯“空闲”时，将来到该层候命。
（2）乘客可随机地进出于任何层。对每个人来说，他有一个能容忍的最长等待时间，一旦等候电梯时间过长，他将放弃。
（3）模拟时钟从0开始，时间单位为0.1秒。人和电梯的各种动作均要耗费一定的时间单位（简记为t)，比如：
有人进出时，电梯每隔40t测试一次，若无人进出，则关门；
关门和开门各需要20t；
每个人进出电梯均需要25t；
如果电梯在某层静止时间超过300t，则驶回1层候命。
（4）按时序显示系统状态的变化过程：发生的全部人和电梯的动作序列。
2 、输入规定
（1）输入形式和输入值范围：键盘输入，范围：Time时钟是500-10000之间，楼层Floor是0至4，用户数ID是10000
（2）输出的形式：程序内存输出
（3）程序能达到的功能：日常电梯所拥有的基本功能，能处理用户的上下电梯，同时也能处理因超时而离去的情况
（4）测试数据
有横线的是输入，其他是输出结果
第1用户走进来
他在哪层楼电梯的门前:__1__
他要去哪层楼:__4__
他能容忍的等候时间:__1000
下一个人出现的时间间隔:__1__
第2用户走进来
他在哪层楼电梯的门前:__4__
他要去哪层楼:__0__
他能容忍的等候时间:__10_
下一个人出现的时间间隔:__1__
第3用户走进来
他在哪层楼电梯的门前:__3__
他要去哪层楼:__2__
他能容忍的等候时间:__1000
下一个人出现的时间间隔:__1__
第4用户走进来
他在哪层楼电梯的门前:__0__
他要去哪层楼:__4__
他能容忍的等候时间:__3000
下一个人出现的时间间隔:__10000
用户2放弃了等候然后离开了
电梯门开了
用户1走进电梯
正在关门
电梯门关了
电梯已加速上升!
电梯正在上升!现已到了2层!
电梯正在上升!现已到了3层!
电梯正在上升!现已到了4层!
电梯停了，当前层是4
电梯门开了
用户1走出了电梯
正在关门
电梯门关了
电梯门开了
正在关门
电梯门关了
电梯已加速下降!
电梯正在下降!现已到了3层!
电梯停了，当前层是3
电梯门开了
用户3走进电梯
正在关门
电梯门关了
电梯已加速下降!
电梯正在下降!现已到了2层!
电梯停了，当前层是2
电梯门开了
用户3走出了电梯
正在关门
电梯门关了
电梯已加速下降!
电梯正在下降!现已到了1层!
电梯正在下降!现已到了0层!
电梯停了，当前层是0
电梯门开了
用户4走进电梯
正在关门
电梯门关了
电梯已加速上升!
电梯正在上升!现已到了1层!
电梯正在上升!现已到了2层!
电梯正在上升!现已到了3层!
电梯正在上升!现已到了4层!
电梯停了，当前层是4
电梯门开了
用户4走出了电梯
正在关门
电梯门关了
长时间没人请求电梯!将进入1层
电梯已加速下降!
电梯正在下降!现已到了3层!
电梯正在下降!现已到了2层!
电梯正在下降!现已到了1层!
电梯停了，当前层是1
现在在1层，无人请求电梯!
- 本程序所用到的宏定义及数据类型定义如下：
（使用头文件）
#define MaxPeople 1000000 //最多的用户
#define MaxFloor 5 //最高楼层
#define MaxTime 10000 //最长的过程时间
#define BaseFloor 1 //本垒层
#define Accelerate 15 //加速时间
#define UpTime 51 //上升时间
#define DownTime 61 //下降时间
#define UpDecelerate 14 //上升减速
#define DownDecelerate 23 //下降减速
#define Speeder 15
#define DoorTime 20
#define PeopleTime 25
#define CarTime 40
#define BackTime 300
/**三种状态**/
#define GoingUp 1 //上行
#define GoingDown -1 //下行
#define Idle 0 //停候
全局变量
int Time; //时间表
int Id; //用户
int Floor; //当前位置
int D1; //值为0，除非人们正在进入和离开电梯
int D2; //值为0，如果电梯已经在某层停候300t以上
int D3; //值为0，除非电梯门正开着又无人进出电梯
//int D4; //值为0，除非中途有人进人
int doorclosing;
int doorclosingtime;
int testdoortime;
int backfirsttime;
int State; //电梯的当前状态（GoingUp, GoingDown, Idle）
int preState; //电梯先前的状态（GoingUp, GoingDown, Idle）
int Again;
/**人和电梯操作**/
int Exist[MaxPeople]; //用户是否存在队列中
int Belong[MaxPeople]; //用户在哪里上的楼
int CallUp[5]; //电梯外向上按钮
int CallDown[5]; //电梯外向下按钮
int CallCar[5]; //电梯内按钮
/**集合定义**/
//人的行为
typedef struct people{
int Id; //该用户的编号
int entertime; //进入时间
int InFloor; //他所在的楼层
int OutFloor; //他要去哪层楼
int GiveupTime; //他能容忍的等候时间
struct people* pre;
struct people* next;
}people,*People;
//电梯的行为
typedef struct car{
int Id;
struct car* next;
}car,*Car;
//时序行为
typedef struct act{
int time; //时间限制
People pt; //用户的指针
void(*fn)(People pt); //属于操作
struct act* next;
}act,*Act;
/**人行为队列和电梯栈**/
people QueueUp[5]={0,};//等待上楼的用户
people QueueDown[5]={0,};//等待下楼的用户
car Stack[5]={0,};//电梯里的用户
/**时序监控活动**/
act activity={0,0,NULL,NULL}；
所有的数据类型的定义：
void init()；//初始化
void AddQueueUp(People &p,int floor)；//加入等候队列
void AddQueueDown(People &p,int floor)// 加入等候队列
void AddAct(int time,People ap,void(*fn)(People pt))// 加入时序活动
void remove(People p)//删除等候超时
void input(People pt)//程序输入
void doclosedoor(People ap)//关门
void testinout(People o)//测试是否关门
void doin(People p)//用户进入电梯
void doout(People p)//用户走出电梯
void doopendoor(People p)//打开门
void doslow(People ap)//停电梯
void doup(People ap)//电梯上升
void dodown(People ap)//电梯下降
void domove(People ap)//电梯减速
void tofirst(People ap)//电梯去第一层
int getW()//电梯内需函数
int GetUp()
int GetDown()
void Controler()//电梯调度函数
void solve()//处理函数
伪代码：
/**初始化**/
void init(){
Floor=BaseFloor;
D1=D2=D3=0;
Id=0;
State=Idle;
preState=Idle;
Again=0;
doorclosing = 0;
}
/**加入等候队列**/
void AddQueueUp(People &p,int floor){
People q=&QueueUp[floor];
while(q->next!=NULL){
q=q->next;
}
q->next=p;
p->pre=q;
}
void AddQueueDown(People &p,int floor){
People q=&QueueDown[floor];
while(q->next!=NULL){
q=q->next;
}
q->next=p;
p->pre=q;
}
/**加入时序活动**/
void AddAct(int time,People ap,void(*fn)(People pt)){
int totalTime=Time+time;
Act p=&activity;
Act q=(Act)malloc(sizeof(act));
q->time=totalTime;
if(ap!=NULL){
加入时序活动
}
else q->pt=NULL;
}
/**电梯和人的行为操作函数**/
void remove(People p){
if(Exist[p->Id]==0||(p->InFloor==Floor&&State==Idle))return;
printf("/***************************/\n");
printf("用户%d放弃了等候然后离开了\n",p->Id);
printf("/***************************/\n\n");
}
/**操作**/
/**输入**/
void input(People pt){
int infloor,outfloor,giveuptime,intertime;
while(1){
printf("/**************************************/\n");
printf("第%d用户走进来\n",Id+1);
printf("他在哪层楼电梯的门前:_____\b\b\b");
scanf("%d",&infloor);
printf("他要去哪层楼:_____\b\b\b");
scanf("%d",&outfloor);
printf("他能容忍的等候时间:_____\b\b\b");
scanf("%d",&giveuptime);
printf("下一个人出现的时间间隔:_____\b\b\b");
scanf("%d",&intertime);
printf("/**************************************/\n\n");
if(infloor>=0&&infloor=0&&outfloor
break;
}
printf("/*********************/\n");
printf("输入错误，请重新输入\n");
printf("/*********************/\n\n");
}
}
/**关门**/
void doclosedoor(People ap)｛
if(time)closedoor;
｝
/**测试关门**/
void testinout(People o)｛
if(state==Idle&&time){
关门
}
｝
/**进门出门**/
void doin(People p){
if(queue!=NULL)｛人进电梯｝
｝
void doout(People p) {
if(queue!=NULL)｛人出电梯｝
｝
/**电梯门开关**/
void doopendoor(People p){
if(time)开门;}
/**调度函数**/
void Controler(){
if(state==Idle){}
else if(state==goingUp){}
else {}
}
/**处理**/
void solve(){
while(Time<=MaxTime){
do{
Again=0;
Controler();
}while(Again==1);
Act p=activity.next;
if(p==NULL)Time=MaxTime;
while(p&&p->time<=Time){
activity.next=p->next;
p->fn(p->pt);
free(p);
p=activity.next;
}
Time++;
//printf("%d\n",Time);
}
}
1程序的逻辑连接比较复杂，同时又是一个由时钟激发的程序，所以在每一步的连接都要花时间去考虑时间复杂度和逻辑合理度，对于调度函数要把每个变量合理利用
2对于复杂度，我通过多添加一个变量让每一步都能知道操作是什么，然后可以O(1)和O（n）进行删除和加入
3调试时通过输出特殊值一步一步的调试到错的地方
经验和体会是通过几百行的代码的调试我对代码的书写功能和调试功能更加熟练
运行界面已经通过输出函数告知要操作的步骤，同时该文件为c++文件
以下是多部电梯，代码在源文件里
报告：
报告内容：□详细 □完整 □基本完整 □不完整
设计方案：□非常合理 □合理 □基本合理 □较差
算法实现：□全部实现 □基本实现 □部分实现 □实现较差
测试样例：□非常完备 □完备 □基本完备 □不完备
文档格式：□规范 □比较规范 □基本规范 □不规范
答辩：
□理解题目透彻，回答问题流利
□理解题目较透彻，回答问题基本正确
□部分理解题目，部分问题回答正确
□未能完全理解题目，答辩情况较差
总评成绩：
□优秀 □良好 □中等 □及格 □不及格
代码
#include
using namespace std;
/**常量定义**/
#define MaxPeople 1000000 //最多的用户
#define MaxFloor 5 //最高楼层
#define MaxTime 10000 //最长的过程时间
#define BaseFloor 1 //本垒层
#define Accelerate 15 //加速时间
#define UpTime 51 //上升时间
#define DownTime 61 //下降时间
#define UpDecelerate 14 //上升减速
#define DownDecelerate 23 //下降减速
#define Speeder 15
#define DoorTime 20
#define PeopleTime 25
#define CarTime 40
#define BackTime 300
/**三种状态**/
#define GoingUp 1 //上行
#define GoingDown -1 //下行
#define Idle 0 //停候
/**全局变量**/
int Time; //时间表
int Id; //用户
int Floor; //当前位置
int D1; //值为0，除非人们正在进入和离开电梯
int D2; //值为0，如果电梯已经在某层停候300t以上
int D3; //值为0，除非电梯门正开着又无人进出电梯
//int D4; //值为0，除非中途有人进人
int doorclosing;
int doorclosingtime;
int testdoortime;
int backfirsttime;
int State; //电梯的当前状态（GoingUp, GoingDown, Idle）
int preState; //电梯先前的状态（GoingUp, GoingDown, Idle）
int Again;
/**人和电梯操作**/
int Exist[MaxPeople]; //用户是否存在队列中
int Belong[MaxPeople]; //用户在哪里上的楼
int CallUp[5]; //电梯外向上按钮
int CallDown[5]; //电梯外向下按钮
int CallCar[5]; //电梯内按钮
/**集合定义**/
//人的行为
typedef struct people{
int Id; //该用户的编号
int entertime; //进入时间
int InFloor; //他所在的楼层
int OutFloor; //他要去哪层楼
int GiveupTime; //他能容忍的等候时间
struct people* pre;
struct people* next;
}people,*People;
//电梯的行为
typedef struct car{
int Id;
struct car* next;
}car,*Car;
//时序行为
typedef struct act{
int time; //时间限制
People pt; //用户的指针
void(*fn)(People pt); //属于操作
struct act* next;
}act,*Act;
/**人行为队列和电梯栈**/
people QueueUp[5]={0,};
people QueueDown[5]={0,};
car Stack[5]={0,};
/**时序监控活动**/
act activity={0,0,NULL,NULL};
/**初始化**/
void init(){
Floor=BaseFloor;
D1=D2=D3=0;
Id=0;
State=Idle;
preState=Idle;
Again=0;
doorclosing = 0;
}
/**加入等候队列**/
void AddQueueUp(People &p,int floor){
People q=&QueueUp[floor];
while(q->next!=NULL){
q=q->next;
}
q->next=p;
p->pre=q;
}
void AddQueueDown(People &p,int floor){
People q=&QueueDown[floor];
while(q->next!=NULL){
q=q->next;
}
q->next=p;
p->pre=q;
}
/**加入时序活动**/
void AddAct(int time,People ap,void(*fn)(People pt)){
int totalTime=Time+time;
Act p=&activity;
Act q=(Act)malloc(sizeof(act));
q->time=totalTime;
if(ap!=NULL){
q->pt=(People)malloc(sizeof(people));
q->pt->pre=ap->pre;
q->pt->Id=ap->Id;
q->pt->InFloor=ap->InFloor;
}
else q->pt=NULL;
q->fn=fn; q->next=NULL;
while(p->next!=NULL){
if(p->next->time>totalTime)break;
p=p->next;
}
q->next=p->next;
p->next=q;
}
/**电梯和人的行为操作函数**/
void remove(People p){
if(Exist[p->Id]==0||(p->InFloor==Floor&&State==Idle))return;
printf("/***************************/\n");
printf("用户%d放弃了等候然后离开了\n",p->Id);
printf("/***************************/\n\n");
int floor=p->InFloor;
int outfloor=p->OutFloor;
Exist[p->Id]=0;
People q=p->pre;
People ap=q->next;
q->next=ap->next;
if(ap->next!=NULL)ap->next->pre=q;
free(ap);
//cout<outfloor&&QueueDown[floor].next==NULL){
// CallDown[floor]=0;
// }
}
/**操作**/
/**输入**/
void input(People pt){
int infloor,outfloor,giveuptime,intertime;
while(1){
printf("/**************************************/\n");
printf("第%d用户走进来\n",Id+1);
printf("他在哪层楼电梯的门前:_____\b\b\b");
scanf("%d",&infloor);
printf("他要去哪层楼:_____\b\b\b");
scanf("%d",&outfloor);
printf("他能容忍的等候时间:_____\b\b\b");
scanf("%d",&giveuptime);
printf("下一个人出现的时间间隔:_____\b\b\b");
scanf("%d",&intertime);
printf("/**************************************/\n\n");
if(infloor>=0&&infloor=0&&outfloorentertime=Time;
p->Id=++Id; p->InFloor=infloor; p->OutFloor=outfloor;
p->GiveupTime=giveuptime; p->pre=NULL; p->next=NULL;
Exist[Id]=1;
if(outfloor>infloor){
AddQueueUp(p,infloor);
CallUp[infloor]=1;
}
else{
AddQueueDown(p,infloor);
CallDown[infloor]=1;
}
AddAct(giveuptime,p,remove);
AddAct(intertime,NULL,input);
}
/****/
void doclosedoor(People ap){
if(doorclosing==0||Time!=doorclosingtime+DoorTime)return;
doorclosing=0;
printf("/**********/\n");
printf("电梯门关了\n");
printf("/**********/\n\n");
}
void testinout(People o){
if(preState==GoingUp){
if(QueueUp[Floor].next||Stack[Floor].next||testdoortime+CarTime!=Time)return;
CallUp[Floor]=0;
CallCar[Floor]=0;
D1=0;D3=0;
doorclosing=1; doorclosingtime=Time;
printf("/**********/\n");
printf("正在关门\n");
printf("/**********/\n\n");
AddAct(DoorTime,NULL,doclosedoor);
}
else if(preState==GoingDown){
if(QueueDown[Floor].next||Stack[Floor].next||testdoortime+CarTime!=Time)return;
CallDown[Floor]=0;
CallCar[Floor]=0;
D1=0;D3=0;
doorclosing=1; doorclosingtime=Time;
printf("/**********/\n");
printf("正在关门\n");
printf("/**********/\n\n");
AddAct(DoorTime,NULL,doclosedoor);
}
}
void doin(People p){
if(preState==GoingUp){
People ap=QueueUp[Floor].next;
if(ap){
printf("/***************/\n");
printf("用户%d走进电梯\n",ap->Id);
printf("/***************/\n\n");
Exist[ap->Id]=0;
QueueUp[Floor].next=ap->next;
Car pr=(Car)malloc(sizeof(car));
int i=ap->OutFloor;
CallCar[i]=1;
pr->next=Stack[i].next;
Stack[i].next=pr;
pr->Id=ap->Id;
free(ap);
}
if(QueueUp[Floor].next)AddAct(PeopleTime,NULL,doin);
else {
CallUp[Floor]=0;
CallCar[Floor]=0;
D1=0;D3=1; //没人进出，但门是开着的
testdoortime=Time;
AddAct(CarTime,NULL,testinout);
}
}
else if(preState==GoingDown){
People ap=QueueDown[Floor].next;
if(ap){
printf("/***************/\n");
printf("用户%d走进电梯\n",ap->Id);
printf("/***************/\n\n");
Exist[ap->Id]=0;
QueueDown[Floor].next=ap->next;
Car pr=(Car)malloc(sizeof(car));
int i=ap->OutFloor;
CallCar[i]=1;
pr->next=Stack[i].next;
Stack[i].next=pr;
pr->Id=ap->Id;
free(ap);
}
if(QueueDown[Floor].next)AddAct(PeopleTime,NULL,doin);
else {
CallDown[Floor]=0;
CallCar[Floor]=0;
D1=0;D3=1; //没人进出，但门是开着的
testdoortime=Time;
AddAct(CarTime,NULL,testinout);
}
}
}
void doout(People p){
if(Stack[Floor].next){
Car ap=Stack[Floor].next;
Stack[Floor].next=ap->next;
printf("/*******************/\n");
printf("用户%d走出了电梯\n",ap->Id);
printf("/*******************/\n\n");
free(ap);
}
if(Stack[Floor].next){
AddAct(PeopleTime,NULL,doout);
}
else if(preState==GoingUp&&QueueUp[Floor].next){
AddAct(PeopleTime,NULL,doin);
}
else if(preState==GoingDown&&QueueDown[Floor].next){
AddAct(PeopleTime,NULL,doin);
}
else {
if(preState==GoingUp){
CallUp[Floor]=0;
int flag=0;
for(int i=Floor+1;i=0;i--){
if(CallCar[i]||CallUp[i]||CallDown[i]){
flag=1;break;
}
}
if(flag==0){
if(QueueUp[Floor].next!=NULL){
preState=GoingUp;
AddAct(PeopleTime,NULL,doin);return;
}
}
}
CallCar[Floor]=0;
D1=0; D3=1; 没人进出，但门是开着的
testdoortime=Time;
AddAct(CarTime,NULL,testinout);
}
}
void doopendoor(People p){
printf("/**********/\n");
printf("电梯门开了\n");
printf("/**********/\n\n");
if(Stack[Floor].next){
AddAct(PeopleTime,NULL,doout);
}
else if(preState==GoingUp&&QueueUp[Floor].next){
AddAct(PeopleTime,NULL,doin);
}
else if(preState==GoingDown&&QueueDown[Floor].next){
AddAct(PeopleTime,NULL,doin);
}
else {
CallUp[Floor]=0;
CallDown[Floor]=0;
CallCar[Floor]=0;
D1=0; D3=1; //没人进出，但门是开着的
testdoortime=Time;
AddAct(CarTime,NULL,testinout);
}
}
void doslow(People ap){//电梯停了
State=Idle;
D1=0;D3=0;
printf("/*********************/\n");
printf("电梯停了，当前层是%d\n",Floor);
printf("/*********************/\n\n");
}
void doup(People ap){
Floor++;
printf("/*************************/\n");
printf("电梯正在上升!现已到了%d层!\n",Floor);
printf("/*************************/\n\n");
if(preState==GoingUp&&(CallUp[Floor]||CallCar[Floor]||CallDown[Floor])){
if(CallUp[Floor]||CallCar[Floor])AddAct(UpDecelerate,NULL,doslow);
else{
int flag=0;
for(int i=Floor+1;i=0;i--){
if(CallUp[i]||CallCar[i]||CallDown[i]){flag=1;break;}
}
if(flag==0)AddAct(UpDecelerate,NULL,doslow);
else{
AddAct(UpTime,NULL,doup);
}
}
}
else{
if(Floor==MaxFloor-1){
AddAct(UpDecelerate,NULL,doslow);
}else{
AddAct(UpTime,NULL,doup);
}
}
}
void dodown(People ap){
Floor--;
printf("/**************************/\n");
printf("电梯正在下降!现已到了%d层!\n",Floor);
printf("/**************************/\n\n");
if(preState==GoingUp&&(CallUp[Floor]||CallCar[Floor])){
AddAct(UpDecelerate,NULL,doslow);
}
else if(preState==GoingDown&&(CallDown[Floor]||CallCar[Floor])){
AddAct(UpDecelerate,NULL,doslow);
}
else{
if(Floor==0){
AddAct(DownDecelerate,NULL,doslow);
}else{
AddAct(DownTime,NULL,dodown);
}
}
}
void domove(People ap){//加速完成，将进入正常速度
if(State==GoingUp){
printf("/***************/\n");
printf("电梯已加速上升!\n");
printf("/***************/\n\n");
AddAct(UpTime,NULL,doup);
}else{
printf("/***************/\n");
printf("电梯已加速下降!\n");
printf("/***************/\n\n");
AddAct(DownTime,NULL,dodown);
}
}
void tofirst(People ap){//去第一层
if(State!=Idle||backfirsttime+BackTime!=Time)return;
if(Floor==BaseFloor&&D2==0){CallCar[BaseFloor]=2;return;}
else if(Floor==BaseFloor)return;
printf("/*******************************/\n");
printf("长时间没人请求电梯!将进入%d层\n",BaseFloor);
printf("/*******************************/\n\n");
CallCar[BaseFloor]=2;
}
int getW(){
int timeUp=-1,timeDown=-1;
if(QueueUp[Floor].next!=NULL){
timeUp=QueueUp[Floor].next->entertime;
}
if(QueueDown[Floor].next!=NULL){
timeDown=QueueDown[Floor].next->entertime;
}
if(timeUp!=-1||timeDown!=-1){
if(timeUp!=-1&&timeDown!=-1){
return timeUpentertime);
}
if(QueueDown[i].next!=NULL){
timeUp=min(timeUp,QueueDown[i].next->entertime);
}
}
for(int i=Floor-1;i>=0;i--){
if(QueueUp[i].next!=NULL){
timeDown=min(timeDown,QueueUp[i].next->entertime);
}
if(QueueDown[i].next!=NULL){
timeDown=min(timeDown,QueueDown[i].next->entertime);
}
}
if(timeUp!=MaxTime+1||timeDown!=MaxTime+1){
if(timeUp!=MaxTime+1&&timeDown!=MaxTime+1){
return timeUpFloor)return GoingUp;
else if(CallCar[BaseFloor]==2&&BaseFloor=0;i--){
if(CallCar[i]||CallUp[i]||CallDown[i])return 1;
}
return 0;
}
/**电梯调度函数**/
void Controler(){
if(State==Idle){
if(preState==Idle){
preState=getW();
}
if(D1==0&&D3==0&&CallCar[Floor]==2){
CallCar[Floor]=0;
// D2=0;
int flag=0;
for(int i=Floor+1;i=0;i--){
if(CallDown[i]||CallCar[i]||CallUp[i]){flag=1;break;}
}
if(flag==1)return;
printf("/**************************/\n");
printf("现在在%d层，无人请求电梯!\n",Floor);
printf("/**************************/\n\n");
return;
}
if(D1==0&&D3==0&&preState==GoingUp&&(CallUp[Floor]||CallCar[Floor])){ //D1=0，无人进出电梯 D3=0,门是关的
D1=1; D2=1;
if(doorclosing==1){
doorclosing=0;
printf("/*************/\n");
printf("打断关门\n");
printf("/*************/\n\n");
AddAct(Time-doorclosingtime,NULL,doopendoor);
}
else AddAct(DoorTime,NULL,doopendoor);
return;
}
else if(D1==0&&D3==0&&preState==GoingDown&&(CallDown[Floor]||CallCar[Floor])){
D1=1; D2=1;
if(doorclosing==1){
doorclosing=0;
printf("/*************/\n");
printf("打断关门\n");
printf("/*************/\n\n");
AddAct(Time-doorclosingtime,NULL,doopendoor);
}
else AddAct(DoorTime,NULL,doopendoor);
return;
}
else if(D3==1&&preState==GoingUp&&CallUp[Floor]){
D1=1;D3=0; //门还没关，又有人进来
AddAct(PeopleTime,NULL,doin);
}
else if(D3==1&&preState==GoingDown&&CallDown[Floor]){
D1=1;D3=0; //门还没关，又有人进来
AddAct(PeopleTime,NULL,doin);
}
else if(D1==0&&D3==0&&doorclosing==0&&preState==GoingUp&&
!(CallUp[Floor]||CallCar[Floor])){
int temp=GetUp();
if(temp==1){
State=GoingUp;
AddAct(Accelerate,NULL,domove);
}
else {
preState=Idle;
State=Idle;
Again=1;
}
}
else if(D1==0&&D3==0&&doorclosing==0&&preState==GoingDown&&
!(CallDown[Floor]||CallCar[Floor])){
int temp=GetDown();
if(temp==1){
State=GoingDown;
AddAct(Accelerate,NULL,domove);
}
else {
preState=Idle;
State=Idle;
Again=1;
}
}
else if(D1==0&&D3==0&&doorclosing==0&&D2==1){
D2=0;
backfirsttime=Time;
AddAct(BackTime,NULL,tofirst);
}
}
}
/**处理**/
void solve(){
while(Time<=MaxTime){
do{
Again=0;
Controler();
}while(Again==1);
Act p=activity.next;
if(p==NULL)Time=MaxTime;
while(p&&p->time<=Time){
activity.next=p->next;
p->fn(p->pt);
free(p);
p=activity.next;
}
Time++;
//printf("%d\n",Time);
}
}
/**主体**/
int main(){
system("color 4F");
init();
input(NULL);
solve();
}
