从0到上线只需3小时！飞算JavaAI引爆全民编程革命：不懂代码也能做系统，AI全自动开发时代来了！

import java.util.Arrays;

public class Graph {
    private int numVertices;
    private int[][] adjMatrix;

    public Graph(int numVertices) {
        this.numVertices = numVertices;
        adjMatrix = new int[numVertices][numVertices];
    }

    public void addEdge(int i, int j, int weight) {
        adjMatrix[i][j] = weight;
        adjMatrix[j][i] = weight; // 如果是无向图
    }

    public void dijkstra(int startVertex) {
        int[] distances = new int[numVertices];
        boolean[] visited = new boolean[numVertices];

        Arrays.fill(distances, Integer.MAX_VALUE);
        distances[startVertex] = 0;

        for (int vertex = 0; vertex < numVertices - 1; vertex++) {
            int u = findMinDistance(distances, visited);
            visited[u] = true;

            for (int v = 0; v < numVertices; v++) {
                if (!visited[v] && adjMatrix[u][v] != 0 &&
                    distances[u] != Integer.MAX_VALUE &&
                    distances[u] + adjMatrix[u][v] < distances[v]) {
                    distances[v] = distances[u] + adjMatrix[u][v];
                }
            }
        }

        printSolution(distances, startVertex);
    }

    private int findMinDistance(int[] distances, boolean[] visited) {
        int min = Integer.MAX_VALUE;
        int index = -1;

        for (int v = 0; v < numVertices; v++) {
            if (!visited[v] && distances[v] <= min) {
                min = distances[v];
                index = v;
            }
        }
        return index;
    }

    private void printSolution(int[] distances, int startVertex) {
        System.out.println("Vertex Distance from " + startVertex);
        for (int i = 0; i < numVertices; i++) {
            System.out.println(i + "\t\t" + distances[i]);
        }
    }

    public static void main(String[] args) {
        Graph g = new Graph(5);
        g.addEdge(0, 1, 9);
        g.addEdge(0, 2, 6);
        g.addEdge(0, 3, 5);
        g.addEdge(0, 4, 3);
        g.addEdge(2, 1, 2);
        g.addEdge(2, 3, 4);

        g.dijkstra(0);
    }
}

import java.util.Arrays;

/**
 * 图类，用于表示带权重的无向图，并实现Dijkstra最短路径算法
 * 使用邻接矩阵存储图结构
 */
public class Graph {
    private int numVertices;        // 图中顶点的数量
    private int[][] adjMatrix;      // 邻接矩阵，存储边的权重

    /**
     * 构造函数：初始化图
     * @param numVertices 顶点数量
     */
    public Graph(int numVertices) {
        this.numVertices = numVertices;
        // 创建numVertices x numVertices的二维数组作为邻接矩阵
        // 初始化所有边的权重为0（表示无连接）
        adjMatrix = new int[numVertices][numVertices];
    }

    /**
     * 添加边到图中
     * @param i 起始顶点索引
     * @param j 结束顶点索引  
     * @param weight 边的权重（距离）
     */
    public void addEdge(int i, int j, int weight) {
        // 在邻接矩阵中设置两个方向的权重
        // 因为是无向图，所以i->j和j->i的权重相同
        adjMatrix[i][j] = weight;
        adjMatrix[j][i] = weight; // 如果是无向图则需要双向设置
    }

    /**
     * Dijkstra算法：计算从起始顶点到其他所有顶点的最短距离
     * @param startVertex 起始顶点索引
     */
    public void dijkstra(int startVertex) {
        // distances[i] 存储从起始顶点到顶点i的最短距离
        int[] distances = new int[numVertices];
        
        // visited[i] 标记顶点i是否已找到最短路径
        boolean[] visited = new boolean[numVertices];

        // 初始化所有距离为无穷大（用Integer.MAX_VALUE表示）
        Arrays.fill(distances, Integer.MAX_VALUE);
        
        // 起始顶点到自身的距离为0
        distances[startVertex] = 0;

        // 主循环：需要处理numVertices-1个顶点
        // （起始顶点已处理，剩余numVertices-1个）
        for (int vertex = 0; vertex < numVertices - 1; vertex++) {
            // 找到当前未访问顶点中距离最小的顶点
            int u = findMinDistance(distances, visited);
            
            // 将该顶点标记为已访问
            // 一旦标记为已访问，其最短距离就确定了
            visited[u] = true;

            // 更新与顶点u相邻的所有未访问顶点的距离
            for (int v = 0; v < numVertices; v++) {
                // 满足以下条件时更新距离：
                // 1. 顶点v未被访问
                // 2. u和v之间有边连接（权重不为0）
                // 3. 从起始点到u的距离不是无穷大（可达）
                // 4. 通过u到达v的距离比当前记录的距离更短
                if (!visited[v] && adjMatrix[u][v] != 0 &&
                    distances[u] != Integer.MAX_VALUE &&
                    distances[u] + adjMatrix[u][v] < distances[v]) {
                    // 更新顶点v的最短距离
                    distances[v] = distances[u] + adjMatrix[u][v];
                }
            }
        }

        // 打印最终的最短距离结果
        printSolution(distances, startVertex);
    }

    /**
     * 在未访问的顶点中找到距离起始点最近的顶点
     * @param distances 当前各顶点到起始点的距离数组
     * @param visited 访问状态数组
     * @return 距离最小的未访问顶点的索引
     */
    private int findMinDistance(int[] distances, boolean[] visited) {
        int min = Integer.MAX_VALUE;  // 记录最小距离值
        int index = -1;               // 记录最小距离顶点的索引

        // 遍历所有顶点
        for (int v = 0; v < numVertices; v++) {
            // 如果顶点未被访问，且其距离小于等于当前最小值
            if (!visited[v] && distances[v] <= min) {
                min = distances[v];   // 更新最小距离值
                index = v;            // 更新最小距离顶点的索引
            }
        }
        return index;  // 返回距离最小的未访问顶点索引
    }

    /**
     * 打印最短路径结果
     * @param distances 最短距离数组
     * @param startVertex 起始顶点
     */
    private void printSolution(int[] distances, int startVertex) {
        System.out.println("Vertex Distance from " + startVertex);
        // 打印从起始顶点到每个顶点的最短距离
        for (int i = 0; i < numVertices; i++) {
            System.out.println(i + "\t\t" + distances[i]);
        }
    }

    /**
     * 主函数：程序入口点
     * 创建图实例，添加边，运行Dijkstra算法
     */
    public static void main(String[] args) {
        // 创建一个包含5个顶点的图
        Graph g = new Graph(5);
        
        // 添加边及其权重
        g.addEdge(0, 1, 9);  // 顶点0和1之间权重为9
        g.addEdge(0, 2, 6);  // 顶点0和2之间权重为6
        g.addEdge(0, 3, 5);  // 顶点0和3之间权重为5
        g.addEdge(0, 4, 3);  // 顶点0和4之间权重为3
        g.addEdge(2, 1, 2);  // 顶点2和1之间权重为2
        g.addEdge(2, 3, 4);  // 顶点2和3之间权重为4

        // 从顶点0开始运行Dijkstra算法
        // 计算从顶点0到其他所有顶点的最短距离
        g.dijkstra(0);
    }
}