用C++写一份电梯调度算法

由于电梯调度算法有多种不同的实现方法，以下仅提供一种简单的参考实现：

首先需要定义电梯状态，包括当前楼层、运行方向、当前乘客数量。定义一个包含所有电梯的数组，并初始化为初始状态。

当有乘客按下电梯按钮时，记录其所在楼层和目标楼层，然后根据算法规则决定将请求派发到哪个电梯。算法规则可以采用贪心、最短路径等不同策略，例如：

1. 遍历所有电梯，如果某一台电梯当前处于闲置状态，那么将其派发到该请求所在楼层。
2. 如果所有电梯都在运行中，那么选择与请求楼层最近的那台电梯，同时遵循以下优先级：当前方向的空闲电梯 > 当前方向的运行电梯 > 反方向的电梯。
3. 如果有多台电梯与请求楼层相同，那么选择其中负载最小的那台电梯。

在每个时间片结束时，检查所有电梯的状态，如果有电梯到达目标楼层，那么调整其状态并更新当前有多少乘客离开或进入电梯。如果所有电梯都处于闲置状态，那么等待下一次请求。如果有更高或更低的请求，那么调整电梯的运行方向并重复上述过程。

简单起见，以下代码省略了初始化、请求存储等部分，仅给出电梯调度逻辑的核心部分：

#define MAX_ELEVATORS 4
#define MAX_FLOORS 20

typedef enum { IDLE, UP, DOWN } Direction;

typedef struct {
    int floor;
    Direction dir;
    int passengers;
} Elevator;

Elevator elevators[MAX_ELEVATORS];

int dispatch_request(int source, int target) {
    int best_elevator = -1;
    int best_distance = MAX_FLOORS + 1;  // 初始化一个比最大楼层数还大的值

    // 遍历所有电梯，选择最合适的那台电梯
    for (int i = 0; i < MAX_ELEVATORS; i++) {
        int distance = abs(elevators[i].floor - source);
        if (elevators[i].dir == IDLE ||  // 选择状态闲置的电梯
                (elevators[i].dir == UP && target > source && elevators[i].floor <= source) ||  // 当前方向上升且请求在电梯上面
                (elevators[i].dir == DOWN && target < source && elevators[i].floor >= source) ||  // 当前方向下降且请求在电梯下面
                distance < best_distance) {  // 如果无法满足上述条件，就选择距离最近的电梯
            if (elevators[i].dir == IDLE ||
                    (elevators[i].dir == UP && target > source && elevators[i].dir != DOWN) ||
                    (elevators[i].dir == DOWN && target < source && elevators[i].dir != UP)) {  // 如果有多台电梯满足条件，那么根据以下优先级选择其中之一
                best_elevator = i;
                best_distance = distance;
            }
        }
    }

    // 将请求分派给最优电梯
    if (best_elevator != -1) {
        elevators[best_elevator].dir = source > elevators[best_elevator].floor ? UP : DOWN;
        return best_elevator;
    }
    return -1;  // 没有可用电梯，等待下一次请求
}

void update_elevator_state(int elevator) {
    if (elevators[elevator].dir == UP) {
        elevators[elevator].floor++;
    } else if (elevators[elevator].dir == DOWN) {
        elevators[elevator].floor--;
    }

    // 到达最高楼层或最低楼层时改变方向
    if (elevators[elevator].floor == MAX_FLOORS) {
        elevators[elevator].dir = DOWN;
    } else if (elevators[elevator].floor == 1) {
        elevators[elevator].dir = UP;
    }

    // 到达目标楼层时更新状态
    // NOTE: 进一步优化时可以加上其他附加的判断条件，如当前是上升还是下降状态、电梯负载等
    if (elevators[elevator].floor == elevators[elevator].target_floor) {
        elevators[elevator].dir = IDLE;
        elevators[elevator].passengers -= elevators[elevator].leaving;
        elevators[elevator].passengers += elevators[elevator].entering;
        elevators[elevator].target_floor = -1;
        elevators[elevator].entering = 0;
        elevators[elevator].leaving = 0;
    }
}

int main() {
    while (true) {  // 循环执行电梯调度过程
        for (int i = 0; i < MAX_ELEVATORS; i++) {
            update_elevator_state(i);
        }
        // 监听是否有请求到达
        // 假设有一个名为request_queue的队列，其中的元素格式为{source_floor, target_floor}
        // 每次轮询队列，将请求分派给可用的电梯
        while (!is_empty(request_queue)) {
            int request[2];
            dequeue(request_queue, request);
            int elevator = dispatch_request(request[0], request[1]);
            if (elevator != -1) {
                // 如果有可用电梯，将请求加入指定电梯的进入队列
                int entering = rand() % (MAX_CAPACITY - elevators[elevator].passengers + 1);
                elevators[elevator].target_floor = request[1];
                elevators[elevator].entering = entering;
                elevators[elevator].leaving = elevators[elevator].passengers > entering ? rand() % (elevators[elevator].passengers - entering) : 0;
            }
        }
        // 等待一段时间，然后进入下一个时间片
        sleep(500);
    }
    return 0;
}