机场出租车调度问题的数学建模与仿真实现

机场出租车调度问题的数学建模与仿真实现

机场出租车调度是典型的运筹优化问题，涉及乘客等待时间、司机收益与机场管理效率的多目标平衡。本文以 2019 年全国大学生数学建模竞赛 C 题为例，拆解如何通过排队论与博弈论构建模型，并提供 Python 仿真代码供参考。

问题背景

在机场场景中，出租车通常在"蓄车池"排队候客。管理人员采集乘客目的地信息后，会对短途乘客（距离小于阈值 d）给予补偿或优先安排。司机则面临选择：加入短途通道（接客快但收入低）还是普通通道（等待久但可能接长途）。核心目标是设计调度方案，在各方利益间找到平衡点。

核心模型

排队论基础

系统主要受乘客到达率、出租车到达率及服务时间影响。飞机班次有固定规律但也存在延误，乘客出站时间随机，路况导致出租车到达具有波动性。

假设乘客到达率为 λ_p，出租车到达率为 λ_d，短途比例为 ρ，服务平均时间为 1/μ。经典的 M/M/1 模型可估算平均等待时间：

W_q = λ / (μ(μ - λ))

该公式过于简化，实际场景需引入优先级机制。对于短途乘客设置专用通道，采用非抢占式优先排队模型：

W_q_short = (λE[S^2]) / (2(1 - ρ_short))
W_q_long = (λE[S^2]) / (2(1 - ρ_short)(1 - ρ_short - ρ_long))

其中 S 为服务时间，ρ 为流量强度。

司机决策与博弈

司机的选择取决于收益预期。收益计算需考虑基本运费、里程费及空返成本：

司机收益 = 基本运费 + 里程费 × 距离 - 空返成本 - 时间成本

利用博弈论中的混合策略均衡分析，设选择短途通道的司机比例为 q，均衡点满足：

E[收益 | 短途] = E[收益 | 普通]

解此方程即可确定司机群体的最优策略比例。

Python 仿真实现

理论推导之后，通过代码模拟验证模型效果。以下是一个简化的离散事件仿真框架，重点展示队列匹配与收益计算逻辑。

import numpy as np
from scipy.stats import expon, uniform

class TaxiSimulator:
    def __init__(self, passenger_rate=50, taxi_rate=60, short_ratio=0.3,
                 d_threshold=15, base_fare=10, fare_per_km=2,
                 waiting_cost=0.3, empty_return_ratio=0.5):
        # 参数初始化
        self.passenger_rate = passenger_rate      # 乘客到达率 (人/小时)
        self.taxi_rate = taxi_rate                # 出租车到达率 (辆/小时)
        self.short_ratio = short_ratio            # 短途乘客比例
        self.d_threshold = d_threshold            # 短途距离阈值 (km)
        self.base_fare = base_fare                # 起步价
        self.fare_per_km = fare_per_km            # 每公里费用
        self.waiting_cost = waiting_cost          # 等待成本 (元/分钟)
        self.empty_return_ratio = empty_return_ratio # 空返概率

        # 系统状态
        self.passenger_queue = []
        self.taxi_queue = []
        self.short_taxi_queue = []
        self.time = 0
        self.stats = {
            'passenger_wait_time': [],
            'driver_profit': [],
            'short_trips_served': 0,
            'long_trips_served': 0
        }

    def generate_distance(self):
        """生成乘客距离 (指数分布，长尾)"""
        is_short = np.random.random() < self.short_ratio
        if is_short:
            return np.random.uniform(2, self.d_threshold)
        else:
            return np.random.exponential(scale=30) + self.d_threshold

    def run_simulation(self, hours=8):
        """模拟系统运行"""
        # 生成事件时间线
        passenger_arrivals = expon.rvs(
            scale=60 / self.passenger_rate,
            size=int(self.passenger_rate * hours * 1.2)
        )
        taxi_arrivals = expon.rvs(
            scale=60 / self.taxi_rate,
            size=int(self.taxi_rate * hours * 1.2)
        )

        passenger_times = np.cumsum(passenger_arrivals)
        taxi_times = np.cumsum(taxi_arrivals)

        p_idx = t_idx = 0
        while p_idx < len(passenger_times) and t_idx < len(taxi_times):
            # 处理乘客到达
            if passenger_times[p_idx] <= taxi_times[t_idx]:
                dist = self.generate_distance()
                self.passenger_queue.append((passenger_times[p_idx], dist))
                p_idx += 1
            # 处理出租车到达
            else:
                # 司机决策：是否加入短途队列
                current_short_ratio = (
                    len(self.passenger_queue) / (len(self.taxi_queue) + 1)
                    if self.passenger_queue else 0
                )
                if np.random.random() < current_short_ratio * 0.5:  # 简化决策模型
                    self.short_taxi_queue.append(taxi_times[t_idx])
                else:
                    self.taxi_queue.append(taxi_times[t_idx])
                t_idx += 1

            self.match_passenger_taxi()

        return self.stats

    def match_passenger_taxi(self):
        """优先匹配短途队列"""
        while self.passenger_queue and (self.taxi_queue or self.short_taxi_queue):
            arrival_time, dist = self.passenger_queue[0]
            is_short = dist <= self.d_threshold

            if is_short and self.short_taxi_queue:
                taxi_time = self.short_taxi_queue.pop(0)
                queue_type = 'short'
            elif self.taxi_queue:
                taxi_time = self.taxi_queue.pop(0)
                queue_type = 'long'
            else:
                break

            # 记录统计信息
            wait_time = max(self.time - arrival_time, 0)
            self.stats['passenger_wait_time'].append(wait_time)

            # 计算司机收益
            fare = self.base_fare + self.fare_per_km * dist
            if is_short and dist < self.d_threshold / 2:
                fare += 5  # 超级短途可能有补偿
            
            if np.random.random() < self.empty_return_ratio:
                profit = fare - dist * 0.5  # 空返成本假设 0.5 元/km
            else:
                profit = fare

            self.stats['driver_profit'].append(profit)

            if is_short:
                self.stats['short_trips_served'] += 1
            else:
                self.stats['long_trips_served'] += 1

            self.passenger_queue.pop(0)

# 运行模拟
sim = TaxiSimulator(passenger_rate=50, taxi_rate=60, short_ratio=0.3)
results = sim.run_simulation(hours=4)

print(f"平均乘客等待时间：{np.mean(results['passenger_wait_time']):.1f}分钟")
print(f"司机平均收益：{np.mean(results['driver_profit']):.1f}元")
print(f"短途服务数量：{results['short_trips_served']}")
print(f"长途服务数量：{results['long_trips_served']}")

这段代码模拟了乘客和出租车的到达过程，实现了基本的优先队列调度。你可以调整参数来观察不同策略的效果，例如改变短途比例或补偿金额。

实际应用与优化方向

此类模型在上海浦东机场等场景已有应用实践。通过 APP 提前收集目的地信息，动态调整长短途分界点，并结合智能补偿机制，能有效降低空驶率并提升满意度。

若要进一步优化，可考虑以下方向：

1. 空间因素：不同航站楼的客流分布差异。
2. 时间动态性：早晚高峰的客流规律变化。
3. 多目标优化：同时兼顾等待时间、司机收益与碳排放。

例如，引入强化学习动态调整补偿策略：

class ReinforcementLearningScheduler:
    def __init__(self):
        self.state_space = ['low', 'medium', 'high']  # 乘客队列状态
        self.action_space = [5, 10, 15]               # 补偿金额
        self.q_table = np.zeros((len(self.state_space), len(self.action_space)))

    def get_state(self, queue_length):
        if queue_length < 10: return 0
        elif queue_length < 20: return 1
        else: return 2

    def choose_action(self, state, epsilon=0.1):
        if np.random.random() < epsilon:
            return np.random.choice(len(self.action_space))
        else:
            return np.argmax(self.q_table[state])

    def update_q_table(self, state, action, reward, next_state, alpha=0.1, gamma=0.9):
        best_next_action = np.argmax(self.q_table[next_state])
        td_target = reward + gamma * self.q_table[next_state][best_next_action]
        td_error = td_target - self.q_table[state][action]
        self.q_table[state][action] += alpha * td_error

这个简单的 Q-learning 框架能让系统自动学习最佳补偿策略，根据实时情况动态调整。

总结

机场出租车调度问题展示了数学建模解决现实复杂问题的典型路径。通过排队论分析系统流程，用博弈论理解参与者行为，再结合计算机模拟，我们能够找到接近最优的解决方案。这种将实际问题转化为数学模型的能力，同样适用于电商仓库拣货、网约车车队管理及外卖配送路由优化等领域。