12306偷偷改了？连续座位竟这么抢！

某个区段最多允许出多少张票

某个区段最少允许出多少张票

某个站点上车的最多多少张

1车厢1排 A、B、C 号座位

1车厢1排 D、F 号座位

public class SeatAllocator {
    // 座位池缓存：key = [车次+区段+座位类型], value = 可用座位池列表
    private final Map<String, List<SeatPool>> seatPoolCache = new ConcurrentHashMap<>();
    
    // 配额管理：key = [车次+区段+座位类型], value = 当前剩余配额
    private final Map<String, Integer> quotaManager = new ConcurrentHashMap<>();
    
    // 预留订单缓存：key = 订单ID, value = 预留座位列表 + 超时时间戳
    private final Map<String, Reservation> reservationCache = new ConcurrentHashMap<>();

    // 1. 初始化座位池（系统启动时预加载）
    public void initSeatPools(String trainId, String segment, String seatType, int totalSeats) {
        // 实际实现：从数据库加载车厢布局，生成连续座位池
        List<SeatPool> pools = generateContinuousPools(segment, seatType, totalSeats);
        seatPoolCache.put(trainId + "_" + segment + "_" + seatType, pools);
        quotaManager.put(trainId + "_" + segment + "_" + seatType, totalSeats);
    }

    // 2. 核心分配方法（处理连续/混合场景）
    public boolean allocateSeats(BookingRequest request) {
        if (request.isContinuous()) {
            return allocateContinuous(request);
        } elseif (request.isMixedType()) {
            return allocateMixed(request);
        } else {
            return allocateStandard(request);
        }
    }

    // 3. 连续座位分配逻辑
    private boolean allocateContinuous(BookingRequest request) {
        String key = request.getTrainId() + "_" + request.getSegment() + "_" + request.getSeatType();
        
        // 1. 获取可用座位池（按物理连续性筛选）
        List<SeatPool> pools = seatPoolCache.getOrDefault(key, Collections.emptyList());
        SeatPool selectedPool = findContinuousPool(pools, request.getSeatCount());
        
        if (selectedPool == null) {
            returnfalse; // 无连续座位
        }

        // 2. 配额原子性检查（防止超卖）
        if (!checkQuotaAndReserve(key, request.getSeatCount())) {
            returnfalse;
        }

        // 3. 分配座位（标记为预留）
        List<Seat> allocatedSeats = selectedPool.allocateSeats(request.getSeatCount());
        reservationCache.put(request.getOrderId(), new Reservation(allocatedSeats, System.currentTimeMillis() + 45 * 60000));
        
        returntrue;
    }

    // 4. 混合铺位分配逻辑（如卧铺+中铺）
    private boolean allocateMixed(BookingRequest request) {
        List<String> seatTypes = request.getSeatTypes(); // [卧铺, 中铺]
        List<Integer> counts = request.getSeatCounts();  // [1, 1]
        
        // 1. 逐类型检查配额并预留
        for (int i = 0; i < seatTypes.size(); i++) {
            String type = seatTypes.get(i);
            String key = request.getTrainId() + "_" + request.getSegment() + "_" + type;
            
            if (!checkQuotaAndReserve(key, counts.get(i))) {
                returnfalse; // 任一类型配额不足
            }
        }

        // 2. 为每种类型分配座位（独立池）
        List<Seat> allSeats = new ArrayList<>();
        for (int i = 0; i < seatTypes.size(); i++) {
            String type = seatTypes.get(i);
            String key = request.getTrainId() + "_" + request.getSegment() + "_" + type;
            SeatPool pool = findAnyPool(seatPoolCache.getOrDefault(key, Collections.emptyList()));
            allSeats.addAll(pool.allocateSeats(counts.get(i)));
        }
        
        // 3. 保存混合分配结果
        reservationCache.put(request.getOrderId(), new Reservation(allSeats, System.currentTimeMillis() + 45 * 60000));
        returntrue;
    }

    // 购票请求格式
    class BookingRequest {
        private String trainId;
        private String segment;
        private String seatType;
        private List<String> seatTypes; // 混合铺位时使用
        private List<Integer> seatCounts; // 每种类型的数量
        private int seatCount;
        private boolean isContinuous;
        private boolean isMixedType;
        private String orderId;
    }
}