首先是图的表示，邻接矩阵和邻接表。实现看代码
- 邻接矩阵：二维数组，
- matrix[a][b] 表示 从a可以指向b
- 无向图而言， matrix[a][b]=matrix[b][a]，比如可以定义matrix[a][b]=1表示ab是连接的，matrix[a][b]=0表示ab是不可连接的
- 有向图：matrix[a][b]=x，表示从a到b的权是x，如果matrix[a][b]=无穷大，表示ab是不可连接的
- 邻接表：
- 外层是一个数组，数组长度表示图中有多少个节点，数组下标对应节点a
- 每个数组中，存放一个链表，链表的每个节点也是数组
- 链表长度代表从a可以直接指向多少个节点
- 链表元素树一个数组，数组第一个元素代表被执向的b，第二个元素代表a到b的权
个人感觉，邻接矩阵适合无向图，邻接表适合有向图。
/*** 邻接矩阵** @param n 初始化图中节点的个数* @param edges edges边，从edge[0]指向edge[1],路径长度为edge[2]* @return matrix*/
public int[][] adjacentMatrix(int n, int[][] edges) {// 邻接矩阵就是一个二维数组，很好理解，对应坐标的值是路径长度int[][] matrix = new int[n][n];for (int[] edge : edges) {int start = edge[0];int end = edge[1];int length = edge[2];matrix[start][end] = length;}return matrix;
}public List<int[]>[] adjacentList(int n, int[][] edges) {// 邻接列表，最外层是个数组，数组元素是一个列表// 列表中存储的数据，又是一个数组// 最外层数组，坐标代表edge[0]// 数组元素是个列表，这个列表存储的东西是 edge[1]，edge[2]// 每个链表有多少元素，就说明这个点指向多少个别的点List<int[]>[] list = new List[n];for (int i = 0; i < n; i++) {list[i] = new ArrayList<>();}for (int[] edge : edges) {int start = edge[0];int end = edge[1];int length = edge[2];list[start].add(new int[] {end, length});}return list;
}
2642. 设计可以求最短路径的图类
比如我们求从0 到其他点的最短距离，定义一个数组，第0行分别是每个节点，第一行是0到其他节点的距离，初始化为正无穷大，第三行是表示是否已经是最小距离。
| 0 | 1 | 2 | 3 |
| 0 | ∞ | ∞ | ∞ |
| T | F | F | F |
首先遍历0能够直接到达的顶点，修改如下，此时0到1的距离是最短的，可以标记为T
| 0 | 1 | 2 | 3 |
| 0 | 2 | 5 | ∞ |
| T | T | F | F |
然后看从2出发，能够直接到达的距离
因为从1到2的距离是2+1，小于当前的5，因此可以刷新下表，此时得到了0到2最短距离3
| 0 | 1 | 2 | 3 |
| 0 | 2 | 3 | ∞ |
| T | T | T | F |
思路就是上面的思路，不断的获取距离，然后和当前的距离比较，如果比他小，就更新进去。
public class Graph {List<int[]>[] graph;public Graph(int n, int[][] edges) {graph = adjacentList(n, edges);}public List<int[]>[] adjacentList(int n, int[][] edges) {List<int[]>[] list = new List[n];for (int i = 0; i < n; i++) {list[i] = new ArrayList<>();}for (int[] edge : edges) {int start = edge[0];int end = edge[1];int length = edge[2];list[start].add(new int[] {end, length});}return list;}// 向边集中添加一条边,本题的数据保证添加这条边之前对应的两个节点之间没有有向边// 这说明添加不会产生新的节点。即邻接矩阵外层的数组长度不会改变，只会改变数组元素的链表public void addEdge(int[] edge) {int start = edge[0];int end = edge[1];int length = edge[2];graph[start].add(new int[] {end, length});}public int shortestPath(int node1, int node2) {// 如果是同一个端点，说明路径为0，直接返回即可if (node1 == node2) {return 0;}// 定义一个距离数组，用于标识从当前node1出发，到所有点的最短路径，初始化值为Integer.MAX_VALUE，表示无穷大int[] distance = new int[graph.length];Arrays.fill(distance, Integer.MAX_VALUE);// node1到自身的距离为0；distance[node1] = 0;// 参考BFS，定义一个队列Queue<int[]> queue = new LinkedList<>();// 把node1变成节点传入队列中，队列存一个长度2的数组，分别表示到这个节点，距离queue.offer(new int[] {node1, 0});while (!queue.isEmpty()) {int[] poll = queue.poll();int cur = poll[0];int cost = poll[1];// if (cur == node2) {// return cost;// }// 从邻接列表中取出当前节点可以指向的节点list，遍历这个listList<int[]> list = graph[cur];for (int[] arr : list) {int next = arr[0];int ncost = arr[1];// 如果路径和比当前小，就更新进去if (distance[next] > cost + ncost) {distance[next] = cost + ncost;queue.offer(new int[] {next, cost + ncost});}}}return distance[node2] == Integer.MAX_VALUE ? -1 : distance[node2];}
}// 优化，如果我们定义一个优先级队列，这样每次BFS的时候，都会先遍历路径最小的节点
// 这样的话，就可以在while循环里面进行判断，如果等于目标节点，就可以直接返回了
Queue<int[]> queue = new PriorityQueue<>((a, b) -> a[1] - b[1]);
