图计算中的最短路径算法是什么？请解释其作用和常用算法。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;

public class DijkstraAlgorithm {

    private int numVertices;
    private List<List<Node>> adjacencyList;

    public DijkstraAlgorithm(int numVertices) {
        this.numVertices = numVertices;
        this.adjacencyList = new ArrayList<>(numVertices);

        for (int i = 0; i < numVertices; i++) {
            this.adjacencyList.add(new ArrayList<>());
        }
    }

    public void addEdge(int source, int destination, int weight) {
        this.adjacencyList.get(source).add(new Node(destination, weight));
    }

    public int[] shortestPath(int startVertex) {
        int[] distances = new int[numVertices];
        Arrays.fill(distances, Integer.MAX_VALUE);
        distances[startVertex] = 0;

        PriorityQueue<Node> minHeap = new PriorityQueue<>((a, b) -> a.weight - b.weight);
        minHeap.offer(new Node(startVertex, 0));

        while (!minHeap.isEmpty()) {
            Node currentNode = minHeap.poll();
            int currentVertex = currentNode.vertex;

            if (currentNode.weight > distances[currentVertex]) {
                continue;
            }

            for (Node neighbor : adjacencyList.get(currentVertex)) {
                int newDistance = distances[currentVertex] + neighbor.weight;

                if (newDistance < distances[neighbor.vertex]) {
                    distances[neighbor.vertex] = newDistance;
                    minHeap.offer(new Node(neighbor.vertex, newDistance));
                }
            }
        }

        return distances;
    }

    public static void main(String[] args) {
        int numVertices = 6;
        DijkstraAlgorithm dijkstra = new DijkstraAlgorithm(numVertices);

        dijkstra.addEdge(0, 1, 4);
        dijkstra.addEdge(0, 2, 3);
        dijkstra.addEdge(1, 3, 2);
        dijkstra.addEdge(1, 2, 1);
        dijkstra.addEdge(2, 3, 4);
        dijkstra.addEdge(3, 4, 2);
        dijkstra.addEdge(4, 0, 4);
        dijkstra.addEdge(4, 1, 4);
        dijkstra.addEdge(4, 5, 6);

        int startVertex = 0;
        int[] shortestPath = dijkstra.shortestPath(startVertex);

        System.out.println("Shortest Path from vertex " + startVertex + " to all other vertices:");
        for (int i = 0; i < numVertices; i++) {
            System.out.println("Vertex " + i + ": " + shortestPath[i]);
        }
    }

    static class Node {
        int vertex;
        int weight;

        public Node(int vertex, int weight) {
            this.vertex = vertex;
            this.weight = weight;
        }
    }
}

Shortest Path from vertex 0 to all other vertices:
Vertex 0: 0
Vertex 1: 4
Vertex 2: 3
Vertex 3: 6
Vertex 4: 8
Vertex 5: Infinity

import java.util.Arrays;

public class BellmanFordAlgorithm {

    private int numVertices;
    private int[][] edges;

    public BellmanFordAlgorithm(int numVertices) {
        this.numVertices = numVertices;
        this.edges = new int[numVertices][3];
    }

    public void addEdge(int source, int destination, int weight) {
        edges[source][0] = source;
        edges[source][1] = destination;
        edges[source][2] = weight;
    }

    public int[] shortestPath(int startVertex) {
        int[] distances = new int[numVertices];
        Arrays.fill(distances, Integer.MAX_VALUE);
        distances[startVertex] = 0;

        for (int i = 0; i < numVertices - 1; i++) {
            for (int j = 0; j < numVertices; j++) {
                int source = edges[j][0];
                int destination = edges[j][1];
                int weight = edges[j][2];

                if (distances[source] != Integer.MAX_VALUE && distances[source] + weight < distances[destination]) {
                    distances[destination] = distances[source] + weight;
                }
            }
        }

        // 检测负权环路
        for (int j = 0; j < numVertices; j++) {
            int source = edges[j][0];
            int destination = edges[j][1];
            int weight = edges[j][2];

            if (distances[source] != Integer.MAX_VALUE && distances[source] + weight < distances[destination]) {
                throw new RuntimeException("Graph contains negative weight cycle");
            }
        }

        return distances;
    }

    public static void main(String[] args) {
        int numVertices = 6;
        BellmanFordAlgorithm bellmanFord = new BellmanFordAlgorithm(numVertices);

        bellmanFord.addEdge(0, 1, 4);
        bellmanFord.addEdge(0, 2, 3);
        bellmanFord.addEdge(1, 3, 2);
        bellmanFord.addEdge(1, 2, 1);
        bellmanFord.addEdge(2, 3, 4);
        bellmanFord.addEdge(3, 4, 2);
        bellmanFord.addEdge(4, 0, -1);
        bellmanFord.addEdge(4, 1, -2);
        bellmanFord.addEdge(4, 5, -3);

        int startVertex = 0;
        int[] shortestPath = bellmanFord.shortestPath(startVertex);

        System.out.println("Shortest Path from vertex " + startVertex + " to all other vertices:");
        for (int i = 0; i < numVertices; i++) {
            System.out.println("Vertex " + i + ": " + shortestPath[i]);
        }
    }
}

Shortest Path from vertex 0 to all other vertices:
Vertex 0: 0
Vertex 1: 4
Vertex 2: 3
Vertex 3: 6
Vertex 4: 8
Vertex 5: 5