#

luxiaotao1123

2024-10-25 beb476733eaff1f3a76ec1be772337655803cccb

#

 zy-acs-manager/src/main/java/com/zy/acs/manager/core/DispatcherTestController.java

@@ -38,13 +38,13 @@
        Map<String, List<String>> adjacencyCodeMap = new HashMap<>();
        for (Code code : codeList) {
            List<Long> adjacencyNode = routeService.getAdjacencyNode(code.getId());
            adjacencyCodeMap.put(code.getData(), adjacencyNode.stream().map(node -> {
                return codeService.getById(node).getData();
            }).collect(Collectors.toList()));
            adjacencyCodeMap.put(code.getData(), adjacencyNode.stream().map(node -> (
                    codeService.getById(node).getData()
            )).collect(Collectors.toList()));
        }
        List<String> codeDataList = codeList.stream().map(Code::getData).collect(Collectors.toList());
        System.out.println(codeDataList.toString());
        System.out.println(adjacencyCodeMap.toString());
//        System.out.println(codeDataList.toString());
//        System.out.println(adjacencyCodeMap.toString());


        Set<String> visited = new HashSet<>();
@@ -74,6 +74,76 @@
            }
        }

        /**
         * 1.explore a dead end lane and checkout end point that is not dead point
         * 2.if this point has two near points and one of those points which not in current lane was also have two near points too
         * 3.then merge above two lane because they can connect each other
         */
        Iterator<Lane> iterator = lanes.iterator();
        while (iterator.hasNext()) {
            Lane lane = iterator.next();
            String[] endPoints = lane.queryEndPoints();
            if (null == endPoints) {
                continue;
            }
            String startPoint = endPoints[0];
            String endPoint = endPoints[1];

            boolean isDeadEndLane = false;
            String deadEndPoint = null;
            Integer anotherPointNearsCount = null;
            if (adjacencyCodeMap.get(startPoint).size() == 1) {
                isDeadEndLane = true;
                deadEndPoint = startPoint;
                anotherPointNearsCount = adjacencyCodeMap.get(endPoint).size();
            }
            if (adjacencyCodeMap.get(endPoint).size() == 1) {
                isDeadEndLane = true;
                deadEndPoint = endPoint;
                anotherPointNearsCount = adjacencyCodeMap.get(startPoint).size();
            }

            if (!isDeadEndLane) {
                continue;
            }

            if (anotherPointNearsCount == 2) {
                String anotherPoint = deadEndPoint.equals(startPoint) ? endPoint : startPoint;
                List<String> anotherPointNears = adjacencyCodeMap.get(anotherPoint);
                for (String anotherPointNear : anotherPointNears) {
                    if (!lane.getCodes().contains(anotherPointNear) && adjacencyCodeMap.get(anotherPointNear).size() == 2) {

                        for (Lane lane0 : lanes) {
                            if (lane0.getCodes().contains(anotherPointNear)) {

                                lane0.getCodes().addAll(lane.getCodes());
                                iterator.remove();


                                Collections.shuffle(lane0.getCodes());
                                System.out.println(lane0.getCodes().toString());
                                for (String code : lane0.getCodes()) {
                                    System.out.println("key: " + code + "; val" + adjacencyCodeMap.get(code).toString());
                                }
                                lane0.sortUsingDfs(adjacencyCodeMap);
                                System.out.println(lane0.getCodes().toString());


                            }

                        }

                    }
                }
            }

        }

        for (Lane lane : lanes) {
            lane.removeInteraction(adjacencyCodeMap);
        }

        lanes.removeIf(next -> next.getCodes().size() <= 2);

        System.out.println(GsonUtils.toJson(lanes));
        return R.ok().add(lanes);

 zy-acs-manager/src/main/java/com/zy/acs/manager/core/domain/Lane.java

@@ -1,9 +1,9 @@
package com.zy.acs.manager.core.domain;

import com.zy.acs.framework.common.Cools;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;
import java.util.*;

/**
 * Created by vincent on 10/24/2024
@@ -22,4 +22,76 @@
        this.laneId = laneId;
    }

    public String[] queryEndPoints() {
        if (Cools.isEmpty(this.codes)) {
            return null;
        }
        String[] endPoints = new String[2];
        if (this.codes.size() == 1) {
            endPoints[0] = this.codes.get(0);
            endPoints[1] = this.codes.get(0);
        } else {
            endPoints[0] = this.codes.get(0);
            endPoints[1] = this.codes.get(this.codes.size() - 1);
        }
        return endPoints;
    }

    public void sortUsingDfs(Map<String, List<String>> adjacencyCodeMap) {
        if (Cools.isEmpty(this.codes) || this.codes.size() < 2) {
            return;
        }
        Set<String> visited = new HashSet<>();
        List<String> result = new ArrayList<>();

        String startNode = findStartNode(adjacencyCodeMap);
        dfs(startNode, adjacencyCodeMap, visited, result);

        for (String code : this.codes) {
            if (!visited.contains(code)) {
                dfs(code, adjacencyCodeMap, visited, result);
            }
        }

        this.codes = result;
    }

    private String findStartNode(Map<String, List<String>> adjacencyCodeMap) {
        for (String code : this.codes) {
            List<String> neighbors = adjacencyCodeMap.get(code);
            if (!Cools.isEmpty(neighbors)) {
                int count = 0;
                for (String neighbor : neighbors) {
                    if (this.codes.contains(neighbor)) {
                        count++;
                    }
                }
                if (count == 1) {
                    return code;
                }
            }
        }
        return null;
    }

    private static void dfs(String node, Map<String, List<String>> adjacencyCodeMap, Set<String> visited, List<String> result) {
        visited.add(node);
        result.add(node);

        if (adjacencyCodeMap.containsKey(node)) {
            for (String neighbor : adjacencyCodeMap.get(node)) {
                if (!visited.contains(neighbor)) {
                    dfs(neighbor, adjacencyCodeMap, visited, result);
                }
            }
        }
    }

    public void removeInteraction(Map<String, List<String>> adjacencyCodeMap) {
        if (Cools.isEmpty(this.codes)) {
            return;
        }
        this.codes.removeIf(code -> adjacencyCodeMap.get(code).size() > 2);
    }

}