#优化运行速度

Junjie

10 小时以前 45052042f06689096093fc86cae36560b2eeb1f0

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

@@ -7,8 +7,10 @@
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Set;

import com.zy.asrs.domain.path.StationPathCalcMode;
import com.zy.asrs.domain.path.StationPathProfileConfig;
import com.zy.asrs.domain.path.StationPathResolvedPolicy;
import com.zy.asrs.domain.path.StationPathRuleConfig;
@@ -73,42 +75,28 @@
    @Autowired
    private StationTaskTraceRegistry stationTaskTraceRegistry;

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId) {
        return calcByStationId(startStationId, endStationId, null, null, false);
    public List<NavigateNode> calcOptimalPathByStationId(Integer startStationId,
                                                         Integer endStationId,
                                                         Integer currentTaskNo,
                                                         Double pathLenFactor) {
        return calcPathByStationId(startStationId, endStationId, currentTaskNo, pathLenFactor, StationPathCalcMode.OPTIMAL);
    }

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId,
                                                           Integer endStationId,
                                                           Double pathLenFactor) {
        return calcByStationId(startStationId, endStationId, null, pathLenFactor, false);
    public List<NavigateNode> calcReachablePathByStationId(Integer startStationId, Integer endStationId) {
        return calcPathByStationId(startStationId, endStationId, null, null, StationPathCalcMode.REACHABILITY);
    }

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId, Integer currentTaskNo) {
        return calcByStationId(startStationId, endStationId, currentTaskNo, null, false);
    }

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId,
                                                           Integer endStationId,
                                                           Integer currentTaskNo,
                                                           Double pathLenFactor) {
        return calcByStationId(startStationId, endStationId, currentTaskNo, pathLenFactor, false);
    }

    public synchronized List<NavigateNode> calcReachablePathByStationId(Integer startStationId, Integer endStationId) {
        return calcByStationId(startStationId, endStationId, null, null, true);
    }

    public synchronized List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
                                                                              Integer endStationId,
                                                                              Integer currentTaskNo) {
        return calcCandidatePathByStationId(startStationId, endStationId, currentTaskNo, null);
    }

    public synchronized List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
                                                                              Integer endStationId,
                                                                              Integer currentTaskNo,
                                                                              Double pathLenFactor) {
        StationPathSearchContext context = buildStationPathSearchContext(startStationId, endStationId);
    public List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
                                                                 Integer endStationId,
                                                                 Integer currentTaskNo,
                                                                 Double pathLenFactor) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                StationPathCalcMode.REROUTE
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
        }
@@ -124,7 +112,7 @@
        return normalizeCandidatePaths(orderedPathList);
    }

    public synchronized Map<Integer, Set<Integer>> loadUndirectedStationGraphSnapshot() {
    public Map<Integer, Set<Integer>> loadUndirectedStationGraphSnapshot() {
        Map<Integer, Set<Integer>> graph = loadUndirectedStationGraph();
        Map<Integer, Set<Integer>> snapshot = new HashMap<>();
        for (Map.Entry<Integer, Set<Integer>> entry : graph.entrySet()) {
@@ -137,22 +125,42 @@
        return snapshot;
    }

    private synchronized List<NavigateNode> calcByStationId(Integer startStationId,
                                                            Integer endStationId,
                                                            Integer currentTaskNo,
                                                            Double pathLenFactor,
                                                            boolean reachabilityOnly) {
        StationPathSearchContext context = buildStationPathSearchContext(startStationId, endStationId);
    private List<NavigateNode> calcPathByStationId(Integer startStationId,
                                                   Integer endStationId,
                                                   Integer currentTaskNo,
                                                   Double pathLenFactor,
                                                   StationPathCalcMode calcMode) {
        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        if (calcMode != StationPathCalcMode.REROUTE) {
            List<NavigateNode> directPath = findStationDirectPath(
                    startStationId,
                    endStationId,
                    currentTaskNo,
                    pathLenFactor,
                    calcMode,
                    resolvedPolicy
            );
            if (!directPath.isEmpty()) {
                return normalizeStationPath(directPath);
            }
        }

        StationPathSearchContext context = buildStationPathSearchContext(
                startStationId,
                endStationId,
                resolvedPolicy,
                calcMode
        );
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
        }
        List<NavigateNode> list = reachabilityOnly
        List<NavigateNode> list = calcMode == StationPathCalcMode.REACHABILITY
                ? findStationReachablePath(context.allList, context.resolvedPolicy, startStationId, endStationId)
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
        return normalizeStationPath(list);
    }

    public synchronized List<NavigateNode> calcByTrackSiteNo(int lev, Integer startTrackSiteNo, Integer endTrackSiteNo) {
    public List<NavigateNode> calcByTrackSiteNo(int lev, Integer startTrackSiteNo, Integer endTrackSiteNo) {
        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> rgvTrackMap = navigateSolution.getRgvTrackMap(lev);

@@ -222,7 +230,7 @@
        return fitlerList;
    }

    public synchronized List<NavigateNode> findLiftStationList(int lev) {
    public List<NavigateNode> findLiftStationList(int lev) {
        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(lev);

@@ -261,6 +269,502 @@
            News.warn("站点路径策略加载失败，回退默认 twoStage: {}", e.getMessage());
        }
        return new StationPathResolvedPolicy();
    }

    private List<NavigateNode> findStationDirectPath(Integer startStationId,
                                                     Integer endStationId,
                                                     Integer currentTaskNo,
                                                     Double pathLenFactor,
                                                     StationPathCalcMode calcMode,
                                                     StationPathResolvedPolicy resolvedPolicy) {
        if (!supportsDirectPathMode(calcMode, resolvedPolicy, pathLenFactor)) {
            return new ArrayList<>();
        }

        DirectStationPathContext context = buildDirectStationPathContext(
                startStationId,
                endStationId,
                currentTaskNo,
                calcMode,
                resolvedPolicy
        );
        if (context == null) {
            return new ArrayList<>();
        }

        long startTime = System.currentTimeMillis();
        News.info("[WCS Debug] 站点路径快速计算开始,startStationId={},endStationId={},mode={}",
                startStationId,
                endStationId,
                calcMode.name());

        DirectPathSearchResult searchResult = searchDirectPathWithFallback(
                context,
                true,
                calcMode == StationPathCalcMode.OPTIMAL
        );
        if (searchResult.path.isEmpty() && hasWaypoint(context.ruleConfig) && !strictWaypoint(context.ruleConfig)) {
            searchResult = searchDirectPathWithFallback(
                    context,
                    false,
                    calcMode == StationPathCalcMode.OPTIMAL
            );
            if (!searchResult.path.isEmpty()) {
                News.info("[WCS Debug] 站点路径快速计算已降级，忽略关键途经点约束后重试");
            }
        }
        if (searchResult.path.isEmpty()) {
            return new ArrayList<>();
        }

        if (!isDirectPathValid(
                searchResult.path,
                context,
                searchResult.includeWaypoint,
                searchResult.includeSoftPreference)) {
            return new ArrayList<>();
        }

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

    private DirectPathSearchResult searchDirectPathWithFallback(DirectStationPathContext context,
                                                                boolean includeWaypoint,
                                                                boolean includeSoftPreference) {
        List<NavigateNode> path = searchDirectPath(context, includeWaypoint, includeSoftPreference);
        if (!path.isEmpty()) {
            return new DirectPathSearchResult(path, includeWaypoint, includeSoftPreference);
        }
        if (includeSoftPreference && hasSoftPreference(context.ruleConfig) && allowSoftDegrade(context.ruleConfig)) {
            List<NavigateNode> degradedPath = searchDirectPath(context, includeWaypoint, false);
            if (!degradedPath.isEmpty()) {
                News.info("[WCS Debug] 站点路径快速计算已降级，忽略软偏好约束后重试");
            }
            return new DirectPathSearchResult(degradedPath, includeWaypoint, false);
        }
        return DirectPathSearchResult.empty(includeWaypoint, includeSoftPreference);
    }

    private List<NavigateNode> searchDirectPath(DirectStationPathContext context,
                                                boolean includeWaypoint,
                                                boolean includeSoftPreference) {
        List<Integer> guideStationSequence = buildDirectGuideStationSequence(
                context.startStationId,
                context.endStationId,
                context.ruleConfig,
                includeWaypoint,
                includeSoftPreference
        );
        if (guideStationSequence.isEmpty()) {
            guideStationSequence = new ArrayList<>();
            guideStationSequence.add(context.startStationId);
            guideStationSequence.add(context.endStationId);
        }

        List<NavigateNode> result = new ArrayList<>();
        for (int i = 1; i < guideStationSequence.size(); i++) {
            Integer segmentStartStationId = guideStationSequence.get(i - 1);
            Integer segmentEndStationId = guideStationSequence.get(i);
            if (segmentStartStationId == null || segmentEndStationId == null) {
                return new ArrayList<>();
            }

            NavigateNode segmentStartNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentStartStationId);
            NavigateNode segmentEndNode = context.navigateSolution.findStationNavigateNode(context.stationMap, segmentEndStationId);
            if (segmentStartNode == null || segmentEndNode == null) {
                return new ArrayList<>();
            }

            List<NavigateNode> segmentPath = searchDirectPathSegment(
                    context,
                    segmentStartNode,
                    segmentEndNode,
                    includeSoftPreference
            );
            if (segmentPath.isEmpty()) {
                return new ArrayList<>();
            }
            mergeSegmentPath(result, segmentPath);
        }
        return result;
    }

    private List<NavigateNode> searchDirectPathSegment(DirectStationPathContext context,
                                                       NavigateNode startNode,
                                                       NavigateNode endNode,
                                                       boolean includeSoftPreference) {
        PriorityQueue<DirectPathState> openQueue = new PriorityQueue<>((left, right) -> {
            int compare = Double.compare(left.fScore, right.fScore);
            if (compare != 0) {
                return compare;
            }
            return Double.compare(left.gScore, right.gScore);
        });
        Map<String, Double> bestScoreMap = new HashMap<>();
        DirectPathState startState = new DirectPathState(startNode, null, 0.0d, calcHeuristicScore(startNode, endNode));
        openQueue.offer(startState);
        bestScoreMap.put(buildDirectStateKey(startState), 0.0d);

        while (!openQueue.isEmpty()) {
            DirectPathState currentState = openQueue.poll();
            if (sameCoordinate(currentState.node, endNode)) {
                return buildDirectPath(currentState);
            }

            List<NavigateNode> nextNodeList = context.navigateSolution.extend_current_node(context.stationMap, currentState.node);
            for (NavigateNode nextNode : safeList(nextNodeList)) {
                if (!isDirectTransitionAllowed(context, currentState.node, nextNode, endNode)) {
                    continue;
                }

                double stepCost = calcDirectStepCost(
                        context,
                        currentState.parent == null ? null : currentState.parent.node,
                        currentState.node,
                        nextNode,
                        endNode,
                        includeSoftPreference
                );
                double nextGScore = currentState.gScore + stepCost;
                DirectPathState nextState = new DirectPathState(
                        nextNode,
                        currentState,
                        nextGScore,
                        nextGScore + calcHeuristicScore(nextNode, endNode)
                );
                String stateKey = buildDirectStateKey(nextState);
                Double recordedScore = bestScoreMap.get(stateKey);
                if (recordedScore != null && recordedScore <= nextGScore) {
                    continue;
                }
                bestScoreMap.put(stateKey, nextGScore);
                openQueue.offer(nextState);
            }
        }
        return new ArrayList<>();
    }

    private boolean isDirectTransitionAllowed(DirectStationPathContext context,
                                              NavigateNode currentNode,
                                              NavigateNode nextNode,
                                              NavigateNode endNode) {
        if (nextNode == null) {
            return false;
        }
        Integer nextStationId = extractStationId(nextNode);
        Integer currentStationId = extractStationId(currentNode);
        Integer endStationId = extractStationId(endNode);

        if (nextStationId != null && !nextStationId.equals(endStationId)) {
            if (context.forbidStationIdSet.contains(nextStationId)) {
                return false;
            }
            StationProtocol protocol = context.statusMap.get(nextStationId);
            if (protocol != null && !protocol.isAutoing()) {
                return false;
            }
            if (context.globalPolicy.forceSkipPassOtherOutStation
                    && context.outStationIdSet.contains(nextStationId)
                    && !nextStationId.equals(context.startStationId)
                    && !nextStationId.equals(context.endStationId)) {
                return false;
            }
        }

        if (currentStationId != null && nextStationId != null) {
            String edgeKey = currentStationId + "->" + nextStationId;
            if (context.forbidEdgeSet.contains(edgeKey)) {
                return false;
            }
        }
        return true;
    }

    private double calcDirectStepCost(DirectStationPathContext context,
                                      NavigateNode prevNode,
                                      NavigateNode currentNode,
                                      NavigateNode nextNode,
                                      NavigateNode endNode,
                                      boolean includeSoftPreference) {
        double stepCost = safeDouble(context.profileConfig.getS1LenWeight(), 1.0d) * context.globalPolicy.lenWeightFactor;
        stepCost += safeDouble(context.profileConfig.getS1TurnWeight(), 3.0d)
                * calcDirectTurnPenalty(prevNode, currentNode, nextNode, endNode);
        stepCost += safeDouble(context.profileConfig.getS1LiftWeight(), 8.0d) * calcLiftTransferPenalty(nextNode);

        if (context.calcMode == StationPathCalcMode.REACHABILITY) {
            return Math.max(stepCost, 1.0d);
        }

        Integer stationId = extractStationId(nextNode);
        if (stationId != null) {
            double congWeightFactor = context.globalPolicy.congWeightFactor;
            stepCost += safeDouble(context.profileConfig.getS2BusyWeight(), 2.0d)
                    * congWeightFactor
                    * context.trafficSnapshot.congestionScoreMap.getOrDefault(stationId, 0.0d);
            stepCost += safeDouble(context.profileConfig.getS2QueueWeight(), 2.5d)
                    * context.trafficSnapshot.queueDepthMap.getOrDefault(stationId, 0);
            stepCost += safeDouble(context.profileConfig.getS2WaitWeight(), 1.5d)
                    * (context.trafficSnapshot.estimatedWaitSecondsMap.getOrDefault(stationId, 0.0d) / 60.0d);
            StationProtocol protocol = context.statusMap.get(stationId);
            if (protocol != null && protocol.isRunBlock()) {
                stepCost += safeDouble(context.profileConfig.getS2RunBlockWeight(), 10.0d);
            }
            stepCost += safeDouble(context.profileConfig.getS2LoopLoadWeight(), 12.0d)
                    * context.stationLoopLoadMap.getOrDefault(stationId, 0.0d);
            if (context.outStationIdSet.contains(stationId)
                    && !stationId.equals(context.startStationId)
                    && !stationId.equals(context.endStationId)) {
                stepCost += context.globalPolicy.passOtherOutStationPenaltyWeight;
            }

            if (includeSoftPreference && context.softReferenceStationSet.contains(stationId)) {
                stepCost -= 0.25d;
            } else if (includeSoftPreference
                    && stationId != null
                    && !stationId.equals(context.startStationId)
                    && !stationId.equals(context.endStationId)
                    && !context.softReferenceStationSet.isEmpty()) {
                double softDeviationWeight = safeDouble(context.profileConfig.getS1SoftDeviationWeight(), 4.0d);
                if (context.ruleConfig.getSoft() != null && context.ruleConfig.getSoft().getDeviationWeight() != null) {
                    softDeviationWeight = context.ruleConfig.getSoft().getDeviationWeight();
                }
                stepCost += softDeviationWeight;
            }
        }

        return Math.max(stepCost, 1.0d);
    }

    private int calcDirectTurnPenalty(NavigateNode prevNode,
                                      NavigateNode currentNode,
                                      NavigateNode nextNode,
                                      NavigateNode endNode) {
        if (prevNode == null || currentNode == null || nextNode == null) {
            return 0;
        }
        if (nextNode.getX() == prevNode.getX() || nextNode.getY() == prevNode.getY()) {
            return 0;
        }
        return (endNode != null && (nextNode.getX() == endNode.getX() || nextNode.getY() == endNode.getY())) ? 1 : 1;
    }

    private int calcLiftTransferPenalty(NavigateNode node) {
        if (node == null || node.getNodeValue() == 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;
        }
    }

    private double calcHeuristicScore(NavigateNode currentNode, NavigateNode endNode) {
        if (currentNode == null || endNode == null) {
            return 0.0d;
        }
        return Math.abs(endNode.getX() - currentNode.getX()) + Math.abs(endNode.getY() - currentNode.getY());
    }

    private boolean sameCoordinate(NavigateNode left, NavigateNode right) {
        return left != null
                && right != null
                && left.getX() == right.getX()
                && left.getY() == right.getY();
    }

    private String buildDirectStateKey(DirectPathState state) {
        if (state == null || state.node == null) {
            return "";
        }
        String currentKey = state.node.getX() + "_" + state.node.getY();
        if (state.parent == null || state.parent.node == null) {
            return currentKey + "|S";
        }
        return currentKey + "|" + state.parent.node.getX() + "_" + state.parent.node.getY();
    }

    private List<NavigateNode> buildDirectPath(DirectPathState endState) {
        List<NavigateNode> path = new ArrayList<>();
        DirectPathState cursor = endState;
        while (cursor != null) {
            NavigateNode clonedNode = cursor.node == null ? null : cursor.node.clone();
            if (clonedNode != null) {
                path.add(clonedNode);
            }
            cursor = cursor.parent;
        }
        Collections.reverse(path);
        return path;
    }

    private void mergeSegmentPath(List<NavigateNode> target, List<NavigateNode> segmentPath) {
        if (target == null || segmentPath == null || segmentPath.isEmpty()) {
            return;
        }
        if (target.isEmpty()) {
            target.addAll(segmentPath);
            return;
        }
        for (int i = 0; i < segmentPath.size(); i++) {
            if (i == 0 && sameCoordinate(target.get(target.size() - 1), segmentPath.get(i))) {
                continue;
            }
            target.add(segmentPath.get(i));
        }
    }

    private List<Integer> buildDirectGuideStationSequence(Integer startStationId,
                                                          Integer endStationId,
                                                          StationPathRuleConfig ruleConfig,
                                                          boolean includeWaypoint,
                                                          boolean includeSoftPreference) {
        List<Integer> sequence = new ArrayList<>();
        appendGuideStation(sequence, startStationId);
        if (ruleConfig == null) {
            appendGuideStation(sequence, endStationId);
            return sequence;
        }

        if (includeSoftPreference) {
            List<Integer> preferredPath = safeList(ruleConfig.getSoft() == null ? null : ruleConfig.getSoft().getPreferredPath());
            if (!preferredPath.isEmpty() && startStationId.equals(preferredPath.get(0))) {
                for (int i = 1; i < preferredPath.size(); i++) {
                    appendGuideStation(sequence, preferredPath.get(i));
                }
                if (sequence.get(sequence.size() - 1).equals(endStationId)) {
                    return sequence;
                }
                sequence.clear();
                appendGuideStation(sequence, startStationId);
            }
        }

        if (includeWaypoint) {
            for (Integer stationId : safeList(ruleConfig.getWaypoint() == null ? null : ruleConfig.getWaypoint().getStations())) {
                appendGuideStation(sequence, stationId);
            }
        }
        if (includeSoftPreference) {
            for (Integer stationId : safeList(ruleConfig.getSoft() == null ? null : ruleConfig.getSoft().getKeyStations())) {
                appendGuideStation(sequence, stationId);
            }
        }
        appendGuideStation(sequence, endStationId);
        return sequence;
    }

    private boolean isDirectPathValid(List<NavigateNode> path,
                                      DirectStationPathContext context,
                                      boolean includeWaypoint,
                                      boolean includeSoftPreference) {
        if (path == null || path.isEmpty()) {
            return false;
        }
        List<Integer> stationIdList = extractStationIdList(path);
        if (!matchHardConstraint(stationIdList, context.ruleConfig.getHard())) {
            return false;
        }
        if (includeWaypoint && !matchWaypointConstraint(stationIdList, context.ruleConfig.getWaypoint())) {
            return false;
        }
        if (includeSoftPreference && !matchSoftConstraint(stationIdList, context.ruleConfig.getSoft())) {
            return false;
        }
        if (!isLoopMergePathAllowed(
                path,
                context.statusMap,
                context.trafficSnapshot,
                context.loopMergeGuardContext,
                Collections.emptySet())) {
            return false;
        }

        if (context.globalPolicy.forceSkipPassOtherOutStation
                && countPassOtherOutStations(path, context.outStationIdSet) > 0) {
            return false;
        }
        return true;
    }

    private boolean supportsDirectPathMode(StationPathCalcMode calcMode,
                                           StationPathResolvedPolicy resolvedPolicy,
                                           Double pathLenFactor) {
        if (calcMode == null || calcMode == StationPathCalcMode.REROUTE) {
            return false;
        }
        if (calcMode == StationPathCalcMode.OPTIMAL && normalizePathLenFactor(pathLenFactor) > 0.0d) {
            return false;
        }
        StationPathRuleConfig ruleConfig = resolvedPolicy == null || resolvedPolicy.getRuleConfig() == null
                ? new StationPathRuleConfig()
                : resolvedPolicy.getRuleConfig();
        return safeList(ruleConfig.getHard() == null ? null : ruleConfig.getHard().getMustPassStations()).isEmpty()
                && safeList(ruleConfig.getHard() == null ? null : ruleConfig.getHard().getMustPassEdges()).isEmpty();
    }

    private DirectStationPathContext buildDirectStationPathContext(Integer startStationId,
                                                                   Integer endStationId,
                                                                   Integer currentTaskNo,
                                                                   StationPathCalcMode calcMode,
                                                                   StationPathResolvedPolicy resolvedPolicy) {
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 起点 对应的站点数据");
        }

        NavigateSolution navigateSolution = new NavigateSolution();
        List<List<NavigateNode>> stationMap = navigateSolution.getStationMap(startStation.getStationLev());
        NavigateNode startNode = navigateSolution.findStationNavigateNode(stationMap, startStationId);
        NavigateNode endNode = navigateSolution.findStationNavigateNode(stationMap, endStationId);
        if (startNode == null || endNode == null) {
            throw new CoolException("未找到该 起点 或 终点 对应的节点");
        }

        DirectStationPathContext context = new DirectStationPathContext();
        context.calcMode = calcMode;
        context.startStationId = startStationId;
        context.endStationId = endStationId;
        context.navigateSolution = navigateSolution;
        context.stationMap = stationMap;
        context.startNode = startNode;
        context.endNode = endNode;
        context.resolvedPolicy = resolvedPolicy == null ? new StationPathResolvedPolicy() : resolvedPolicy;
        context.ruleConfig = context.resolvedPolicy.getRuleConfig() == null
                ? new StationPathRuleConfig()
                : context.resolvedPolicy.getRuleConfig();
        context.profileConfig = context.resolvedPolicy.getProfileConfig() == null
                ? 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.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())) {
            if (notBlank(edgeText)) {
                context.forbidEdgeSet.add(edgeText.replace(" ", ""));
            }
        }
        context.softReferenceStationSet = new HashSet<>(getSoftReferencePath(context.ruleConfig.getSoft()));
        return context;
    }

    private List<NavigateNode> findStationReachablePath(List<List<NavigateNode>> allList,
@@ -1923,7 +2427,10 @@
        return text != null && !text.trim().isEmpty();
    }

    private StationPathSearchContext buildStationPathSearchContext(Integer startStationId, Integer endStationId) {
    private StationPathSearchContext buildStationPathSearchContext(Integer startStationId,
                                                                   Integer endStationId,
                                                                   StationPathResolvedPolicy resolvedPolicy,
                                                                   StationPathCalcMode calcMode) {
        BasStation startStation = basStationService.getById(startStationId);
        if (startStation == null) {
            throw new CoolException("未找到该 起点 对应的站点数据");
@@ -1943,13 +2450,15 @@
            throw new CoolException("未找到该 终点 对应的节点");
        }

        StationPathResolvedPolicy resolvedPolicy = resolveStationPathPolicy(startStationId, endStationId);
        StationPathProfileConfig profileConfig = resolvedPolicy.getProfileConfig() == null
                ? StationPathProfileConfig.defaultConfig()
                : resolvedPolicy.getProfileConfig();

        long startTime = System.currentTimeMillis();
        News.info("[WCS Debug] 站点路径开始计算,startStationId={},endStationId={}", startStationId, endStationId);
        News.info("[WCS Debug] 站点路径开始计算,startStationId={},endStationId={},mode={}",
                startStationId,
                endStationId,
                calcMode == null ? "" : calcMode.name());
        int calcMaxDepth = safeInt(profileConfig.getCalcMaxDepth(), 120);
        int calcMaxPaths = safeInt(profileConfig.getCalcMaxPaths(), 500);
        int calcMaxCost = safeInt(profileConfig.getCalcMaxCost(), 300);
@@ -1972,7 +2481,11 @@
            News.info("[WCS Debug] 站点路径候选全部被过滤，存在非自动站点,startStationId={},endStationId={}", startStationId, endStationId);
            return StationPathSearchContext.empty(resolvedPolicy);
        }
        News.info("[WCS Debug] 站点路径计算完成，耗时：{}ms", System.currentTimeMillis() - startTime);
        News.info("[WCS Debug] 站点路径计算完成，耗时：{}ms,startStationId={},endStationId={},mode={}",
                System.currentTimeMillis() - startTime,
                startStationId,
                endStationId,
                calcMode == null ? "" : calcMode.name());
        return new StationPathSearchContext(allList, resolvedPolicy);
    }

@@ -1994,8 +2507,8 @@
    }

    private List<NavigateNode> normalizeStationPath(List<NavigateNode> path) {
        HashSet<Integer> stationIdSet = new HashSet<>();
        List<NavigateNode> filterList = new ArrayList<>();
        Integer lastStationId = null;
        for (NavigateNode navigateNode : safeList(path)) {
            if (navigateNode == null) {
                continue;
@@ -2010,9 +2523,14 @@
                continue;
            }
            Integer stationId = valueObject.getInteger("stationId");
            if (stationId == null || !stationIdSet.add(stationId)) {
            if (stationId == null) {
                continue;
            }
            // 仅压缩连续重复站点，保留环线重算场景下后续再次经过的同一站点。
            if (lastStationId != null && lastStationId.equals(stationId)) {
                continue;
            }
            lastStationId = stationId;
            NavigateNode clonedNode = navigateNode.clone();
            if (clonedNode == null) {
                continue;
@@ -2088,6 +2606,64 @@
        }
    }

    private static class DirectStationPathContext {
        private StationPathCalcMode calcMode;
        private Integer startStationId;
        private Integer endStationId;
        private NavigateSolution navigateSolution;
        private List<List<NavigateNode>> stationMap;
        private NavigateNode startNode;
        private NavigateNode endNode;
        private StationPathResolvedPolicy resolvedPolicy;
        private StationPathRuleConfig ruleConfig;
        private StationPathProfileConfig profileConfig;
        private PathGlobalPolicy globalPolicy;
        private Map<Integer, StationProtocol> statusMap = new HashMap<>();
        private Map<Integer, Double> stationLoopLoadMap = new HashMap<>();
        private StationTrafficSnapshot trafficSnapshot = new StationTrafficSnapshot();
        private LoopMergeGuardContext loopMergeGuardContext = new LoopMergeGuardContext();
        private Set<Integer> outStationIdSet = new HashSet<>();
        private Set<Integer> forbidStationIdSet = new HashSet<>();
        private Set<String> forbidEdgeSet = new HashSet<>();
        private Set<Integer> softReferenceStationSet = new HashSet<>();
    }

    private static class DirectPathState {
        private final NavigateNode node;
        private final DirectPathState parent;
        private final double gScore;
        private final double fScore;

        private DirectPathState(NavigateNode node,
                                DirectPathState parent,
                                double gScore,
                                double fScore) {
            this.node = node;
            this.parent = parent;
            this.gScore = gScore;
            this.fScore = fScore;
        }
    }

    private static class DirectPathSearchResult {
        private final List<NavigateNode> path;
        private final boolean includeWaypoint;
        private final boolean includeSoftPreference;

        private DirectPathSearchResult(List<NavigateNode> path,
                                       boolean includeWaypoint,
                                       boolean includeSoftPreference) {
            this.path = path == null ? new ArrayList<>() : path;
            this.includeWaypoint = includeWaypoint;
            this.includeSoftPreference = includeSoftPreference;
        }

        private static DirectPathSearchResult empty(boolean includeWaypoint,
                                                    boolean includeSoftPreference) {
            return new DirectPathSearchResult(new ArrayList<>(), includeWaypoint, includeSoftPreference);
        }
    }

    private static class PathCandidateMetrics {
        private List<NavigateNode> path;
        private int pathLen;