第7章：核心产品线技术体系

美团外卖配送技术体系
┌────────────────────────────────────────────┐
│              智能调度大脑                   │
│         (AI模型/优化算法/预测引擎)           │
└──────────────┬─────────────────────────────┘
               │
┌──────────────┼─────────────────────────────┐
│              │                              │
│  ┌───────────▼──────────┐  ┌──────────────┐│
│  │    订单分配系统       │  │  运力管理系统 ││
│  │  (实时派单/智能改派)  │  │ (骑手调度/排班)││
│  └──────────────────────┘  └──────────────┘│
│                                             │
│  ┌──────────────────────┐  ┌──────────────┐│
│  │    路径规划系统       │  │  时效预估系统 ││
│  │  (最优路径/动态规划)  │  │ (送达时间预测)││
│  └──────────────────────┘  └──────────────┘│
└─────────────────────────────────────────────┘

class MultiObjectiveDispatcher:
    """
    多目标优化派单算法
    目标：用户体验、骑手收益、平台成本的平衡
    """

    def __init__(self):
        self.weights = {
            'user_experience': 0.4,
            'rider_income': 0.3,
            'platform_cost': 0.3
        }

    def dispatch(self, orders, riders):
        # 构建优化模型
        model = self.build_optimization_model(orders, riders)

        # 求解最优分配
        solution = self.solve(model)

        return solution

    def build_optimization_model(self, orders, riders):
        """
        构建混合整数规划模型
        """
        from ortools.linear_solver import pywraplp

        solver = pywraplp.Solver.CreateSolver('SCIP')

        # 决策变量：x[i][j] = 1 表示订单i分配给骑手j
        x = {}
        for i, order in enumerate(orders):
            for j, rider in enumerate(riders):
                x[i, j] = solver.IntVar(0, 1, f'x_{i}_{j}')

        # 约束1：每个订单只能分配给一个骑手
        for i in range(len(orders)):
            solver.Add(sum(x[i, j] for j in range(len(riders))) == 1)

        # 约束2：骑手容量限制
        for j, rider in enumerate(riders):
            current_load = len(rider.current_orders)
            max_capacity = rider.max_capacity
            solver.Add(
                sum(x[i, j] for i in range(len(orders))) <= 
                max_capacity - current_load
            )

        # 约束3：时效约束
        for i, order in enumerate(orders):
            for j, rider in enumerate(riders):
                delivery_time = self.estimate_delivery_time(order, rider)
                if delivery_time > order.promise_time:
                    solver.Add(x[i, j] == 0)

        # 目标函数：多目标加权
        objective = solver.Objective()

        for i, order in enumerate(orders):
            for j, rider in enumerate(riders):
                # 用户体验得分
                user_score = self.calculate_user_score(order, rider)

                # 骑手收益得分
                rider_score = self.calculate_rider_score(order, rider)

                # 平台成本得分
                cost_score = self.calculate_cost_score(order, rider)

                # 综合得分
                total_score = (
                    self.weights['user_experience'] * user_score +
                    self.weights['rider_income'] * rider_score +
                    self.weights['platform_cost'] * cost_score
                )

                objective.SetCoefficient(x[i, j], total_score)

        objective.SetMaximization()

        return solver, x

    def estimate_delivery_time(self, order, rider):
        """
        配送时间预估模型
        """
        features = {
            'distance': self.calculate_distance(rider.location, order.restaurant),
            'rider_speed': rider.average_speed,
            'weather': self.get_weather_factor(),
            'traffic': self.get_traffic_condition(),
            'merchant_prepare_time': order.merchant.avg_prepare_time,
            'rider_familiarity': rider.get_area_familiarity(order.area),
            'current_load': len(rider.current_orders)
        }

        # 使用XGBoost模型预测
        return self.time_prediction_model.predict(features)

@Service
public class PressureSchedulingSystem {
    /**

     * 高峰期压力调度
     */

    @Autowired
    private RiderPoolManager riderPoolManager;

    @Autowired
    private DemandPredictor demandPredictor;

    public void handlePeakPressure(String areaId) {
        // 预测未来30分钟订单量
        int predictedOrders = demandPredictor.predict(areaId, 30);

        // 计算运力缺口
        int currentCapacity = riderPoolManager.getAvailableCapacity(areaId);
        int gap = predictedOrders - currentCapacity;

        if (gap > 0) {
            // 多策略并行调度
            CompletableFuture<Integer> crossAreaScheduling = 
                CompletableFuture.supplyAsync(() -> 
                    scheduleCrossAreaRiders(areaId, gap));

            CompletableFuture<Integer> partTimeActivation = 
                CompletableFuture.supplyAsync(() -> 
                    activatePartTimeRiders(areaId, gap));

            CompletableFuture<Integer> incentiveScheduling = 
                CompletableFuture.supplyAsync(() -> 
                    offerIncentives(areaId, gap));

            // 等待所有策略完成
            CompletableFuture.allOf(
                crossAreaScheduling, 
                partTimeActivation, 
                incentiveScheduling
            ).join();

            // 评估调度效果
            evaluateSchedulingEffect(areaId);
        }
    }

    private int scheduleCrossAreaRiders(String targetArea, int needed) {
        // 从临近区域调度骑手
        List<String> nearbyAreas = getNearbyAreas(targetArea);
        int scheduled = 0;

        for (String area : nearbyAreas) {
            List<Rider> availableRiders = riderPoolManager
                .getIdleRiders(area)
                .stream()
                .filter(r -> r.canRelocate())
                .limit(needed - scheduled)
                .collect(Collectors.toList());

            for (Rider rider : availableRiders) {
                sendRelocationRequest(rider, targetArea);
                scheduled++;
            }

            if (scheduled >= needed) break;
        }

        return scheduled;
    }
}

路径规划算法对比
┌──────────────┬────────────┬────────────┬────────────┐
│   算法       │  适用场景   │   优点     │   缺点     │
├──────────────┼────────────┼────────────┼────────────┤
│ Dijkstra    │ 单点配送   │ 最优解     │ 计算慢     │
│ A*          │ 实时导航   │ 快速高效   │ 需要启发式  │
│ 遗传算法     │ 多点配送   │ 全局优化   │ 收敛慢     │
│ 蚁群算法     │ 动态环境   │ 自适应     │ 参数敏感   │
│ 深度强化学习 │ 复杂场景   │ 自学习     │ 需要大量数据│
└──────────────┴────────────┴────────────┴────────────┘

class HotelSearchEngine:
    """
    酒店搜索引擎
    """

    def __init__(self):
        self.es_client = Elasticsearch()
        self.ranking_model = self.load_ranking_model()

    def search(self, query):
        # 第一阶段：召回
        recall_results = self.recall_phase(query)

        # 第二阶段：粗排
        coarse_ranking = self.coarse_ranking(recall_results, query)

        # 第三阶段：精排
        fine_ranking = self.fine_ranking(coarse_ranking[:100], query)

        # 第四阶段：重排（考虑多样性、业务规则等）
        final_results = self.reranking(fine_ranking[:50], query)

        return final_results

    def recall_phase(self, query):
        """
        多路召回策略
        """
        results = []

        # 地理位置召回
        geo_recall = self.geo_based_recall(
            query.location, 
            query.radius
        )
        results.extend(geo_recall)

        # 文本召回
        text_recall = self.text_based_recall(
            query.keywords,
            query.filters
        )
        results.extend(text_recall)

        # 协同过滤召回
        if query.user_id:
            cf_recall = self.collaborative_filtering_recall(
                query.user_id
            )
            results.extend(cf_recall)

        # 热门召回
        popular_recall = self.popularity_based_recall(
            query.city
        )
        results.extend(popular_recall[:20])

        # 去重
        return list(set(results))

    def fine_ranking(self, hotels, query):
        """
        深度学习精排模型
        """
        features = []
        for hotel in hotels:
            feature = self.extract_features(hotel, query)
            features.append(feature)

        # 批量预测
        scores = self.ranking_model.predict(np.array(features))

        # 按分数排序
        ranked_hotels = sorted(
            zip(hotels, scores), 
            key=lambda x: x[1], 
            reverse=True
        )

        return [hotel for hotel, _ in ranked_hotels]

@Service
public class DynamicPricingEngine {

    /**

     * 酒店房间动态定价
     */
    public BigDecimal calculateDynamicPrice(
            String hotelId, 
            String roomType, 
            LocalDate date) {

        // 基础价格
        BigDecimal basePrice = getBasePrice(hotelId, roomType);

        // 需求因子
        double demandFactor = calculateDemandFactor(hotelId, date);

        // 供给因子
        double supplyFactor = calculateSupplyFactor(hotelId, roomType, date);

        // 竞争因子
        double competitionFactor = calculateCompetitionFactor(hotelId, date);

        // 季节因子
        double seasonalFactor = getSeasonalFactor(date);

        // 事件因子（展会、节假日等）
        double eventFactor = getEventFactor(hotelId, date);

        // 用户因子
        double userFactor = getUserFactor();

        // 综合定价
        BigDecimal dynamicPrice = basePrice
            .multiply(BigDecimal.valueOf(demandFactor))
            .multiply(BigDecimal.valueOf(supplyFactor))
            .multiply(BigDecimal.valueOf(competitionFactor))
            .multiply(BigDecimal.valueOf(seasonalFactor))
            .multiply(BigDecimal.valueOf(eventFactor))
            .multiply(BigDecimal.valueOf(userFactor));

        // 价格边界控制
        return enforePriceBounds(dynamicPrice, basePrice);
    }

    private double calculateDemandFactor(String hotelId, LocalDate date) {
        // 历史预订数据
        int historicalBookings = getHistoricalBookings(hotelId, date);

        // 搜索热度
        int searchVolume = getSearchVolume(hotelId, date);

        // 转化率
        double conversionRate = getConversionRate(hotelId);

        // 预测需求
        double predictedDemand = predictDemand(
            historicalBookings, 
            searchVolume, 
            conversionRate
        );

        // 需求因子（0.8 - 1.5）
        return Math.max(0.8, Math.min(1.5, predictedDemand / 100));
    }
}

酒店库存管理架构
┌────────────────────────────────────────┐
│           库存中心                      │
│    (实时库存/预留库存/超售管理)          │
└──────────────┬─────────────────────────┘
               │
    ┌──────────┼──────────┐
    │          │          │
┌───▼───┐ ┌───▼───┐ ┌───▼───┐
│直连库存│ │代理库存│ │缓存库存│
│(PMS)  │ │(OTA)  │ │(Redis)│
└───────┘ └───────┘ └───────┘

库存同步策略：
• 实时推送：库存变化立即同步
• 定时拉取：每5分钟全量同步
• 增量同步：变化部分同步
• 对账机制：每日对账确保一致性

type LocalSearchService struct {
    geoIndex    *GeospatialIndex
    textIndex   *TextSearchIndex
    graphEngine *GraphQueryEngine
}

// 本地商家搜索
func (s *LocalSearchService) Search(req SearchRequest) SearchResponse {
    // 地理位置过滤
    nearbyMerchants := s.geoIndex.FindNearby(
        req.Location, 
        req.Radius,
    )

    // 文本搜索
    textMatches := s.textIndex.Search(req.Query)

    // 交集计算
    candidates := intersect(nearbyMerchants, textMatches)

    // 图查询增强（关联推荐）
    if req.EnableGraphEnhancement {
        relatedMerchants := s.graphEngine.FindRelated(
            candidates,
            req.UserID,
        )
        candidates = append(candidates, relatedMerchants...)
    }

    // 个性化排序
    ranked := s.personalizedRanking(candidates, req.UserID)

    // 过滤和分页
    results := s.filterAndPaginate(ranked, req)

    return SearchResponse{
        Merchants: results,
        Total:     len(candidates),
    }
}

// 地理空间索引
type GeospatialIndex struct {
    quadTree *QuadTree
    geoHash  *GeoHashIndex
}

func (g *GeospatialIndex) FindNearby(location Point, radius float64) []Merchant {
    // 使用GeoHash快速过滤
    geoHashPrefixes := g.calculateGeoHashPrefixes(location, radius)
    candidates := g.geoHash.GetMerchantsByPrefixes(geoHashPrefixes)

    // 精确距离计算
    var results []Merchant
    for _, merchant := range candidates {
        distance := haversineDistance(location, merchant.Location)
        if distance <= radius {
            merchant.Distance = distance
            results = append(results, merchant)
        }
    }

    return results
}

class CouponSystem:
    """
    优惠券发放与核销系统
    """

    def __init__(self):
        self.redis = Redis()
        self.db = Database()

    def issue_coupon(self, campaign_id, user_id):
        """
        发放优惠券（防止超发）
        """
        lua_script = """
        local campaign_key = KEYS[1]
        local user_key = KEYS[2]
        local user_id = ARGV[1]
        local max_total = tonumber(ARGV[2])
        local max_per_user = tonumber(ARGV[3])

        -- 检查总量限制
        local issued_total = redis.call('GET', campaign_key .. ':total')
        if issued_total and tonumber(issued_total) >= max_total then
            return {0, 'SOLD_OUT'}
        end

        -- 检查用户限制
        local user_count = redis.call('HGET', user_key, user_id)
        if user_count and tonumber(user_count) >= max_per_user then
            return {0, 'USER_LIMIT_EXCEEDED'}
        end

        -- 发放优惠券
        redis.call('INCR', campaign_key .. ':total')
        redis.call('HINCRBY', user_key, user_id, 1)

        return {1, 'SUCCESS'}
        """

        result = self.redis.eval(
            lua_script,
            keys=[f'campaign:{campaign_id}', f'user_issued:{campaign_id}'],
            args=[user_id, campaign.max_total, campaign.max_per_user]
        )

        if result[0] == 1:
            # 异步写入数据库
            self.async_save_coupon(campaign_id, user_id)

        return result[1]

    def verify_and_use_coupon(self, coupon_code, order_amount):
        """
        核销优惠券
        """
        # 验证优惠券有效性
        coupon = self.get_coupon(coupon_code)

        if not coupon:
            return {'valid': False, 'reason': 'INVALID_CODE'}

        if coupon.status != 'ISSUED':
            return {'valid': False, 'reason': 'ALREADY_USED'}

        if coupon.expire_time < datetime.now():
            return {'valid': False, 'reason': 'EXPIRED'}

        if order_amount < coupon.min_amount:
            return {'valid': False, 'reason': 'AMOUNT_NOT_ENOUGH'}

        # 使用优惠券（防止并发）
        with self.redis.lock(f'coupon_lock:{coupon_code}'):
            # 再次检查状态
            if self.is_coupon_used(coupon_code):
                return {'valid': False, 'reason': 'ALREADY_USED'}

            # 标记为已使用
            self.mark_coupon_used(coupon_code)

            # 计算优惠金额
            discount = self.calculate_discount(coupon, order_amount)

            return {
                'valid': True,
                'discount': discount,
                'final_amount': order_amount - discount
            }

class BikeRebalancingSystem:
    """
    共享单车智能调度系统
    """

    def __init__(self):
        self.predictor = DemandPredictor()
        self.optimizer = RouteOptimizer()

    def generate_rebalancing_plan(self, city_id):
        """
        生成调度计划
        """
        # 获取所有站点信息
        stations = self.get_all_stations(city_id)

        # 预测各站点供需
        predictions = []
        for station in stations:
            supply = station.current_bikes
            demand = self.predictor.predict_demand(
                station.id,
                datetime.now() + timedelta(hours=2)
            )
            predictions.append({
                'station': station,
                'supply': supply,
                'demand': demand,
                'gap': demand - supply
            })

        # 识别供给站和需求站
        supply_stations = [p for p in predictions if p['gap'] < -5]
        demand_stations = [p for p in predictions if p['gap'] > 5]

        # 生成调度任务
        tasks = self.match_supply_demand(supply_stations, demand_stations)

        # 车辆路径优化
        routes = self.optimizer.optimize_routes(tasks)

        return RebalancingPlan(tasks=tasks, routes=routes)

    def match_supply_demand(self, supply_stations, demand_stations):
        """
        供需匹配算法
        """
        from scipy.optimize import linear_sum_assignment

        # 构建成本矩阵
        n = len(supply_stations)
        m = len(demand_stations)
        cost_matrix = np.zeros((n, m))

        for i, supply in enumerate(supply_stations):
            for j, demand in enumerate(demand_stations):
                # 考虑距离和优先级
                distance = self.calculate_distance(
                    supply['station'].location,
                    demand['station'].location
                )
                priority = demand['station'].priority
                cost = distance / priority
                cost_matrix[i][j] = cost

        # 使用匈牙利算法求解
        row_ind, col_ind = linear_sum_assignment(cost_matrix)

        # 生成调度任务
        tasks = []
        for i, j in zip(row_ind, col_ind):
            tasks.append({
                'from': supply_stations[i]['station'],
                'to': demand_stations[j]['station'],
                'bikes': min(
                    abs(supply_stations[i]['gap']),
                    abs(demand_stations[j]['gap'])
                )
            })

        return tasks

@Service
public class RideDispatchService {

    /**

     * 网约车智能派单
     */
    public DispatchResult dispatch(RideRequest request) {
        // 获取附近司机
        List<Driver> nearbyDrivers = findNearbyDrivers(
            request.getPickupLocation(),
            5000 // 5公里范围
        );

        if (nearbyDrivers.isEmpty()) {
            return DispatchResult.noDriverAvailable();
        }

        // 计算匹配分数
        List<DriverScore> scores = new ArrayList<>();
        for (Driver driver : nearbyDrivers) {
            double score = calculateMatchScore(driver, request);
            scores.add(new DriverScore(driver, score));
        }

        // 排序选择最优司机
        scores.sort((a, b) -> Double.compare(b.score, a.score));

        // 广播给前N个司机
        int broadcastSize = Math.min(3, scores.size());
        List<Driver> candidates = scores.subList(0, broadcastSize)
            .stream()
            .map(s -> s.driver)
            .collect(Collectors.toList());

        // 发送派单请求
        CompletableFuture<Driver> acceptedDriver = 
            broadcastToDrivers(candidates, request);

        try {
            Driver driver = acceptedDriver.get(15, TimeUnit.SECONDS);
            return DispatchResult.success(driver);
        } catch (TimeoutException e) {
            // 无司机接单，扩大范围重试
            return retryWithLargerRadius(request);
        }
    }

    private double calculateMatchScore(Driver driver, RideRequest request) {
        double score = 0;

        // 距离因素 (40%)
        double distance = calculateDistance(
            driver.getCurrentLocation(),
            request.getPickupLocation()
        );
        score += (1 - distance / 5000) * 0.4;

        // 司机评分 (20%)
        score += (driver.getRating() / 5.0) * 0.2;

        // 司机熟悉度 (20%)
        double familiarity = driver.getAreaFamiliarity(
            request.getPickupLocation()
        );
        score += familiarity * 0.2;

        // 订单完成率 (10%)
        score += driver.getCompletionRate() * 0.1;

        // 车型匹配 (10%)
        if (driver.getCarType().equals(request.getPreferredCarType())) {
            score += 0.1;
        }

        return score;
    }
}

美团支付系统架构
┌────────────────────────────────────────┐
│            支付网关                     │
│    (路由/限流/加密/签名验证)            │
└──────────────┬─────────────────────────┘
               │
┌──────────────┼─────────────────────────┐
│              │                          │
│  ┌───────────▼──────────┐  ┌──────────┐│
│  │    支付核心          │  │  风控系统 ││
│  │  (交易/清算/对账)    │  │ (反欺诈)  ││
│  └──────────────────────┘  └──────────┘│
│                                         │
│  ┌──────────────────────┐  ┌──────────┐│
│  │    账户系统          │  │  账务系统 ││
│  │  (余额/提现/充值)    │  │ (记账/对账)││
│  └──────────────────────┘  └──────────┘│
└─────────────────────────────────────────┘

class IntelligentRiskControl:
    """
    实时风控决策引擎
    """

    def __init__(self):
        self.rule_engine = RuleEngine()
        self.ml_models = self.load_models()
        self.graph_analyzer = GraphAnalyzer()

    def evaluate_transaction(self, transaction):
        """
        交易风险评估
        """
        risk_score = 0
        risk_signals = []

        # 规则引擎检查
        rule_results = self.rule_engine.check(transaction)
        for rule in rule_results.triggered_rules:
            risk_score += rule.weight
            risk_signals.append({
                'type': 'rule',
                'name': rule.name,
                'severity': rule.severity
            })

        # 机器学习模型评分
        ml_features = self.extract_ml_features(transaction)
        ml_score = self.ml_models['fraud_detection'].predict_proba(ml_features)[0][1]
        risk_score += ml_score * 50

        if ml_score > 0.7:
            risk_signals.append({
                'type': 'ml_model',
                'name': 'fraud_detection',
                'probability': ml_score
            })

        # 图分析检测
        graph_risk = self.graph_analyzer.analyze(transaction)
        if graph_risk.is_suspicious:
            risk_score += 30
            risk_signals.append({
                'type': 'graph_analysis',
                'pattern': graph_risk.pattern,
                'connected_frauds': graph_risk.connected_frauds
            })

        # 设备指纹分析
        device_risk = self.analyze_device(transaction.device_fingerprint)
        if device_risk > 0.5:
            risk_score += device_risk * 20
            risk_signals.append({
                'type': 'device',
                'risk_level': device_risk
            })

        # 决策
        action = self.make_decision(risk_score, risk_signals)

        return RiskAssessment(
            score=min(risk_score, 100),
            signals=risk_signals,
            action=action
        )

    def make_decision(self, risk_score, risk_signals):
        """
        风险决策
        """
        if risk_score < 30:
            return 'PASS'
        elif risk_score < 60:
            return 'VERIFY'  # 需要额外验证
        elif risk_score < 80:
            return 'MANUAL_REVIEW'  # 人工审核
        else:
            return 'BLOCK'  # 直接拒绝

@Service
public class SmartWarehouseSystem {

    /**

     * 智能分拣系统
     */
    public SortingPlan generateSortingPlan(List<Order> orders) {
        // 订单聚类
        List<OrderCluster> clusters = clusterOrders(orders);

        // 为每个聚类分配分拣区
        Map<OrderCluster, SortingZone> zoneAssignment = 
            assignSortingZones(clusters);

        // 生成拣货路径
        List<PickingRoute> routes = new ArrayList<>();
        for (OrderCluster cluster : clusters) {
            PickingRoute route = optimizePickingRoute(cluster);
            routes.add(route);
        }

        // 分配拣货员
        Map<PickingRoute, Picker> pickerAssignment = 
            assignPickers(routes);

        return new SortingPlan(routes, pickerAssignment, zoneAssignment);
    }

    private PickingRoute optimizePickingRoute(OrderCluster cluster) {
        // 使用TSP算法优化拣货路径
        List<Product> products = cluster.getAllProducts();
        List<Location> locations = products.stream()
            .map(Product::getWarehouseLocation)
            .collect(Collectors.toList());

        // 动态规划求解TSP
        return solveTSP(locations);
    }

    /**

     * 库存预测与补货
     */
    public ReplenishmentPlan predictAndReplenish(String warehouseId) {
        List<SKU> skus = warehouseRepository.getAllSKUs(warehouseId);
        List<ReplenishmentOrder> orders = new ArrayList<>();

        for (SKU sku : skus) {
            // 预测未来N天需求
            int predictedDemand = demandPredictor.predict(
                sku.getId(), 
                7 // 7天
            );

            // 当前库存
            int currentStock = sku.getCurrentStock();

            // 安全库存
            int safetyStock = calculateSafetyStock(sku);

            // 计算补货量
            int replenishmentQty = predictedDemand + safetyStock - currentStock;

            if (replenishmentQty > 0) {
                orders.add(new ReplenishmentOrder(sku, replenishmentQty));
            }
        }

        return new ReplenishmentPlan(orders);
    }
}

美团会员体系架构
┌────────────────────────────────────────┐
│           会员中心                      │
│    (等级/积分/权益/画像)                │
└──────────────┬─────────────────────────┘
               │
    ┌──────────┼──────────┐
    │          │          │
┌───▼───┐ ┌───▼───┐ ┌───▼───┐
│外卖会员│ │酒店会员│ │单车会员│
└───┬───┘ └───┬───┘ └───┬───┘
    │          │          │
    └──────────┼──────────┘
               │
         ┌─────▼─────┐
         │ 权益互通  │
         │ 积分通兑  │
         │ 等级共享  │
         └───────────┘

class CrossMarketingEngine:
    """
    跨业务交叉营销引擎
    """

    def generate_cross_sell_recommendations(self, user_id):
        # 获取用户全业务线画像
        user_profile = self.get_unified_profile(user_id)

        recommendations = []

        # 基于外卖推荐酒店
        if user_profile.has_food_delivery_history:
            hotel_recs = self.recommend_hotels_for_foodie(user_profile)
            recommendations.extend(hotel_recs)

        # 基于酒店推荐美食
        if user_profile.has_hotel_history:
            food_recs = self.recommend_restaurants_near_hotels(user_profile)
            recommendations.extend(food_recs)

        # 基于出行推荐到店
        if user_profile.has_mobility_history:
            store_recs = self.recommend_stores_on_route(user_profile)
            recommendations.extend(store_recs)

        # 个性化排序
        ranked = self.personalized_ranking(recommendations, user_profile)

        return ranked[:10]