电梯控制算法（3）单电梯场景——空闲停靠

电梯控制算法 https://blog.csdn.net/nameofcsdn/article/details/106874615

 

电梯在空闲状态时，停靠的情况有2种：原处停靠、固定楼层停靠。

原处停靠很简单，停到哪了就是哪，而固定楼层停靠，一般是为了节约乘客平均等待电梯时间。

 

楼层均值分析：

一般情况下，乘电梯是2种情况，1到k 或者 k到1，起点和终点都不是1楼的情况很少。

更进一步，人流均衡，1楼的等待乘客数等于其他楼层等待乘客数（此处数目指的的数学期望，下同）。

假设2到n的等待乘客数分别为1，那么一楼的等待乘客数为n-1

假设停靠楼层为m，那么电梯去接第一个乘客的接客距离为

(n-1) * abs(m-1) + abs(m-2) +  abs(m-3) + ...... + abs(m-n) ，忽略常数，下同

abs表示绝对值，很明显，这个式子在m=1或2时取到最小值，所以电梯停靠在1楼或者2楼是可以达到乘客平均等待电梯时间最短的目的的。

PS: 这里只考虑当电梯空闲，第一位乘客等待电梯的情况。

 

固定停靠的楼层，也可以采取复杂的策略而定，而不是一直保持一个固定的数字。

比如，按照时间，小区早高峰是下楼上班，晚高峰是下班上楼，公司中午12点是下楼吃饭高峰，12点20分是吃完饭上楼高峰，等等。

对于下行高峰，如果按照前面的逻辑，一共n层楼的话，停靠在n/2层楼貌似是最优解。

然而，光考虑第一位乘客等待电梯的情况，或许还不是最优方案。

存在这么一种情况，加入电梯空闲停靠在5楼，此时7楼用户按了电梯下行按钮，电梯就上行去7楼接乘客，然而此时9楼又按了电梯下行按钮，那么电梯就会先去9楼，下行时经过7楼才开门接7楼乘客。如果一开始电梯停靠在8楼，那么电梯就会直接去7楼接乘客下行到1楼，然后才上行到9楼接乘客。

很明显，2种情况下的电梯利用率是不一样的，乘客的等待时间也是不一样的。

所以，对于下行高峰，相比于停靠在n/2层楼，停靠在更低的楼层或许是更好的方案。

 

假设电梯处于空闲状态停靠在m层，此时 i 层有乘客按电梯下行，紧接着 j 层立马也有人按电梯下行，那么电梯把俩乘客都送到1楼需要多久呢？平均停靠在哪一层可以最快的把2名乘客都送到1楼?

枚举一下n从3到30的结果：

int main()
{
	for (int n = 3; n <= 30; n++)
	{
		double x = 2 * n*n - 6 * n + 10.0 / 3;
		cout << n << " " << int((3 * n - 1 - sqrt(x)) / 7 +0.5)<< endl;
	}
	return 0;
}

3 1
4 1
5 1
6 2
7 2
8 2
9 2
10 2
11 3
12 3
13 3
14 3
15 4
16 4
17 4
18 4
19 4
20 5
21 5
22 5
23 5
24 6
25 6
26 6
27 6
28 7
29 7
30 7

让我们用编程验证一下E求解的过程对不对。

int getE(int n, int m)
{
	int ans = 0;
	for (int i = 1; i <= m; i++)for (int j = 1; j <= m; j++)ans += m;
	for (int i = m+1; i <= n; i++)for (int j = m+1; j <= n; j++)ans += 2*max(i,j)-m;
	for (int i = 1; i <= m; i++)for (int j = m + 1; j <= n; j++)ans += m + 2 * j;
	for (int i = m + 1; i <= n; i++)for (int j = 1; j <= m; j++)ans += 2 * i;
	return ans;
}
int main()
{
	for (int n = 3; n <= 30; n++)
	{
		int k = 0, ansk = 1234567;
		for (int m = 1; m <= n; m++)if (ansk > getE(n, m))ansk > getE(n, m), k = m;
		cout << n << " " << k << endl;
	}
	return 0;
}

3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
11 11
12 12
13 13
14 14
15 15
16 16
17 17
18 18
19 19
20 20
21 21
22 22
23 23
24 24
25 25
26 26
27 27
28 28
29 29
30 30

结果不一样！

我们把E关于m的三次函数画出来大概是这样：

前面求出来的那个是极值点，但还不是最小值。

所以对于下行高峰，如果只考虑尽快把乘客都送到1楼，空闲停靠选择最高层是最优的。

如果要同时考虑电梯外乘客等待时间和乘客到达1楼时间，上面求的极值点附近是比较优的方案。

PS：虽然下行高峰期往往空闲时间较短，电梯可能到不了空闲停靠楼层就要去接客，但是空闲的时候往这个方向前进还是有效果的。

 

现在我们已经知道了如何设定空闲停靠楼层，那么基于此，扫描调度算法还需要进一步优化：

#include <thread>
#include<time.h>

#define LEVEL 6
#define PARK 2  //空闲停靠楼层
int flag[LEVEL + 1];  //1到Level层的外部输入，取值为0,1,2,3，其中0表示无乘客,1表示有乘客上行，2表示有乘客下行，3表示既有上行又有下行
int dest[LEVEL + 1];  //目的楼层的记录，取值为0,1，其中0表示不是目的地，1表示是目的地
int levelMax, levelMin; //levelMax是进出电梯最大楼层，levelMin是进出电梯最小楼层

void input()
{
	int lev, fla;
	while (cin >> lev >> fla) if (lev > 0 && lev <= LEVEL)
	{
		if (fla>0 && fla <= 3)flag[lev] = fla; //外部输入
		else dest[lev] = 1;//内部输入
	}
}
void upPull(int loc)//上行接客
{
	flag[loc]--;
	cout << "上行接客" << loc << endl;
}
void downPull(int loc)//下行接客
{
	flag[loc] -= 2;
	cout << "下行接客" << loc << endl;
}
void push(int loc)//送客
{
	dest[loc] = 0;
	cout << "送客" << loc << endl;
}
int getMax()//进出电梯最大楼层
{
	levelMax = 0;
	for (int loc = 1; loc <= LEVEL; loc++)
	{
		if (flag[loc] || dest[loc])levelMax = max(levelMax, loc);
	}
	return levelMax;
}
int getMin()//进出电梯最小楼层
{
	levelMin = LEVEL + 1;
	for (int loc = 1; loc <= LEVEL; loc++)
	{
		if (flag[loc] || dest[loc])levelMin = min(levelMin, loc);
	}
	return levelMin;
}
bool isPark()//是否为空闲状态
{
	return getMax() <= 0 || getMax() > LEVEL;
}
int getMax2()//进出电梯最大楼层
{
	if (isPark())return PARK;
	return getMax();
}
int getMin2()//进出电梯最小楼层
{
	if (isPark())return PARK;
	return getMin();
}
void run()
{
	int loc = 1;
	cout << "    当前楼层" << loc << endl;
	while (1)
	{
		while (loc <= getMax2())
		{
			if (flag[loc] == 1 || flag[loc] == 3)upPull(loc);
			if (dest[loc])push(loc);
			Sleep(1000);
			if (loc<getMax2())loc++;
			else break;
			cout << "    当前楼层" << loc << endl;
		}
		while (loc >= getMin2())
		{
			if (flag[loc] == 2 || flag[loc] == 3)downPull(loc);
			if (dest[loc])push(loc);
			Sleep(1000);
			if (loc > getMin2())loc--;
			else break;
			cout << "    当前楼层" << loc << endl;
		}
	}
}

int main()
{
	thread t1(input);
	thread t2(run);
	t1.join();
	t2.join();
	return 0;
}