java小车自动寻路避障avg调度模拟

uml图

Graph.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author ：
 * @description：TODO
 * @date ：2023/3/4 1:53
 */
public class Graph {
    public int v; // 顶点数目
    public int e; // 边的数目

    static public List<List<Path>> pathArrayList = new ArrayList<>();
    static public List<Node> nodes = new ArrayList<>();

    static public int [][]matrix;


    Graph(List<Node> nodeList, List<Path> pathList){
        for (Node node : nodeList) {
            nodes.add(node);
            pathArrayList.add(new ArrayList<Path>());
        }
        for(Path p: pathList){
            pathArrayList.get(p.node1.index).add(p);
        }
    }
    Graph(Node[] vertices, Node[][] edges){
        for (Node node : vertices) {
            nodes.add(node);
            pathArrayList.add(new ArrayList<Path>());
        }
        for (int i = 0; i < edges.length; i++) {
            Node node1 = edges[i][0];
            Node node2 = edges[i][1];
            pathArrayList.get(node1.index).add(new Path(node1, node2));
            pathArrayList.get(node2.index).add(new Path(node2, node1));
        }
        matrix = new int[nodes.size()][nodes.size()];
        for (int i = 0; i < nodes.size(); i++) {
            for(Path p:pathArrayList.get(i)){
                matrix[i][p.node2.index] = p.distance;
            }
            for (int j = 0; j < nodes.size(); j++) {
                if(matrix[i][j] == 0){
                    matrix[i][j] = Integer.MAX_VALUE / 2;
                }
            }
            matrix[i][i] = 0;
        }
    }

    public List getVertices() {
        return nodes;
    }

    public int getSize() {
        return nodes.size();
    }
    public static int getTime(Node a, Node b){
        for(Path p:pathArrayList.get(a.index)){
            if(p.node2.index == b.index){
                return p.distance;
            }
        }
        return 0;
    }

    public static int addTime(Node a, Node b, Integer timeIn, String carName){
        for(Path p:pathArrayList.get(a.index)){
            if(p.node2.index == b.index){
                p.timeWindow.timeIn.add(timeIn);
                p.timeWindow.timeOut.add(timeIn + getTime(a, b));
                p.timeWindow.carName.add(carName);
            }
        }
        return 0;
    }

    public static boolean empty(Node a, Node b){
        for(Path p:pathArrayList.get(a.index)){
            if(p.node2.index == b.index){
                return p.timeWindow.empty;
            }
        }
        return false;
    }

    public static void changeEmpty(Node a, Node b){
        for(Path p:pathArrayList.get(a.index)){
            if(p.node2.index == b.index){
                if(p.timeWindow.empty){
                    p.timeWindow.empty = false;}else{
                    p.timeWindow.empty = true;
                }
            }
        }
    }

    public List<Node> getNeighbors(int i) {
        List<Node> result = new ArrayList<>();
        for(Path p: pathArrayList.get(i)){
            result.add(p.node2);
        }
        return result;
    }

    public void printEdges(){
        for (int i = 0; i < pathArrayList.size(); i++) {
            System.out.println(nodes.get(i).getString() +": ");
            for (Path p: pathArrayList.get(i)) {
                System.out.println(p.node1.getString() + "---" + p.node2.getString());
            }
            System.out.println();
        }
    }

    public static Node getNode(int x, int y){
        for (int i = 0; i < nodes.size(); i++) {
            Node node = nodes.get(i);
            if(node.x == x && node.y == y){
                return node;
            }
        }
        return null;
    }

    public List<Node> dijkstra(Node v0, Node vi) {
        List<Node> paths = new ArrayList<>();
        // 从顶点vO出发,查找到vi的最短路径
        int n = nodes.size();
        // listU 记录还未处理的节点
        ArrayList<Integer> listU = new ArrayList<>();
        // dist[] 记录各个节点到起始节点的最短权值
        int[] dist = new int[n];
        // 记录各个节点的上一级节点(用来联系该节点到起始节点的路径)
        int[] path = new int[n];

        int start = v0.index; // 源点序号
        int end = vi.index; // 结束顶点序号

        // 初始化U集合
        for (int i = 0; i < n; i++) {
            if (i == start) { // S={start}
                continue;
            }
            listU.add(i); // u={vi}/{start}
        }
        // 初始化dist[],path[]
        for (int i = 0; i < n; i++) {
            // dist[]的当前节点权值就等于start->i节点的权值;初始化所有节点到源点的最短距离
            dist[i] = this.matrix[start][i];
            if (this.matrix[start][i] == Integer.MAX_VALUE) {
                path[i] = -1; // 节点i不可达
            } else {
                path[i] = start; // 若start能直达某点,则表示节点i可以直接访问到start;
            }
        }

        // 记录最小值的节点序号
        int minIndex;
        do {

            // dist数组下标
            minIndex = listU.get(0);
            for (int i = 1; i < listU.size(); i++) {
                if (dist[listU.get(i)] < dist[minIndex]) {
                    minIndex = listU.get(i);

                }
            }
            listU.remove((Integer) minIndex);

            // 更新dist和path数组,主要考察minIndex节点纳入S,即新加入节点最短路径变化.
            for (int i = 0; i < n; i++) {
                if (this.matrix[minIndex][i] != 0 && this.matrix[minIndex][i] < Integer.MAX_VALUE) {
                    // 找到minIndex的所有邻接点
                    if (this.matrix[minIndex][i] + dist[minIndex] < dist[i]) {
                        // 新加入节点更短
                        dist[i] = this.matrix[minIndex][i] + dist[minIndex];
                        path[i] = minIndex;
                    }
                }
            }
        } while (minIndex != end && !listU.isEmpty());

        System.out.println("起始点" + v0.getString() + "到目标点" + vi.getString() +"耗时: "+ dist[end] + ", 全局最短路径为: " );
        String str = "" + vi.getString();
        paths.add(vi);
        int i = end;
        do {
            i = path[i];
            paths.add(nodes.get(i));
            str = nodes.get(i).getString() + "=>" + str;
        } while (i != start);
        System.out.println(str);
        Collections.reverse(paths);
        return paths;
    }


}