腾讯笔试题_电梯问题_思路和初步的算法_討論一下

[小赌移情]

问题如下:
一座楼里没有楼梯，只有一架电梯，电梯一次最多只能乘3人，已知楼共有20层，每层有一个人，每个人都有1~20中唯一的编号，他们要去对应的楼层。
电梯初始状态：在一楼。
目标状态：每个人在相应楼层。
试编写一个算法，完成目标状态，而且使电梯移动最小距离。

我的思路:
尽可能让电梯满载运行,而且优先解决远处的需求.使得电梯的运行轨迹类似于一个作往复运动的弹簧由于阻尼最后停下来. 对于正态分布的情况, 电梯最后的状态应接近于中点. 理想情况是对于平均分布的输入集合,电梯的运行层数为每个人的(需行层数+3+3)/3,之所以要加两个3是因为电梯在最初运行和达到目标的时候分别有一段必须空载的距离(在初始状态,电梯至少要运行三层才能装满). 当然对于大量数据来说, 实际运行的効率应该趋近这个最优结果的渐近线.

以下是我的程序:目前只是初步实现了一下.拋磚引玉.

#include <stdio.h>
#include <string.h>

/*
 * The Question:
 *
 *一座楼里没有楼梯，只有一架电梯，电梯一次最多只能乘3人，已知楼共有20层，每层有一个人，
  每个人都有1~20中唯一的编号，他们要去对应的楼层。电梯初始状态：在一楼。目标状态：每个人在相应楼层。
	试编写一个算法，完成目标状态，而且使电梯移动最小距离。 
 *	
 * ZhanZongru(Z80_AT_whut.edu.cn)
 * 2009,May,30th
 *
 * For the sake of simpliticy.
 *
 * The Building uses a United Kingdom Floor naming fashion.
 * 0-19 Floors.
 * The people in every floor use a United States naming fashion to express their destinations.
 * 1-20 Floors.
 * 
 * In one words, 20 Americans in a UK building...
*/

/*Every floor can content 1 to 20 person.*/
unsigned char FloorContent[20][20];	

/*The carrier struct.*/
typedef struct _Carrier{
	unsigned char Position_uk;
	unsigned char Passager_us[3];
}Carrier;																	
						
#define CAR_CAP	3
						
Carrier theCar;					
								
typedef enum _CurrentDirect{
													UP_WARD = 0,
													DOWN_WARD
}CurDir;
	
CurDir theDir = UP_WARD;

unsigned char cur_bottom = 0;
unsigned char cur_top = 19;										

unsigned char IsSuccessed = 0;
unsigned long RunFloorCount = 0;
	
void Run_One_Floor(void);
void LayToFloor(unsigned char pos_uk, unsigned char set_id);
void LoadToCar_Up(unsigned char floor_uk, unsigned char id);
void LoadToCar_Down(unsigned char floor_uk, unsigned char id);
unsigned char JudgeStatus();
unsigned char FloorSize(unsigned char floor_uk);
void ReCalc_Bot_Top(void);
void Show_Status(void);
unsigned char FloorFirstOne(unsigned char floor_uk);
unsigned char Min_Passger_id(void);
unsigned char Max_Passger_id(void);
								
int main(int argc, char** argv)
{
	char input_file[50];
	char output_file[50];
	FILE* fp=NULL;
	int i=0;
	int simple_crc=0;
	
	if(argc==1)
	{
		strcpy(input_file, "input.txt");
		strcpy(output_file, "output.txt");
	}
	else if(argc==2)
	{
		strcpy(input_file, argv[1]);
		strcpy(output_file, "output.txt");
		
	}
	else if(argc>=3)
	{
		strcpy(input_file, argv[1]);
		strcpy(output_file, argv[2]);
	}
	else
	{
	}
	
	fp = fopen(input_file, "r");
	if(fp==NULL)
	{
		perror("Failed:fopen the input file\r\n");
		return -1;
	}
	/*Read in the initial status, the status could generated by another program, now by hand editing.*/
	for(i=0;i<20;i++)
	{
		fscanf(fp, "%d", (int*)&FloorContent[i][0]);
		simple_crc+=FloorContent[i][0];		
	}
	fclose(fp);
	/*A very simple check to ensure 20 numbers are different.*/
	if(simple_crc!=210)
	{
	}
	/*The carrier initialiy stop at the bottom.*/							
	 theCar.Position_uk = 0;
	 theCar.Passager_us[0] = 0;
	 theCar.Passager_us[1] = 0;
	 theCar.Passager_us[2] = 0;
	 											
	/*It is the main loop, after run every floor, check whether completed.*/
		while(!IsSuccessed)
		{					
#ifdef _DEBUG
			Show_Status();
			system("pause");
#endif			
			Run_One_Floor();
		}
		
		printf("Success %ld Times\r\n", RunFloorCount);
		fp=fopen(output_file, "w");
		for(i=0;i<20;i++)
		{
			fprintf(fp, "%d ",FloorFirstOne(i)); 
		}
		fclose(fp);
		
	return 0;
}

/*For debug*/
void Show_Status(void)
{
	int i,j=0;
	
	for(i=0;i<20;i++)
	{
		printf("Floor%d:  ",19-i);
		for(j=0;j<20;j++)
		{
			printf(" %02d ", FloorContent[19-i][j]);
		}	
		printf("\r\n");
	}
	
	printf("The Car status: %02d, %02d, %02d, %02d, %c\r\n",
				 theCar.Position_uk, theCar.Passager_us[0], theCar.Passager_us[1], theCar.Passager_us[2],
				 theDir==UP_WARD? '^':'v');
}

void Run_One_Floor(void)
{
	int i=0;
	
	//First decite the run direction of the car
	if(theCar.Position_uk==cur_bottom)
	{
		theDir = UP_WARD;
		ReCalc_Bot_Top();
	}
	
	if(theCar.Position_uk==cur_top)
	{
		theDir = DOWN_WARD;
		ReCalc_Bot_Top();
	}
	
	//To see whether need to lay down someone whose destination is this floor
		if(theCar.Passager_us[0]==(1+theCar.Position_uk))
		{
				LayToFloor(theCar.Position_uk, 0);
		}
		
		if(theCar.Passager_us[1]==(1+theCar.Position_uk))
		{
			LayToFloor(theCar.Position_uk, 1);
		}
		
		if(theCar.Passager_us[2]==(1+theCar.Position_uk))
		{
			LayToFloor(theCar.Position_uk, 2);
		}
		
	//Fill the carrier if it has some empty space,or swap when worthy
		for(i=0;i<20;i++)
		{
			if( (FloorContent[theCar.Position_uk][i]>(theCar.Position_uk+1)) && (theDir == UP_WARD) )
			{
				LoadToCar_Up(theCar.Position_uk,i);
			}
			
			if((FloorContent[theCar.Position_uk][i]!=0) &&
			   (FloorContent[theCar.Position_uk][i]<(theCar.Position_uk+1)) && (theDir == DOWN_WARD) )
			{
				LoadToCar_Down(theCar.Position_uk,i);
			}
		}
	
	 //Advance a floor
	 if(theDir == UP_WARD)
	 {
	 	IsSuccessed = JudgeStatus();
	 	if(!IsSuccessed)
	 	{
	 		theCar.Position_uk+=1;
			RunFloorCount++;
	 	}
	 }
	 else if(theDir == DOWN_WARD)
	 {
	 	IsSuccessed = JudgeStatus();
	 	if(!IsSuccessed)
	 	{
	 		theCar.Position_uk-=1;
	 		RunFloorCount++;
	  }
	 }
	 else
	 {
	 		printf("theDir is error\r\n");
	 		return ;
	 }
}

unsigned char JudgeStatus()
{
	int i = 0;
	for(i=0; i<20; i++)
	{
		if( (FloorSize(i)!=1) || (FloorFirstOne(i)!=(i+1)) )
			return 0;
	}
	
	return 1;
}

/* Return the first person's destination in one floor.*/
unsigned char FloorFirstOne(unsigned char floor_uk)
{
	int i=0;
	for(i=0;i<20;i++)
	{
		if(FloorContent[floor_uk][i]!=0)
		{
			return FloorContent[floor_uk][i];
		}
	}
	return 0;
}

/*return the number of persons in one floor.*/
unsigned char FloorSize(unsigned char floor_uk)
{
	int i = 0;
	int j = 0;
	for(i=0; i<20; i++)
	{
		if(0==FloorContent[floor_uk][i])
			continue;
			
			j++;
	}
	
	return j;
}

/* Re-calculate the current bottom and top floors.*/
void ReCalc_Bot_Top(void)
{
#if 1
	int i=0;
	
	if(theDir==UP_WARD)
	{
		for(i=19;i>=0;i--)
		{
			if((FloorSize(i)!=1) || (FloorFirstOne(i)!=i+1))
			{
				cur_top = i;
				break;
			}
		}
	}
	else if(theDir==DOWN_WARD)
	{
		for(i=0;i<20;i++)
		{
			if((FloorSize(i)!=1) || (FloorFirstOne(i)!=i+1))
			{
				cur_bottom = i;
				break;
			}
		}
	}
	else
	{
	}
#endif
}

/* Lay a person from the carrier to the floor.*/
void LayToFloor(unsigned char pos_uk, unsigned char set_id)
{
	int i=0;
	for(i=0; i<20; i++)
	{//Find a empty space to lay down the passager
		if(FloorContent[pos_uk][i]==0)
		{
			FloorContent[pos_uk][i] = theCar.Passager_us[set_id];
			theCar.Passager_us[set_id] = 0;
			break;
		}
	}
	
	return;
}

/* When the direction is UPWARD, load a person from the floor to the carrier.*/
void LoadToCar_Up(unsigned char floor_uk, unsigned char id)
{
	int i=0;
	unsigned char temp=0;
	
	//Find a empty sit set to load the passager
		if(theCar.Passager_us[0]==0)
		{
#ifdef _DEBUG
			printf("the empty set is 0\r\n");
#endif
			theCar.Passager_us[0] = FloorContent[floor_uk][id];
			FloorContent[floor_uk][id] = 0;
		}
		else if(theCar.Passager_us[1]==0)
		{
#ifdef _DEBUG
			printf("the empty set is 1\r\n");
#endif
			theCar.Passager_us[1] = FloorContent[floor_uk][id];
			FloorContent[floor_uk][id] = 0;
		}
		else if(theCar.Passager_us[2]==0)
		{
#ifdef _DEBUG
			printf("the empty set is 2\r\n");
#endif
			theCar.Passager_us[2] = FloorContent[floor_uk][id];
			FloorContent[floor_uk][id] = 0;
		}
	  else
	  {//Full, swap if wothy
#ifdef _DEBUG
			printf("up swap fig, Min_ID is %d\r\n", Min_Passger_id());
#endif
	  	if(FloorContent[floor_uk][id]>theCar.Passager_us[Min_Passger_id()])
	  	{
	  		temp = FloorContent[floor_uk][id];
	  		FloorContent[floor_uk][id] = theCar.Passager_us[Min_Passger_id()];
	  		theCar.Passager_us[Min_Passger_id()] = temp;
	  	}
	  }
	return;
}

/* return the minium passager's destination in the carrier.*/
unsigned char Min_Passger_id(void)
{
	unsigned char min_id = 0;
	if(theCar.Passager_us[1]<theCar.Passager_us[min_id])
		min_id = 1;
		
	if(theCar.Passager_us[2]<theCar.Passager_us[min_id])
		min_id = 2;	
		
		return min_id;
}

/* return the maxium passager's destination in the carrier.*/
unsigned char Max_Passger_id(void)
{
	unsigned char max_id = 0;
	if(theCar.Passager_us[1]>theCar.Passager_us[max_id])
		max_id = 1;
		
	if(theCar.Passager_us[2]>theCar.Passager_us[max_id])
		max_id = 2;	
		
		return max_id;
}

/* When the direction is DOWNWARD, load a person from the floor to the carrier.*/
void LoadToCar_Down(unsigned char floor_uk, unsigned char id)
{
	int i=0;
	unsigned char temp=0;
	
	//Find a empty sit set to load the passager
		if(theCar.Passager_us[0]==0)
		{
			theCar.Passager_us[0] = FloorContent[floor_uk][id];
			FloorContent[floor_uk][id] = 0;
		}
		else if(theCar.Passager_us[1]==0)
		{
			theCar.Passager_us[1] = FloorContent[floor_uk][id];
			FloorContent[floor_uk][id] = 0;
		}
		else if(theCar.Passager_us[2]==0)
		{
			theCar.Passager_us[2] = FloorContent[floor_uk][id];
			FloorContent[floor_uk][id] = 0;
		}
	  else
	  {//Full, swap if wothy
	  	if(FloorContent[floor_uk][id]<theCar.Passager_us[Max_Passger_id()])
	  	{
	  		temp = FloorContent[floor_uk][id];
	  		FloorContent[floor_uk][id] = theCar.Passager_us[Max_Passger_id()];
	  		theCar.Passager_us[Max_Passger_id()] = temp;
	  	}
	  }
	return;
}

[daidodo]

void AddStatus_2(const CLift & lift,__Policy & status,__History & history)
{
    typedef std::pair<__History::iterator,bool> __RetType;
    __RetType ret = history.insert(lift);
    if(ret.second){
        int c1 = status.empty() ? 0 : status.front().FinishCount();
        int c2 = lift.FinishCount();
        bool push = false;
        if(c1 < c2 - MAX_C){
#if __STATISTICS
            add_reduced += status.size();
#endif
            status.clear();
            push = true;
        }else if (c1 <= c2 + MAX_C)
            push = true;
#if __STATISTICS
        else
            ++add_reduced;
#endif
        if(push)
            status.push_back(lift);
        if(history.size() > 1000000){
            history.erase(history.begin());
#if __STATISTICS
            ++history_missed;
        }
    }else
        ++status_reduced;
#else
        }
    }
#endif
}

bool processLift_2(CLift & lift,__Policy & status,const std::vector<int> & dest,int capa,__History & history)
{
    lift.Move();
    const bool empty = lift.Empty();    //电梯是否一直是空的
    lift.Unload(dest);
    if(lift.Finish()){
        AddStatus_2(lift,status,history);
        return true;
    }
    if(lift.CanLoad()){ //有人可上电梯
        if(lift.Empty()){
            lift.direct_ = lift.Load(dest);
            AddStatus_2(lift,status,history);
        }else{
            AddStatus_2(lift,status,history);
            const U8 d = lift.Load(dest);
            AddStatus_2(lift,status,history);
            if(lift.direct_ != d){
                lift.direct_ = d;
                AddStatus_2(lift,status,history);
            }
        }
    }else{               //无人可上电梯
        if(lift.Empty()){
            if(empty){
                AddStatus_2(lift,status,history);
            }else{
                if(lift.TestDir())
                    AddStatus_2(lift,status,history);
                lift.direct_ ^= 1;  //改变方向
                if(lift.TestDir())
                    AddStatus_2(lift,status,history);
            }
        }else
            AddStatus_2(lift,status,history);
    }
    return false;
}

bool enumStatus_2(__Policy & status,const std::vector<int> & dest,int capa,__History & history)
{
    __Policy tmp;
    status.swap(tmp);
    const size_t tmp_sz = tmp.size();
    status.reserve(tmp_sz * 3);
    for(size_t i = 0;i < tmp.size();++i)
        if(processLift_2(tmp[i],status,dest,capa,history))
            return true;
#if __STATISTICS
    size_t sz = status.size();
    if(int(sz) > status_max)
        status_max = status.size();
    double rate = sz;
    rate /= tmp_sz;
    if(rate > increase_rate)
        increase_rate = rate;
#endif
    return false;

}

int policy_2(const std::vector<int> & dest,int capa)
{
    __Policy status(1);
    memset(&status[0],0,sizeof status[0]);
    status[0].direct_ = 1;
    for(int i = 0;i < LEVEL;++i){
        assert(0 <= dest[i] && dest[i] < LEVEL);
        if(i == dest[i])
            status[0].finished_ += S32(1) << i;
    }
    if(status[0].Finish())
        return 0;
    if(!(status[0].finished_ & 1))
        status[0].load_ = 1;
    printStatus(status);
    __History history;
    status.reserve(1000);
    while(!enumStatus_2(status,dest,capa,history))
        printStatus(status);
#if __STATISTICS
    cout<<"history = "<<history.size()<<endl;
#endif
    return status.back().ret_;
}
//------------------------------------------------------------

//--------------测试代码，保证算法的正确性--------------------
//batch test
void batch_test()
{
    std::vector<int> dest(LEVEL);
    for(int i = 0;i < LEVEL;++i){
        for(int j = 0;j < LEVEL;++j){
            dest[i] = j;
            int actual = policy_1(dest,CAPA);
            int test = policy_2(dest,CAPA);
            if(actual != test){
                cout<<"("<<LEVEL<<")";
                for(int k = 0;k < LEVEL;++k)
                    cout<<dest[k]<<",";
                cout<<"\nactual = "<<actual<<", test = "<<test<<endl;
            }
        }
    }
#if __STATISTICS
    PrintStats();
#endif
}
//------------------------------------------------------------

int main()
{
#if __TEST
    batch_test();
#else   //__TEST
    srand((unsigned int)time(0));
    //设置目的地
    std::vector<int> dest;
    destination(LEVEL,dest);
    //计算必须走的距离
    int minimal = minimalDistance(dest);
    double start = clock();
    //电梯实际的运行距离
    int actual = policy_2(dest,CAPA);
#   if __STATISTICS
    PrintStats();
#   endif
    //计算算法效率
    double rate = actual * CAPA * 1. / minimal;
    start = clock() - start;
#   ifndef WIN32
    start /= 1000;
#   endif
    //输出结果
#   if __SAMPLE == 1
    cout<<minimal<<"\t"
        <<actual<<"\t"
        <<rate<<"\t"
        <<start<<"\t"
        <<endl;
#   else   //__SAMPLE
    cout<<"minimal = "<<minimal<<endl
        <<"actual = "<<actual<<endl
        <<"CAPA = "<<CAPA<<endl
        <<"rate = "<<rate<<endl
        <<"Time : "<<start<<" ms\n";
#   endif  //__SAMPLE
#endif  //__TEST
}

代码完。
测试结果：
第一列：所有人从起点到终点的层数总和
第二列：电梯运行的层数
第三列：第一列 * 3 / 第二列
120 66 1.65
136 66 1.45588
140 68 1.45714
120 64 1.6
130 56 1.29231
146 68 1.39726
100 48 1.44
140 70 1.5
128 60 1.40625
152 72 1.42105
144 64 1.33333
120 59 1.475
156 74 1.42308
108 59 1.63889
154 71 1.38312
148 64 1.2973
156 66 1.26923
148 66 1.33784
82 46 1.68293
96 50 1.5625
140 66 1.41429
136 68 1.5
126 60 1.42857
152 64 1.26316
132 64 1.45455
平均结果：
132.4 63.16 1.443

[dong364]

一座楼里没有楼梯，只有一架电梯，电梯一次最多只能乘3人，已知楼共有20层，每层有一个人，每个人都有1~20中唯一的编号，他们要去对应的楼层。
电梯初始状态：在一楼。
目标状态：每个人在相应楼层。
试编写一个算法，完成目标状态，而且使电梯移动最小距离。
////////////////////////////////////////////
1. 没见过只能乘3人的电梯, 要是只能乘3人, 说明电梯有问题, 谁敢去乘啊?
2. 没见过坐电梯还要编号, 怎么乘坐是自己的事, 电梯能控制得了么?
3. 每天进进出出的人不可统计, 题目的假设有意义么?
4. 没见过只有电梯没有楼梯的楼, 消防意识咋这么差呢?
5. 就算没有楼梯, 总不至于就只有一个电梯吧?
6. 纵观上述5点, 结合实际情况来看, 完成此题没有实际意义....

[daidodo]

说明：
1. 首先说明一下目的地的生成规则，第一种是每个人的目的地都不相同，但随机排列（20!种情况）；第二种是每个人的目的地都是完全随机的，可以重复（20^20种情况；上面的测试结果使用的是第一种生成规则；
2. 关于人在到达目的地之前是否可以下电梯，为了实际应用考虑，本算法规定不能；
3. 本算法的原理是找出所有可能的电梯运行路线，从中选出最优的策略；可以通过参数调节计算量，并影响结果的准确度；所以本算法不能得到所有情况的最优结果。

[xin350]

楼主我这是完整的代码阿！
我把主函数宏定义了
#define _ void main()
#define __ {;}
整个程序在构造函数就执行完了

[yu3350360]

学习了

[zxlxp9527]

关注中

[zhouAAA]

纯属个人意见:
我不知道什么是算法的精随,但我想愈简单,才实用!
电梯在第一层往上升的时候,若10层的人想到20层去,电梯会直达20层.电梯从第20层往下降的时候,若第19层的人想到2层来,电梯会直达第2层.现实中的电梯不会听凭你的,在1到5层中来回转而不理楼层上面的人的想法!
我曾经在某个地方见这个面试题目.它回答的要点是:你做出来的东西要符合大众的习惯和市场的需求,并且要求利润,公平最大化.
这个题目最初不是技术题,而是一道综合的面试题.实际上,从技术角度来讲,不需要什么算法.
技术很重要.但技术之外的宇宙法则,市场法则,生存法则,自然规律更重要!

[Marco2752]

个人觉得还是用冒泡排序思想处理比较好，第一次上就把20，19，18放好，下来时又把1，2，3放好。
等哈，用程序试哈看

[pstrunner]

我有以下算法：
1、首先计算每一层与目的层的差。
例如第10层人员想到5层，则：5-10=-5（既下5层）；
如果是4层人员想到6层，则：6-4=2（既上2层）；
2、电梯开始上升时，
电梯则凡是正值的就装载，到额定负载就不装载，直到有人下去的时在继续装载。
这样直到电梯上到最高处。
3、接Step2，此时电梯开始下行，
电梯则凡是负值的就装载，到额定负载就不装载，直到有人下去的时在继续装载。
这样直到电梯下到最低处。
4、重复Step2～3，知道所有人员各就各位。

[小赌移情]

做題就做題, 沒有到jjyy的人比實際想算法 寫代碼的人還多好幾倍. 真是無語.
你覺得沒有實用價值, 大概沒在學校中做過理論研究過, 小學生 做的算術題 中學生做的那些受力分析題 比這個不知虛多少 各位還不是做得屁顛屁顛的. 至於說什么啥宇宙 綜合素質 更看不明白, 不喜歡此題者, 自可無視, 不要說一些莫名其妙的話.

只是就事論事, 說其它者一律無視!

[小赌移情]

[Quote=引用 63 楼 xin350 的回复:]
楼主我这是完整的代码阿！
我把主函数宏定义了
#define _ void main()
#define __ {;}
整个程序在构造函数就执行完了
[/Quote]

這個我眼拙, 不好意思, 你可以生成一些數據測一下嗎, 我是用隨機數生成的1000000組數據測試的.

[小赌移情]

[Quote=引用 70 楼 daidodo 的回复:]
说明：
1. 首先说明一下目的地的生成规则，第一种是每个人的目的地都不相同，但随机排列（20!种情况）；第二种是每个人的目的地都是完全随机的，可以重复（20^20种情况；上面的测试结果使用的是第一种生成规则；
2. 关于人在到达目的地之前是否可以下电梯，为了实际应用考虑，本算法规定不能；
3. 本算法的原理是找出所有可能的电梯运行路线，从中选出最优的策略；可以通过参数调节计算量，并影响结果的准确度；所以本算法不能…
[/Quote]

根據題意, 只有20!(階層)種情況, 你不用考慮實際應用的問題, 因為說電梯是為了方便說事, 說不定用在其它場合就實用了.
任何算法對所有數據都無最佳解, 這個情況下我認為應該以正態分布的很大量的數據的結果為準, 我是用隨機數來生成1000000組數據來測試的.

[小赌移情]

感興趣的人不多啊, 結了算了.

[hmt.sysfixer.net]

人的初始状态是什么

[qulcc]

看到楼主的已经结贴
不知道找到合适的答案没

我有一个想法：
1.到站的人 自己主动下去
2.如果某楼上的人 目的地与当前楼层的距离小于电梯上的人的话 那就替换掉该人.
3.电梯上尽量多上人

不对的话楼主直接无视
程序好久没碰 也不一定能写出来了

[frankl33]

Six people want to reach the 7th floor of a shopping mall. Their cumulative weight is 510KG. There are 4 elevators with the following
specifications:

E1: Max 500 KGs
E2: Max 560 KGs
E3: Max 520 KGs
E4: Max 720 KGs

Assume they are standing nearing the first elevator and the elevators are located quite a distance apart from one another. In which elevator should they be asked to board under each of there circumstances:

1.They have to reach the 7th floor immediately
2.Maximun space utilization has to be achieved
in the trip
3.Maximun number of people should be
accommodated per trip of the elevator



各位大侠能帮我看看这个题目的解法吗？
我对题目的理解可能有问题： 它既然说了6个人在E1门口，而且E2,3,4 离E1都很远很远。 那不是他们只能坐E1了吗 ？ 都不用选了三种情况都只能坐E1了。

这题该怎么理解好呢？

[编号707]

[Quote=引用 18 楼 yuan1125 的回复:]
硬盘寻道的 电梯算法  原理一样
[/Quote]
顶

[iwgh]

强悍，关注

[0x甲鱼]

mark!!

[zidane_yubo]

mark