飞算JavaAI：从写不出代码到丝滑开发，飞算JavaAI把小白从编程深渊捞进了正轨---它都让我怀疑自己是不是多余的！

帮我生成个迪杰斯特拉算法的main文件

public class Main {
    public static void main(String[] args) {
        // Create a graph given in the above diagram
        Graph g = new Graph(9);
        g.addEdge(0, 1, 4);
        g.addEdge(0, 7, 8);
        g.addEdge(1, 2, 8);
        g.addEdge(1, 7, 11);
        g.addEdge(2, 3, 7);
        g.addEdge(2, 5, 4);
        g.addEdge(2, 8, 2);
        g.addEdge(3, 4, 9);
        g.addEdge(3, 5, 14);
        g.addEdge(4, 5, 10);
        g.addEdge(5, 6, 2);
        g.addEdge(6, 7, 1);
        g.addEdge(6, 8, 6);
        g.addEdge(7, 8, 7);

        g.dijkstra(0); // Print the solution
    }
}

public class Graph {
    private int V; // Number of vertices in the graph
    private int[][] graph; // Adjacency matrix

    public Graph(int v) {
        V = v;
        graph = new int[V][V];
    }

    // A utility function to find the vertex with the minimum distance value,
    // from the set of vertices not yet included in shortest path tree
    private int minDistance(int dist[], Boolean sptSet[]) {
        int min = Integer.MAX_VALUE, minIndex = -1;

        for (int v = 0; v < V; v++)
            if (sptSet[v] == false && dist[v] <= min) {
                min = dist[v];
                minIndex = v;
            }

        return minIndex;
    }

    // A utility function to print the constructed distance array
    public void printSolution(int dist[]) {
        System.out.println("Vertex \t\t Distance from Source");
        for (int i = 0; i < V; i++)
            System.out.println(i + " \t\t " + dist[i]);
    }

    // Function that implements Dijkstra's single source shortest path algorithm
    // for a graph represented using adjacency matrix representation
    public void dijkstra(int src) {
        int dist[] = new int[V]; // The output array. dist[i] will hold
                                 // the shortest distance from src to i

        // sptSet[i] will true if vertex i is included in shortest
        // path tree or shortest distance from src to i is finalized
        Boolean sptSet[] = new Boolean[V];

        // Initialize all distances as INFINITE and stpSet[] as false
        for (int i = 0; i < V; i++) {
            dist[i] = Integer.MAX_VALUE;
            sptSet[i] = false;
        }

        // Distance of source vertex from itself is always 0
        dist[src] = 0;

        // Find shortest path for all vertices
        for (int count = 0; count < V - 1; count++) {
            // Pick the minimum distance vertex from the set of vertices
            // not yet processed. u is always equal to src in first iteration.
            int u = minDistance(dist, sptSet);

            // Mark the picked vertex as processed
            sptSet[u] = true;

            // Update dist value of the adjacent vertices of the picked vertex.
            for (int v = 0; v < V; v++)

                // Update dist[v] only if is not in sptSet, there is an edge from
                // u to v, and total weight of path from src to v through u is
                // smaller than current value of dist[v]
                if (!sptSet[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v])
                    dist[v] = dist[u] + graph[u][v];
        }

        // print the constructed distance array
        printSolution(dist);
    }

    // Function to add an edge to the graph
    public void addEdge(int v, int w, int weight) {
        graph[v][w] = weight;
        graph[w][v] = weight; // Assuming undirected graph
    }
}

帮我给这个文件注释改的详细─点

public class Graph {
    private int V; // 图中的顶点数量
    private int[][] graph; // 邻接矩阵表示图

    // 构造函数，初始化图的顶点数量和邻接矩阵
    public Graph(int v) {
        V = v;
        graph = new int[V][V];
    }

    // 找到距离数组中未被包含在最短路径树中的具有最小距离值的顶点的索引
    private int minDistance(int dist[], Boolean sptSet[]) {
        int min = Integer.MAX_VALUE, minIndex = -1; // 初始化最小值为最大整数，索引为-1
        for (int v = 0; v < V; v++) { // 遍历所有顶点
            // 如果顶点v未被包含在最短路径树中，并且其距离小于当前最小值，则更新最小值和索引
            if (sptSet[v] == false && dist[v] <= min) {
                min = dist[v];
                minIndex = v;
            }
        }
        return minIndex; // 返回具有最小距离值的顶点的索引
    }

    // 打印从源顶点到其他所有顶点的距离数组
    public void printSolution(int dist[]) {
        System.out.println("Vertex \t\t Distance from Source"); // 打印表头
        for (int i = 0; i < V; i++) { // 遍历所有顶点
            // 打印每个顶点及其从源顶点的距离
            System.out.println(i + " \t\t " + dist[i]);
        }
    }

    // 实现Dijkstra单源最短路径算法，用于邻接矩阵表示的图
    public void dijkstra(int src) {
        int dist[] = new int[V]; // 创建距离数组，dist[i]将保存从src到i的最短距离
        Boolean sptSet[] = new Boolean[V]; // 创建布尔数组，sptSet[i]为true表示顶点i已在最短路径树中或其最短距离已确定

        // 初始化所有距离为无穷大，布尔数组为false
        for (int i = 0; i < V; i++) {
            dist[i] = Integer.MAX_VALUE; // 设置初始距离为无穷大
            sptSet[i] = false; // 设置初始状态为未包含在最短路径树中
        }

        // 源顶点到自身的距离始终为0
        dist[src] = 0;

        // 计算所有顶点的最短路径
        for (int count = 0; count < V - 1; count++) {
            // 从未处理的顶点集中找到距离最小的顶点u
            int u = minDistance(dist, sptSet);

            // 标记已处理的顶点u
            sptSet[u] = true;

            // 更新顶点u的所有相邻顶点v的距离值
            for (int v = 0; v < V; v++) {
                // 只有当v未被包含在最短路径树中，存在边(u, v)，且通过u到v的路径距离小于当前dist[v]时才更新
                if (!sptSet[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v]; // 更新距离值
                }
            }
        }

        // 打印构造好的距离数组
        printSolution(dist);
    }

    // 向图中添加一条边
    public void addEdge(int v, int w, int weight) {
        graph[v][w] = weight; // 添加边(v, w)
        graph[w][v] = weight; // 假设是无向图，因��也需要添加边(w, v)
    }
}

帮我生成一个用户注册接口，包含用户名、手机号、密码字段。