#算法耗时优化

Junjie

2026-04-13 2a7172b2cb75484692fa794fb19284e51e5e6422

#算法耗时优化

 src/main/java/com/zy/common/model/NavigateNode.java

@@ -4,6 +4,7 @@
import lombok.ToString;

import java.io.Serializable;
import java.util.Collections;
import java.util.List;

/**
@@ -26,6 +27,13 @@
    private String direction;//行走方向
    private String nodeValue;//节点数据
    private String nodeType;//节点类型
    /**
     * 从 nodeValue 预解析出的站点元数据，避免热路径重复 JSON 解析。
     */
    private Integer stationId;
    private List<Integer> bridgeStationIds = Collections.emptyList();
    private Boolean liftTransfer;
    private Boolean rgvCalcFlag;

    public NavigateNode() {
    }

 src/main/java/com/zy/common/utils/NavigateSolution.java

@@ -1,6 +1,7 @@
package com.zy.common.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
@@ -23,6 +24,7 @@
    private static final long REDIS_MAP_CACHE_TTL_SECONDS = 60 * 60 * 24L;
    private static final long MAP_CACHE_TTL_MS = 5000L;
    private static final Map<String, CachedNavigateMap> NAVIGATE_MAP_CACHE = new ConcurrentHashMap<>();
    private static final Map<String, CachedNavigateMapIndex> NAVIGATE_MAP_INDEX_CACHE = new ConcurrentHashMap<>();

    // Open表用优先队列
    public PriorityQueue<NavigateNode> Open = new PriorityQueue<NavigateNode>();
@@ -33,6 +35,10 @@

    public List<List<NavigateNode>> getStationMap(int lev) {
        return cloneNavigateMap(loadCachedNavigateMap("station", lev));
    }

    public NavigateMapIndex getStationMapIndex(int lev) {
        return loadCachedNavigateMapIndex("station", lev);
    }

    public List<List<NavigateNode>> getRgvTrackMap(int lev) {
@@ -49,14 +55,30 @@

        List<List<NavigateNode>> redisNavigateMap = loadNavigateMapFromRedis(mapType, lev);
        if (isValidNavigateMap(redisNavigateMap)) {
            enrichNavigateMapMetadata(redisNavigateMap);
            NAVIGATE_MAP_CACHE.put(cacheKey, new CachedNavigateMap(now, redisNavigateMap));
            return redisNavigateMap;
        }
        clearMapCache(lev);

        List<List<NavigateNode>> navigateNodeList = buildNavigateMap(mapType, lev);
        enrichNavigateMapMetadata(navigateNodeList);
        cacheNavigateMap(cacheKey, mapType, lev, navigateNodeList, now);
        return navigateNodeList;
    }

    private NavigateMapIndex loadCachedNavigateMapIndex(String mapType, int lev) {
        String cacheKey = mapType + ":" + lev;
        long now = System.currentTimeMillis();
        CachedNavigateMapIndex cachedNavigateMapIndex = NAVIGATE_MAP_INDEX_CACHE.get(cacheKey);
        if (cachedNavigateMapIndex != null && now - cachedNavigateMapIndex.cacheAtMs <= MAP_CACHE_TTL_MS) {
            return cachedNavigateMapIndex.navigateMapIndex;
        }

        List<List<NavigateNode>> navigateMap = loadCachedNavigateMap(mapType, lev);
        NavigateMapIndex navigateMapIndex = buildNavigateMapIndex(lev, navigateMap);
        NAVIGATE_MAP_INDEX_CACHE.put(cacheKey, new CachedNavigateMapIndex(now, navigateMapIndex));
        return navigateMapIndex;
    }

    public static void refreshAllMapCaches() {
@@ -82,8 +104,11 @@
        long now = System.currentTimeMillis();
        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.buildNavigateMap("station", lev);
        navigateSolution.enrichNavigateMapMetadata(stationMap);
        navigateSolution.cacheNavigateMap("station:" + lev, "station", lev, stationMap, now);
        navigateSolution.cacheNavigateMapIndex("station:" + lev, lev, stationMap, now);
        List<List<NavigateNode>> rgvMap = navigateSolution.buildNavigateMap("rgv", lev);
        navigateSolution.enrichNavigateMapMetadata(rgvMap);
        navigateSolution.cacheNavigateMap("rgv:" + lev, "rgv", lev, rgvMap, now);
    }

@@ -93,6 +118,7 @@
        }
        NAVIGATE_MAP_CACHE.remove("station:" + lev);
        NAVIGATE_MAP_CACHE.remove("rgv:" + lev);
        NAVIGATE_MAP_INDEX_CACHE.remove("station:" + lev);
        RedisUtil redisUtil = SpringUtils.getBean(RedisUtil.class);
        redisUtil.del(buildRedisCacheKey("station", lev), buildRedisCacheKey("rgv", lev));
    }
@@ -107,6 +133,13 @@
                JSON.toJSONString(navigateNodeList),
                REDIS_MAP_CACHE_TTL_SECONDS);
        NAVIGATE_MAP_CACHE.put(localCacheKey, new CachedNavigateMap(cacheAtMs, navigateNodeList));
    }

    private void cacheNavigateMapIndex(String localCacheKey,
                                       int lev,
                                       List<List<NavigateNode>> navigateNodeList,
                                       long cacheAtMs) {
        NAVIGATE_MAP_INDEX_CACHE.put(localCacheKey, new CachedNavigateMapIndex(cacheAtMs, buildNavigateMapIndex(lev, navigateNodeList)));
    }

    private List<List<NavigateNode>> loadNavigateMapFromRedis(String mapType, int lev) {
@@ -181,6 +214,7 @@

                navigateNode.setNodeType(nodeType);
                navigateNode.setNodeValue(nodeValue);
                applyNodeMetadata(navigateNode);
                navigateNodeRow.add(navigateNode);
            }
            navigateNodeList.add(navigateNodeRow);
@@ -198,6 +232,63 @@
            cloneMap.add(cloneRow);
        }
        return cloneMap;
    }

    private void enrichNavigateMapMetadata(List<List<NavigateNode>> navigateMap) {
        if (navigateMap == null || navigateMap.isEmpty()) {
            return;
        }
        for (List<NavigateNode> row : navigateMap) {
            for (NavigateNode node : row) {
                applyNodeMetadata(node);
            }
        }
    }

    private void applyNodeMetadata(NavigateNode node) {
        if (node == null) {
            return;
        }
        if (node.getNodeValue() == null || node.getNodeValue().trim().isEmpty()) {
            if (node.getBridgeStationIds() == null) {
                node.setBridgeStationIds(Collections.emptyList());
            }
            if (node.getLiftTransfer() == null) {
                node.setLiftTransfer(Boolean.FALSE);
            }
            if (node.getRgvCalcFlag() == null) {
                node.setRgvCalcFlag(Boolean.FALSE);
            }
            return;
        }
        JSONObject valueObj = parseNodeValue(node.getNodeValue());
        if (valueObj == null) {
            if (node.getBridgeStationIds() == null) {
                node.setBridgeStationIds(Collections.emptyList());
            }
            if (node.getLiftTransfer() == null) {
                node.setLiftTransfer(Boolean.FALSE);
            }
            if (node.getRgvCalcFlag() == null) {
                node.setRgvCalcFlag(Boolean.FALSE);
            }
            return;
        }
        node.setStationId(valueObj.getInteger("stationId"));
        JSONArray bridgeStationArray = valueObj.getJSONArray("bridgeStationIds");
        if (bridgeStationArray == null || bridgeStationArray.isEmpty()) {
            node.setBridgeStationIds(Collections.emptyList());
        } else {
            node.setBridgeStationIds(Collections.unmodifiableList(new ArrayList<>(bridgeStationArray.toJavaList(Integer.class))));
        }
        Object isLiftTransfer = valueObj.get("isLiftTransfer");
        if (isLiftTransfer == null) {
            node.setLiftTransfer(Boolean.FALSE);
        } else {
            String isLiftTransferText = String.valueOf(isLiftTransfer);
            node.setLiftTransfer("1".equals(isLiftTransferText) || "true".equalsIgnoreCase(isLiftTransferText));
        }
        node.setRgvCalcFlag(valueObj.containsKey("rgvCalcFlag"));
    }

    private boolean isValidNavigateMap(List<List<NavigateNode>> navigateMap) {
@@ -557,8 +648,14 @@
    }

    private Integer extractStationId(NavigateNode node) {
        JSONObject valueObj = parseNodeValue(node == null ? null : node.getNodeValue());
        return valueObj == null ? null : valueObj.getInteger("stationId");
        if (node == null) {
            return null;
        }
        if (node.getStationId() != null) {
            return node.getStationId();
        }
        applyNodeMetadata(node);
        return node.getStationId();
    }

    private JSONObject parseNodeValue(String nodeValue) {
@@ -689,6 +786,13 @@
        return bestNode;
    }

    public NavigateNode findStationNavigateNode(NavigateMapIndex navigateMapIndex, int stationId) {
        if (navigateMapIndex == null) {
            return null;
        }
        return navigateMapIndex.getBestStationNode(stationId);
    }

    private int countExternalConnectionCount(Integer currentStationId, List<NavigateNode> neighbors) {
        Set<Integer> connectedStationIdSet = new LinkedHashSet<>();
        if (neighbors == null || neighbors.isEmpty()) {
@@ -702,23 +806,125 @@

    private Set<Integer> resolveAdjacentStationIds(Integer currentStationId, NavigateNode node) {
        Set<Integer> stationIdSet = new LinkedHashSet<>();
        JSONObject valueObj = parseNodeValue(node == null ? null : node.getNodeValue());
        if (valueObj == null) {
        if (node == null) {
            return stationIdSet;
        }
        Integer directStationId = valueObj.getInteger("stationId");
        Integer directStationId = extractStationId(node);
        if (directStationId != null && !directStationId.equals(currentStationId)) {
            stationIdSet.add(directStationId);
        }
        if (valueObj.getJSONArray("bridgeStationIds") == null) {
            return stationIdSet;
        }
        for (Integer bridgeStationId : valueObj.getJSONArray("bridgeStationIds").toJavaList(Integer.class)) {
        for (Integer bridgeStationId : node.getBridgeStationIds() == null ? Collections.<Integer>emptyList() : node.getBridgeStationIds()) {
            if (bridgeStationId != null && !bridgeStationId.equals(currentStationId)) {
                stationIdSet.add(bridgeStationId);
            }
        }
        return stationIdSet;
    }

    public List<NavigateNode> getNeighborNodes(NavigateMapIndex navigateMapIndex, NavigateNode node) {
        if (navigateMapIndex == null || node == null) {
            return Collections.emptyList();
        }
        return navigateMapIndex.getNeighborNodes(node);
    }

    public Set<Integer> getConnectedStationIds(NavigateMapIndex navigateMapIndex,
                                               Integer currentStationId,
                                               NavigateNode node) {
        if (navigateMapIndex == null || node == null) {
            return Collections.emptySet();
        }
        return navigateMapIndex.getConnectedStationIds(currentStationId, node);
    }

    private NavigateMapIndex buildNavigateMapIndex(int lev, List<List<NavigateNode>> navigateMap) {
        if (navigateMap == null || navigateMap.isEmpty()) {
            return new NavigateMapIndex(lev,
                    new ArrayList<>(),
                    Collections.emptyMap(),
                    Collections.emptyMap(),
                    Collections.emptyMap(),
                    Collections.emptyMap());
        }

        enrichNavigateMapMetadata(navigateMap);
        Map<String, NavigateNodeMeta> nodeMetaMap = new LinkedHashMap<>();
        Map<String, List<NavigateNode>> neighborNodeMap = new LinkedHashMap<>();
        Map<String, Set<Integer>> connectedStationIdMap = new LinkedHashMap<>();

        for (List<NavigateNode> row : navigateMap) {
            for (NavigateNode node : row) {
                if (node == null || node.getValue() == MapNodeType.DISABLE.id) {
                    continue;
                }
                String nodeKey = buildNodeKey(node);
                nodeMetaMap.put(nodeKey, buildNavigateNodeMeta(node));
                List<NavigateNode> neighborList = extend_current_node(navigateMap, node);
                neighborNodeMap.put(nodeKey, Collections.unmodifiableList(new ArrayList<>(neighborList)));
            }
        }

        Map<Integer, NavigateNode> stationNodeMap = new LinkedHashMap<>();
        Map<Integer, Integer> stationExternalCountMap = new HashMap<>();
        Map<Integer, Integer> stationNeighborCountMap = new HashMap<>();
        for (List<NavigateNode> row : navigateMap) {
            for (NavigateNode node : row) {
                if (node == null || node.getValue() == MapNodeType.DISABLE.id) {
                    continue;
                }
                String nodeKey = buildNodeKey(node);
                Integer stationId = extractStationId(node);
                Set<Integer> connectedStationIds = resolveAdjacentStationIds(stationId, neighborNodeMap.get(nodeKey));
                connectedStationIdMap.put(nodeKey, Collections.unmodifiableSet(connectedStationIds));
                if (stationId == null) {
                    continue;
                }
                int externalConnectionCount = connectedStationIds.size();
                int neighborCount = neighborNodeMap.get(nodeKey).size();
                Integer bestExternalCount = stationExternalCountMap.get(stationId);
                Integer bestNeighborCount = stationNeighborCountMap.get(stationId);
                if (bestExternalCount == null
                        || externalConnectionCount > bestExternalCount
                        || (externalConnectionCount == bestExternalCount && (bestNeighborCount == null || neighborCount > bestNeighborCount))) {
                    stationNodeMap.put(stationId, node);
                    stationExternalCountMap.put(stationId, externalConnectionCount);
                    stationNeighborCountMap.put(stationId, neighborCount);
                }
            }
        }
        return new NavigateMapIndex(lev,
                navigateMap,
                Collections.unmodifiableMap(nodeMetaMap),
                Collections.unmodifiableMap(stationNodeMap),
                Collections.unmodifiableMap(neighborNodeMap),
                Collections.unmodifiableMap(connectedStationIdMap));
    }

    private Set<Integer> resolveAdjacentStationIds(Integer currentStationId, List<NavigateNode> neighbors) {
        Set<Integer> connectedStationIdSet = new LinkedHashSet<>();
        if (neighbors == null || neighbors.isEmpty()) {
            return connectedStationIdSet;
        }
        for (NavigateNode neighbor : neighbors) {
            connectedStationIdSet.addAll(resolveAdjacentStationIds(currentStationId, neighbor));
        }
        return connectedStationIdSet;
    }

    private String buildNodeKey(NavigateNode node) {
        if (node == null) {
            return "";
        }
        return node.getX() + "_" + node.getY();
    }

    private NavigateNodeMeta buildNavigateNodeMeta(NavigateNode node) {
        return new NavigateNodeMeta(
                extractStationId(node),
                node == null || node.getBridgeStationIds() == null ? Collections.emptyList() : node.getBridgeStationIds(),
                node != null && Boolean.TRUE.equals(node.getLiftTransfer()),
                node != null && Boolean.TRUE.equals(node.getRgvCalcFlag())
        );
    }

    public NavigateNode findTrackSiteNoNavigateNode(List<List<NavigateNode>> map, int trackSiteNo) {
@@ -767,6 +973,115 @@

    //------------------A*启发函数-end------------------//

    public static class NavigateMapIndex {
        private final int lev;
        private final List<List<NavigateNode>> navigateMap;
        private final Map<String, NavigateNodeMeta> nodeMetaMap;
        private final Map<Integer, NavigateNode> stationNodeMap;
        private final Map<String, List<NavigateNode>> neighborNodeMap;
        private final Map<String, Set<Integer>> connectedStationIdMap;

        private NavigateMapIndex(int lev,
                                 List<List<NavigateNode>> navigateMap,
                                 Map<String, NavigateNodeMeta> nodeMetaMap,
                                 Map<Integer, NavigateNode> stationNodeMap,
                                 Map<String, List<NavigateNode>> neighborNodeMap,
                                 Map<String, Set<Integer>> connectedStationIdMap) {
            this.lev = lev;
            this.navigateMap = navigateMap == null ? new ArrayList<>() : navigateMap;
            this.nodeMetaMap = nodeMetaMap == null ? Collections.emptyMap() : nodeMetaMap;
            this.stationNodeMap = stationNodeMap == null ? Collections.emptyMap() : stationNodeMap;
            this.neighborNodeMap = neighborNodeMap == null ? Collections.emptyMap() : neighborNodeMap;
            this.connectedStationIdMap = connectedStationIdMap == null ? Collections.emptyMap() : connectedStationIdMap;
        }

        public int getLev() {
            return lev;
        }

        public List<List<NavigateNode>> getNavigateMap() {
            return navigateMap;
        }

        public NavigateNode getBestStationNode(Integer stationId) {
            if (stationId == null) {
                return null;
            }
            return stationNodeMap.get(stationId);
        }

        public List<NavigateNode> getNeighborNodes(NavigateNode node) {
            if (node == null) {
                return Collections.emptyList();
            }
            return neighborNodeMap.getOrDefault(node.getX() + "_" + node.getY(), Collections.emptyList());
        }

        public Set<Integer> getConnectedStationIds(Integer currentStationId, NavigateNode node) {
            if (node == null) {
                return Collections.emptySet();
            }
            Set<Integer> stationIdSet = connectedStationIdMap.getOrDefault(node.getX() + "_" + node.getY(), Collections.emptySet());
            if (currentStationId == null || stationIdSet.isEmpty()) {
                return stationIdSet;
            }
            if (!stationIdSet.contains(currentStationId)) {
                return stationIdSet;
            }
            Set<Integer> filterStationIdSet = new LinkedHashSet<>();
            for (Integer stationId : stationIdSet) {
                if (stationId != null && !stationId.equals(currentStationId)) {
                    filterStationIdSet.add(stationId);
                }
            }
            return filterStationIdSet;
        }

        public Integer getStationId(NavigateNode node) {
            NavigateNodeMeta meta = getNodeMeta(node);
            return meta == null ? null : meta.stationId;
        }

        public List<Integer> getBridgeStationIds(NavigateNode node) {
            NavigateNodeMeta meta = getNodeMeta(node);
            return meta == null ? Collections.emptyList() : meta.bridgeStationIds;
        }

        public boolean isLiftTransfer(NavigateNode node) {
            NavigateNodeMeta meta = getNodeMeta(node);
            return meta != null && meta.liftTransfer;
        }

        public boolean isRgvCalcFlag(NavigateNode node) {
            NavigateNodeMeta meta = getNodeMeta(node);
            return meta != null && meta.rgvCalcFlag;
        }

        private NavigateNodeMeta getNodeMeta(NavigateNode node) {
            if (node == null) {
                return null;
            }
            return nodeMetaMap.get(node.getX() + "_" + node.getY());
        }
    }

    private static class NavigateNodeMeta {
        private final Integer stationId;
        private final List<Integer> bridgeStationIds;
        private final boolean liftTransfer;
        private final boolean rgvCalcFlag;

        private NavigateNodeMeta(Integer stationId,
                                 List<Integer> bridgeStationIds,
                                 boolean liftTransfer,
                                 boolean rgvCalcFlag) {
            this.stationId = stationId;
            this.bridgeStationIds = bridgeStationIds == null ? Collections.emptyList() : bridgeStationIds;
            this.liftTransfer = liftTransfer;
            this.rgvCalcFlag = rgvCalcFlag;
        }
    }

    private static class CachedNavigateMap {
        private final long cacheAtMs;
        private final List<List<NavigateNode>> navigateMap;
@@ -776,4 +1091,14 @@
            this.navigateMap = navigateMap;
        }
    }

    private static class CachedNavigateMapIndex {
        private final long cacheAtMs;
        private final NavigateMapIndex navigateMapIndex;

        private CachedNavigateMapIndex(long cacheAtMs, NavigateMapIndex navigateMapIndex) {
            this.cacheAtMs = cacheAtMs;
            this.navigateMapIndex = navigateMapIndex;
        }
    }
}

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -55,6 +55,7 @@
public class NavigateUtils {

    private static final long STATION_PATH_SLOW_LOG_THRESHOLD_MS = 500L;
    private static final long STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS = 200L;
    private static final double CONGESTION_BUSY_BASE = 1.0d;
    private static final double CONGESTION_ISSUED_RESERVE_BASE = 0.75d;
    private static final double CONGESTION_PENDING_QUEUE_BASE = 0.45d;
@@ -76,6 +77,9 @@
    @Autowired
    private StationTaskTraceRegistry stationTaskTraceRegistry;

    private final Object runtimeSnapshotLock = new Object();
    private volatile CachedStationPathRuntimeSnapshot cachedRuntimeSnapshot;

    public List<NavigateNode> calcOptimalPathByStationId(Integer startStationId,
                                                         Integer endStationId,
                                                         Integer currentTaskNo,
@@ -92,11 +96,13 @@
                                                                 Integer currentTaskNo,
                                                                 Double pathLenFactor) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                StationPathCalcMode.REROUTE
                StationPathCalcMode.REROUTE,
                runtimeSnapshot
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
@@ -108,7 +114,8 @@
                currentTaskNo,
                pathLenFactor,
                startStationId,
                endStationId
                endStationId,
                runtimeSnapshot
        );
        return normalizeCandidatePaths(orderedPathList);
    }
@@ -140,6 +147,9 @@
        long stepStartNs = System.nanoTime();
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        stepCostMap.put("resolvePolicy", elapsedMillis(stepStartNs));
        stepStartNs = System.nanoTime();
        StationPathRuntimeSnapshot runtimeSnapshot = loadStationPathRuntimeSnapshot(currentTaskNo);
        stepCostMap.put("loadRuntimeSnapshot", elapsedMillis(stepStartNs));
        if (calcMode != StationPathCalcMode.REROUTE) {
            stepStartNs = System.nanoTime();
            List<NavigateNode> directPath = findStationDirectPath(
@@ -148,7 +158,8 @@
                    currentTaskNo,
                    pathLenFactor,
                    calcMode,
                    resolvedPolicy
                    resolvedPolicy,
                    runtimeSnapshot
            );
            stepCostMap.put("directPath", elapsedMillis(stepStartNs));
            if (!directPath.isEmpty()) {
@@ -164,7 +175,8 @@
                startStationId,
                endStationId,
                resolvedPolicy,
                calcMode
                calcMode,
                runtimeSnapshot
        );
        stepCostMap.put("buildSearchContext", elapsedMillis(stepStartNs));
        if (context.allList.isEmpty()) {
@@ -175,7 +187,7 @@
        stepStartNs = System.nanoTime();
        List<NavigateNode> list = calcMode == StationPathCalcMode.REACHABILITY
                ? findStationReachablePath(context.allList, context.resolvedPolicy, startStationId, endStationId)
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId, runtimeSnapshot);
        stepCostMap.put("selectBestPath", elapsedMillis(stepStartNs));
        pathSource = calcMode == StationPathCalcMode.REACHABILITY ? "reachability" : "twoStage";
        resultPath = normalizeStationPath(list);
@@ -299,18 +311,24 @@
                                                     Integer currentTaskNo,
                                                     Double pathLenFactor,
                                                     StationPathCalcMode calcMode,
                                                     StationPathResolvedPolicy resolvedPolicy) {
                                                     StationPathResolvedPolicy resolvedPolicy,
                                                     StationPathRuntimeSnapshot runtimeSnapshot) {
        if (!supportsDirectPathMode(calcMode, resolvedPolicy, pathLenFactor)) {
            return new ArrayList<>();
        }

        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        long stepStartNs = System.nanoTime();
        DirectStationPathContext context = buildDirectStationPathContext(
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode,
                resolvedPolicy
                resolvedPolicy,
                runtimeSnapshot
        );
        stepCostMap.put("buildDirectContext", elapsedMillis(stepStartNs));
        if (context == null) {
            return new ArrayList<>();
        }
@@ -321,6 +339,7 @@
                endStationId,
                calcMode.name());

        stepStartNs = System.nanoTime();
        DirectPathSearchResult searchResult = searchDirectPathWithFallback(
                context,
                true,
@@ -336,23 +355,30 @@
                News.info("[WCS Debug] 站点路径快速计算已降级，忽略关键途经点约束后重试");
            }
        }
        stepCostMap.put("searchDirectPath", elapsedMillis(stepStartNs));
        if (searchResult.path.isEmpty()) {
            logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, 0, stepCostMap, totalStartNs);
            return new ArrayList<>();
        }

        stepStartNs = System.nanoTime();
        if (!isDirectPathValid(
                searchResult.path,
                context,
                searchResult.includeWaypoint,
                searchResult.includeSoftPreference)) {
            stepCostMap.put("validateDirectPath", elapsedMillis(stepStartNs));
            logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, searchResult.path.size(), stepCostMap, totalStartNs);
            return new ArrayList<>();
        }
        stepCostMap.put("validateDirectPath", elapsedMillis(stepStartNs));

        News.info("[WCS Debug] 站点路径快速计算完成，耗时：{}ms,startStationId={},endStationId={},mode={}",
                System.currentTimeMillis() - startTime,
                startStationId,
                endStationId,
                calcMode.name());
        logDirectPathSlow(startStationId, endStationId, currentTaskNo, calcMode, pathLenFactor, searchResult.path.size(), stepCostMap, totalStartNs);
        return searchResult.path;
    }

@@ -397,8 +423,12 @@
                return new ArrayList<>();
            }

            NavigateNode segmentStartNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentStartStationId);
            NavigateNode segmentEndNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentEndStationId);
            NavigateNode segmentStartNode = context.navigateMapIndex == null
                    ? context.navigateSolution.findStationNavigateNode(context.stationMap, segmentStartStationId)
                    : context.navigateSolution.findStationNavigateNode(context.navigateMapIndex, segmentStartStationId);
            NavigateNode segmentEndNode = context.navigateMapIndex == null
                    ? context.navigateSolution.findStationNavigateNode(context.stationMap, segmentEndStationId)
                    : context.navigateSolution.findStationNavigateNode(context.navigateMapIndex, segmentEndStationId);
            if (segmentStartNode == null || segmentEndNode == null) {
                return new ArrayList<>();
            }
@@ -439,7 +469,9 @@
                return buildDirectPath(currentState);
            }

            List<NavigateNode> nextNodeList = context.navigateSolution.extend_current_node(context.stationMap, currentState.node);
            List<NavigateNode> nextNodeList = context.navigateMapIndex == null
                    ? context.navigateSolution.extend_current_node(context.stationMap, currentState.node)
                    : context.navigateSolution.getNeighborNodes(context.navigateMapIndex, currentState.node);
            for (NavigateNode nextNode : safeList(nextNodeList)) {
                if (!isDirectTransitionAllowed(context, currentState.node, nextNode, endNode)) {
                    continue;
@@ -577,23 +609,10 @@
    }

    private int calcLiftTransferPenalty(NavigateNode node) {
        if (node == null || node.getNodeValue() == null) {
        if (node == null) {
            return 0;
        }
        try {
            JSONObject valueObject = JSON.parseObject(node.getNodeValue());
            if (valueObject == null) {
                return 0;
            }
            Object isLiftTransfer = valueObject.get("isLiftTransfer");
            if (isLiftTransfer == null) {
                return 0;
            }
            String text = String.valueOf(isLiftTransfer);
            return ("1".equals(text) || "true".equalsIgnoreCase(text)) ? 1 : 0;
        } catch (Exception ignore) {
            return 0;
        }
        return Boolean.TRUE.equals(node.getLiftTransfer()) ? 1 : 0;
    }

    private double calcHeuristicScore(NavigateNode currentNode, NavigateNode endNode) {
@@ -744,16 +763,18 @@
                                                                   Integer endStationId,
                                                                   Integer currentTaskNo,
                                                                   StationPathCalcMode calcMode,
                                                                   StationPathResolvedPolicy resolvedPolicy) {
                                                                   StationPathResolvedPolicy resolvedPolicy,
                                                                   StationPathRuntimeSnapshot runtimeSnapshot) {
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 " + startStationId + "起点 对应的站点数据");
        }

        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(startStation.getStationLev());
        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        NavigateSolution.NavigateMapIndex navigateMapIndex = navigateSolution.getStationMapIndex(startStation.getStationLev());
        List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();
        NavigateNode startNode = navigateSolution.findStationNavigateNode(navigateMapIndex, startStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(navigateMapIndex, endStationId);
        if (startNode == null || endNode == null) {
            throw new CoolException("未找到该 " + startStationId + "起点 或 " + endStationId + "终点 对应的节点");
        }
@@ -763,6 +784,7 @@
        context.startStationId = startStationId;
        context.endStationId = endStationId;
        context.navigateSolution = navigateSolution;
        context.navigateMapIndex = navigateMapIndex;
        context.stationMap = stationMap;
        context.startNode = startNode;
        context.endNode = endNode;
@@ -774,11 +796,12 @@
                ? StationPathProfileConfig.defaultConfig()
                : context.resolvedPolicy.getProfileConfig();
        context.globalPolicy = loadPathGlobalPolicy(context.profileConfig);
        context.statusMap = loadStationStatusMap();
        context.stationLoopLoadMap = loadStationLoopLoadMap();
        context.trafficSnapshot = loadStationTrafficSnapshot(context.statusMap, currentTaskNo);
        context.loopMergeGuardContext = loadLoopMergeGuardContext();
        context.outStationIdSet = loadAllOutStationIdSet();
        context.runtimeSnapshot = runtimeSnapshot == null ? StationPathRuntimeSnapshot.empty() : runtimeSnapshot;
        context.statusMap = context.runtimeSnapshot.statusMap;
        context.stationLoopLoadMap = context.runtimeSnapshot.stationLoopLoadMap;
        context.trafficSnapshot = context.runtimeSnapshot.trafficSnapshot;
        context.loopMergeGuardContext = context.runtimeSnapshot.loopMergeGuardContext;
        context.outStationIdSet = context.runtimeSnapshot.outStationIdSet;
        context.forbidStationIdSet = new HashSet<>(safeList(context.ruleConfig.getHard() == null ? null : context.ruleConfig.getHard().getForbidStations()));
        context.forbidEdgeSet = new HashSet<>();
        for (String edgeText : safeList(context.ruleConfig.getHard() == null ? null : context.ruleConfig.getHard().getForbidEdges())) {
@@ -826,8 +849,9 @@
                                                           Integer currentTaskNo,
                                                           Double pathLenFactor,
                                                           Integer startStationId,
                                                           Integer endStationId) {
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
                                                           Integer endStationId,
                                                           StationPathRuntimeSnapshot runtimeSnapshot) {
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId, runtimeSnapshot);
        if (orderedPathList.isEmpty()) {
            return new ArrayList<>();
        }
@@ -839,7 +863,8 @@
                                                                Integer currentTaskNo,
                                                                Double pathLenFactor,
                                                                Integer startStationId,
                                                                Integer endStationId) {
                                                                Integer endStationId,
                                                                StationPathRuntimeSnapshot runtimeSnapshot) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        if (allList == null || allList.isEmpty()) {
@@ -882,12 +907,12 @@
        stepCostMap.put("filterCandidates", elapsedMillis(stepStartNs));

        stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        Map<Integer, Double> stationLoopLoadMap = loadStationLoopLoadMap();
        StationTrafficSnapshot trafficSnapshot = loadStationTrafficSnapshot(statusMap, currentTaskNo);
        LoopMergeGuardContext loopMergeGuardContext = loadLoopMergeGuardContext();
        Map<Integer, StationProtocol> statusMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.statusMap;
        Map<Integer, Double> stationLoopLoadMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.stationLoopLoadMap;
        StationTrafficSnapshot trafficSnapshot = runtimeSnapshot == null ? new StationTrafficSnapshot() : runtimeSnapshot.trafficSnapshot;
        LoopMergeGuardContext loopMergeGuardContext = runtimeSnapshot == null ? new LoopMergeGuardContext() : runtimeSnapshot.loopMergeGuardContext;
        Set<LoopMergeEntry> mandatoryLoopMergeEntrySet = resolveMandatoryLoopMergeEntrySet(filteredCandidates, loopMergeGuardContext);
        Set<Integer> outStationIdSet = loadAllOutStationIdSet();
        Set<Integer> outStationIdSet = runtimeSnapshot == null ? Collections.emptySet() : runtimeSnapshot.outStationIdSet;
        stepCostMap.put("loadDynamicContext", elapsedMillis(stepStartNs));
        List<PathCandidateMetrics> metricsList = new ArrayList<>();
        int skippedByOtherOutStation = 0;
@@ -1389,19 +1414,8 @@
    private int countLiftTransferCount(List<NavigateNode> path) {
        int count = 0;
        for (NavigateNode node : safeList(path)) {
            try {
                JSONObject valueObject = JSON.parseObject(node.getNodeValue());
                if (valueObject == null) {
                    continue;
                }
                Object isLiftTransfer = valueObject.get("isLiftTransfer");
                if (isLiftTransfer != null) {
                    String text = String.valueOf(isLiftTransfer);
                    if ("1".equals(text) || "true".equalsIgnoreCase(text)) {
                        count++;
                    }
                }
            } catch (Exception ignore) {
            if (node != null && Boolean.TRUE.equals(node.getLiftTransfer())) {
                count++;
            }
        }
        return count;
@@ -1636,6 +1650,51 @@
        return statusMap;
    }

    private StationPathRuntimeSnapshot loadStationPathRuntimeSnapshot(Integer currentTaskNo) {
        BaseRuntimeSnapshot baseRuntimeSnapshot = loadBaseRuntimeSnapshot();
        if (baseRuntimeSnapshot == null) {
            return StationPathRuntimeSnapshot.empty();
        }
        StationTrafficSnapshot trafficSnapshot = buildStationTrafficSnapshot(
                baseRuntimeSnapshot.statusMap,
                currentTaskNo,
                baseRuntimeSnapshot.activeTraceList
        );
        return new StationPathRuntimeSnapshot(
                baseRuntimeSnapshot.statusMap,
                baseRuntimeSnapshot.stationLoopLoadMap,
                trafficSnapshot,
                baseRuntimeSnapshot.loopMergeGuardContext,
                baseRuntimeSnapshot.outStationIdSet
        );
    }

    private BaseRuntimeSnapshot loadBaseRuntimeSnapshot() {
        long now = System.currentTimeMillis();
        CachedStationPathRuntimeSnapshot cachedSnapshot = cachedRuntimeSnapshot;
        if (cachedSnapshot != null && now - cachedSnapshot.cacheAtMs <= STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS) {
            return cachedSnapshot.baseRuntimeSnapshot;
        }
        synchronized (runtimeSnapshotLock) {
            cachedSnapshot = cachedRuntimeSnapshot;
            if (cachedSnapshot != null && now - cachedSnapshot.cacheAtMs <= STATION_PATH_RUNTIME_SNAPSHOT_TTL_MS) {
                return cachedSnapshot.baseRuntimeSnapshot;
            }
            BaseRuntimeSnapshot baseRuntimeSnapshot = buildBaseRuntimeSnapshot();
            cachedRuntimeSnapshot = new CachedStationPathRuntimeSnapshot(now, baseRuntimeSnapshot);
            return baseRuntimeSnapshot;
        }
    }

    private BaseRuntimeSnapshot buildBaseRuntimeSnapshot() {
        Map<Integer, StationProtocol> statusMap = Collections.unmodifiableMap(new LinkedHashMap<>(loadStationStatusMap()));
        Map<Integer, Double> stationLoopLoadMap = Collections.unmodifiableMap(new LinkedHashMap<>(loadStationLoopLoadMap()));
        LoopMergeGuardContext loopMergeGuardContext = loadLoopMergeGuardContext();
        Set<Integer> outStationIdSet = Collections.unmodifiableSet(new LinkedHashSet<>(loadAllOutStationIdSet()));
        List<StationTaskTraceVo> activeTraceList = Collections.unmodifiableList(new ArrayList<>(loadPlanningActiveTraceList(statusMap)));
        return new BaseRuntimeSnapshot(statusMap, stationLoopLoadMap, loopMergeGuardContext, outStationIdSet, activeTraceList);
    }

    private Map<Integer, Double> loadStationLoopLoadMap() {
        Map<Integer, Double> stationLoopLoadMap = new HashMap<>();
        try {
@@ -1761,12 +1820,13 @@
            if (lev == null) {
                continue;
            }
            List<List<NavigateNode>> stationMap;
            NavigateSolution.NavigateMapIndex navigateMapIndex;
            try {
                stationMap = navigateSolution.getStationMap(lev);
                navigateMapIndex = navigateSolution.getStationMapIndex(lev);
            } catch (Exception ignore) {
                continue;
            }
            List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();
            if (stationMap == null || stationMap.isEmpty()) {
                continue;
            }
@@ -1778,16 +1838,13 @@
                        continue;
                    }
                    graph.computeIfAbsent(stationId, key -> new LinkedHashSet<>());
                    List<NavigateNode> nextNodeList = navigateSolution.extend_current_node(stationMap, node);
                    for (NavigateNode nextNode : safeList(nextNodeList)) {
                        for (Integer nextStationId : resolveConnectedStationIds(stationId, nextNode)) {
                            if (nextStationId == null || stationId.equals(nextStationId)) {
                                continue;
                            }
                            graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                            graph.get(stationId).add(nextStationId);
                            graph.get(nextStationId).add(stationId);
                    for (Integer nextStationId : navigateSolution.getConnectedStationIds(navigateMapIndex, stationId, node)) {
                        if (nextStationId == null || stationId.equals(nextStationId)) {
                            continue;
                        }
                        graph.computeIfAbsent(nextStationId, key -> new LinkedHashSet<>());
                        graph.get(stationId).add(nextStationId);
                        graph.get(nextStationId).add(stationId);
                    }
                }
            }
@@ -1797,27 +1854,17 @@

    private Set<Integer> resolveConnectedStationIds(Integer currentStationId, NavigateNode nextNode) {
        Set<Integer> stationIdSet = new LinkedHashSet<>();
        if (nextNode == null || nextNode.getNodeValue() == null) {
        if (nextNode == null) {
            return stationIdSet;
        }
        try {
            JSONObject value = JSON.parseObject(nextNode.getNodeValue());
            if (value == null) {
                return stationIdSet;
        Integer directStationId = extractStationId(nextNode);
        if (directStationId != null && !directStationId.equals(currentStationId)) {
            stationIdSet.add(directStationId);
        }
        for (Integer bridgeStationId : safeList(nextNode.getBridgeStationIds())) {
            if (bridgeStationId != null && !bridgeStationId.equals(currentStationId)) {
                stationIdSet.add(bridgeStationId);
            }
            Integer directStationId = value.getInteger("stationId");
            if (directStationId != null && !directStationId.equals(currentStationId)) {
                stationIdSet.add(directStationId);
            }
            JSONArray bridgeStationIds = value.getJSONArray("bridgeStationIds");
            if (bridgeStationIds != null) {
                for (Integer bridgeStationId : bridgeStationIds.toJavaList(Integer.class)) {
                    if (bridgeStationId != null && !bridgeStationId.equals(currentStationId)) {
                        stationIdSet.add(bridgeStationId);
                    }
                }
            }
        } catch (Exception ignore) {
        }
        return stationIdSet;
    }
@@ -1843,6 +1890,12 @@
    }

    private StationTrafficSnapshot loadStationTrafficSnapshot(Map<Integer, StationProtocol> statusMap, Integer currentTaskNo) {
        return buildStationTrafficSnapshot(statusMap, currentTaskNo, loadPlanningActiveTraceList(statusMap));
    }

    private StationTrafficSnapshot buildStationTrafficSnapshot(Map<Integer, StationProtocol> statusMap,
                                                              Integer currentTaskNo,
                                                              List<StationTaskTraceVo> activeTraceList) {
        StationTrafficSnapshot snapshot = new StationTrafficSnapshot();
        Map<Integer, Integer> busyMap = new HashMap<>();
        Map<Integer, Integer> issuedReserveMap = new HashMap<>();
@@ -1861,8 +1914,11 @@
            }
        }

        for (StationTaskTraceVo traceVo : loadActiveTraceList(currentTaskNo, statusMap)) {
        for (StationTaskTraceVo traceVo : safeList(activeTraceList)) {
            if (traceVo == null) {
                continue;
            }
            if (currentTaskNo != null && currentTaskNo.equals(traceVo.getTaskNo())) {
                continue;
            }
            List<Integer> pendingStationIds = distinctPositiveStationIds(traceVo.getPendingStationIds());
@@ -2037,7 +2093,7 @@
        return false;
    }

    private List<StationTaskTraceVo> loadActiveTraceList(Integer currentTaskNo, Map<Integer, StationProtocol> statusMap) {
    private List<StationTaskTraceVo> loadPlanningActiveTraceList(Map<Integer, StationProtocol> statusMap) {
        Map<Integer, StationTaskTraceVo> traceMap = new LinkedHashMap<>();
        if (stationTaskTraceRegistry != null) {
            try {
@@ -2045,9 +2101,6 @@
                if (traceList != null) {
                    for (StationTaskTraceVo traceVo : traceList) {
                        if (!isPlanningActiveTrace(traceVo)) {
                            continue;
                        }
                        if (currentTaskNo != null && currentTaskNo.equals(traceVo.getTaskNo())) {
                            continue;
                        }
                        if (traceVo.getTaskNo() != null) {
@@ -2058,7 +2111,7 @@
            } catch (Exception ignore) {
            }
        }
        Map<Integer, StationTaskTraceVo> fallbackTraceMap = loadFallbackActiveTraceMap(currentTaskNo, statusMap, traceMap.keySet());
        Map<Integer, StationTaskTraceVo> fallbackTraceMap = loadFallbackActiveTraceMap(null, statusMap, traceMap.keySet());
        if (!fallbackTraceMap.isEmpty()) {
            traceMap.putAll(fallbackTraceMap);
        }
@@ -2481,7 +2534,8 @@
    private StationPathSearchContext buildStationPathSearchContext(Integer startStationId,
                                                                   Integer endStationId,
                                                                   StationPathResolvedPolicy resolvedPolicy,
                                                                   StationPathCalcMode calcMode) {
                                                                   StationPathCalcMode calcMode,
                                                                   StationPathRuntimeSnapshot runtimeSnapshot) {
        long totalStartNs = System.nanoTime();
        Map<String, Long> stepCostMap = new LinkedHashMap<>();
        int rawCandidateCount = 0;
@@ -2497,14 +2551,15 @@

        stepStartNs = System.nanoTime();
        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);
        NavigateSolution.NavigateMapIndex navigateMapIndex = navigateSolution.getStationMapIndex(lev);
        List<List<NavigateNode>> stationMap = navigateMapIndex == null ? new ArrayList<>() : navigateMapIndex.getNavigateMap();

        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        NavigateNode startNode = navigateSolution.findStationNavigateNode(navigateMapIndex, startStationId);
        if (startNode == null) {
            throw new CoolException("未找到该 起点 对应的节点");
        }

        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(navigateMapIndex, endStationId);
        if (endNode == null) {
            throw new CoolException("未找到该 终点 对应的节点");
        }
@@ -2542,7 +2597,7 @@
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        stepStartNs = System.nanoTime();
        Map<Integer, StationProtocol> statusMap = loadStationStatusMap();
        Map<Integer, StationProtocol> statusMap = runtimeSnapshot == null ? Collections.emptyMap() : runtimeSnapshot.statusMap;
        allList = filterNonAutoStationPaths(allList, statusMap);
        stepCostMap.put("filterNonAutoStation", elapsedMillis(stepStartNs));
        filteredCandidateCount = allList.size();
@@ -2641,6 +2696,29 @@
                totalCostMs);
    }

    private void logDirectPathSlow(Integer startStationId,
                                   Integer endStationId,
                                   Integer currentTaskNo,
                                   StationPathCalcMode calcMode,
                                   Double pathLenFactor,
                                   int pathNodeCount,
                                   Map<String, Long> stepCostMap,
                                   long totalStartNs) {
        long totalCostMs = elapsedMillis(totalStartNs);
        if (totalCostMs < STATION_PATH_SLOW_LOG_THRESHOLD_MS) {
            return;
        }
        News.warn("站点路径快速计算耗时较长，startStationId={}，endStationId={}，taskNo={}，mode={}，pathLenFactor={}，pathNodeCount={}，stepCosts={}，totalCost={}ms",
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode == null ? "" : calcMode.name(),
                pathLenFactor,
                pathNodeCount,
                JSON.toJSONString(stepCostMap),
                totalCostMs);
    }

    private long elapsedMillis(long startNs) {
        long elapsedNs = System.nanoTime() - startNs;
        return elapsedNs <= 0L ? 0L : elapsedNs / 1_000_000L;
@@ -2670,16 +2748,10 @@
            if (navigateNode == null) {
                continue;
            }
            JSONObject valueObject;
            try {
                valueObject = JSON.parseObject(navigateNode.getNodeValue());
            } catch (Exception ignore) {
            if (Boolean.TRUE.equals(navigateNode.getRgvCalcFlag())) {
                continue;
            }
            if (valueObject == null || valueObject.containsKey("rgvCalcFlag")) {
                continue;
            }
            Integer stationId = valueObject.getInteger("stationId");
            Integer stationId = extractStationId(navigateNode);
            if (stationId == null) {
                continue;
            }
@@ -2699,19 +2771,8 @@
            NavigateNode currentNode = filterList.get(i);
            currentNode.setIsInflectionPoint(false);
            currentNode.setIsLiftTransferPoint(false);

            try {
                JSONObject valueObject = JSON.parseObject(currentNode.getNodeValue());
                if (valueObject != null) {
                    Object isLiftTransfer = valueObject.get("isLiftTransfer");
                    if (isLiftTransfer != null) {
                        String isLiftTransferStr = isLiftTransfer.toString();
                        if ("1".equals(isLiftTransferStr) || "true".equalsIgnoreCase(isLiftTransferStr)) {
                            currentNode.setIsLiftTransferPoint(true);
                        }
                    }
                }
            } catch (Exception ignore) {
            if (Boolean.TRUE.equals(currentNode.getLiftTransfer())) {
                currentNode.setIsLiftTransferPoint(true);
            }

            NavigateNode nextNode = (i + 1 < filterList.size()) ? filterList.get(i + 1) : null;
@@ -2744,6 +2805,14 @@
        return builder.toString();
    }

    private boolean parseBooleanFlag(Object value) {
        if (value == null) {
            return false;
        }
        String text = String.valueOf(value);
        return "1".equals(text) || "true".equalsIgnoreCase(text);
    }

    private <T> List<T> safeList(List<T> list) {
        return list == null ? Collections.emptyList() : list;
    }
@@ -2768,6 +2837,7 @@
        private Integer startStationId;
        private Integer endStationId;
        private NavigateSolution navigateSolution;
        private NavigateSolution.NavigateMapIndex navigateMapIndex;
        private List<List<NavigateNode>> stationMap;
        private NavigateNode startNode;
        private NavigateNode endNode;
@@ -2775,6 +2845,7 @@
        private StationPathRuleConfig ruleConfig;
        private StationPathProfileConfig profileConfig;
        private PathGlobalPolicy globalPolicy;
        private StationPathRuntimeSnapshot runtimeSnapshot = StationPathRuntimeSnapshot.empty();
        private Map<Integer, StationProtocol> statusMap = new HashMap<>();
        private Map<Integer, Double> stationLoopLoadMap = new HashMap<>();
        private StationTrafficSnapshot trafficSnapshot = new StationTrafficSnapshot();
@@ -2818,6 +2889,64 @@
        private static DirectPathSearchResult empty(boolean includeWaypoint,
                                                    boolean includeSoftPreference) {
            return new DirectPathSearchResult(new ArrayList<>(), includeWaypoint, includeSoftPreference);
        }
    }

    private static class StationPathRuntimeSnapshot {
        private final Map<Integer, StationProtocol> statusMap;
        private final Map<Integer, Double> stationLoopLoadMap;
        private final StationTrafficSnapshot trafficSnapshot;
        private final LoopMergeGuardContext loopMergeGuardContext;
        private final Set<Integer> outStationIdSet;

        private StationPathRuntimeSnapshot(Map<Integer, StationProtocol> statusMap,
                                           Map<Integer, Double> stationLoopLoadMap,
                                           StationTrafficSnapshot trafficSnapshot,
                                           LoopMergeGuardContext loopMergeGuardContext,
                                           Set<Integer> outStationIdSet) {
            this.statusMap = statusMap == null ? Collections.emptyMap() : statusMap;
            this.stationLoopLoadMap = stationLoopLoadMap == null ? Collections.emptyMap() : stationLoopLoadMap;
            this.trafficSnapshot = trafficSnapshot == null ? new StationTrafficSnapshot() : trafficSnapshot;
            this.loopMergeGuardContext = loopMergeGuardContext == null ? new LoopMergeGuardContext() : loopMergeGuardContext;
            this.outStationIdSet = outStationIdSet == null ? Collections.emptySet() : outStationIdSet;
        }

        private static StationPathRuntimeSnapshot empty() {
            return new StationPathRuntimeSnapshot(Collections.emptyMap(),
                    Collections.emptyMap(),
                    new StationTrafficSnapshot(),
                    new LoopMergeGuardContext(),
                    Collections.emptySet());
        }
    }

    private static class BaseRuntimeSnapshot {
        private final Map<Integer, StationProtocol> statusMap;
        private final Map<Integer, Double> stationLoopLoadMap;
        private final LoopMergeGuardContext loopMergeGuardContext;
        private final Set<Integer> outStationIdSet;
        private final List<StationTaskTraceVo> activeTraceList;

        private BaseRuntimeSnapshot(Map<Integer, StationProtocol> statusMap,
                                    Map<Integer, Double> stationLoopLoadMap,
                                    LoopMergeGuardContext loopMergeGuardContext,
                                    Set<Integer> outStationIdSet,
                                    List<StationTaskTraceVo> activeTraceList) {
            this.statusMap = statusMap == null ? Collections.emptyMap() : statusMap;
            this.stationLoopLoadMap = stationLoopLoadMap == null ? Collections.emptyMap() : stationLoopLoadMap;
            this.loopMergeGuardContext = loopMergeGuardContext == null ? new LoopMergeGuardContext() : loopMergeGuardContext;
            this.outStationIdSet = outStationIdSet == null ? Collections.emptySet() : outStationIdSet;
            this.activeTraceList = activeTraceList == null ? Collections.emptyList() : activeTraceList;
        }
    }

    private static class CachedStationPathRuntimeSnapshot {
        private final long cacheAtMs;
        private final BaseRuntimeSnapshot baseRuntimeSnapshot;

        private CachedStationPathRuntimeSnapshot(long cacheAtMs, BaseRuntimeSnapshot baseRuntimeSnapshot) {
            this.cacheAtMs = cacheAtMs;
            this.baseRuntimeSnapshot = baseRuntimeSnapshot;
        }
    }

@@ -2981,7 +3110,13 @@
    }

    private Integer extractStationId(NavigateNode node) {
        if (node == null || node.getNodeValue() == null) {
        if (node == null) {
            return null;
        }
        if (node.getStationId() != null) {
            return node.getStationId();
        }
        if (node.getNodeValue() == null) {
            return null;
        }
        try {
@@ -2989,7 +3124,16 @@
            if (value == null) {
                return null;
            }
            return value.getInteger("stationId");
            node.setStationId(value.getInteger("stationId"));
            JSONArray bridgeStationIds = value.getJSONArray("bridgeStationIds");
            if (bridgeStationIds != null) {
                node.setBridgeStationIds(bridgeStationIds.toJavaList(Integer.class));
            } else {
                node.setBridgeStationIds(Collections.emptyList());
            }
            node.setLiftTransfer(parseBooleanFlag(value.get("isLiftTransfer")));
            node.setRgvCalcFlag(value.containsKey("rgvCalcFlag"));
            return node.getStationId();
        } catch (Exception ignore) {}
        return null;
    }