第三章搜索与图论（二）

最短路

无向图和有向图的最短路没有区别，因为无向图就是特殊一点的有向图，连两次边就可以了。
权重存在子节点上

主要分为两类：（源点就是起点，汇点就是终点）

• 单源点最短路：求一个点到其他所有点的最短距离，又分为所有边权都是正数和存在负权边两种情况。
• 多源汇最短路：求一个点到另一个点的最短距离（起点和终点都不确定）

n 是点的数量，m 是边的数量。
如果 m 和 n² 一个级别----稠密图，邻接矩阵存
如果 m 和 n 一个级别----稀疏图 ，邻接表存
SPFA 是 Bellman-Ford 的一种优化，存在负权边一般是用SPFA，但是如果有 "经过的边数不能超过 k "这样的限制，那就只能用 Bellman-Ford。

最短路的题目难点在于如何这个题目抽象成最短路，建图，确定源点，终点，选择相应模板解决该题。

朴素Dijkstra算法

集合 S：存储所有当前已经确定最短距离的点
步骤：
（1）初始化距离，dist[1] = 0, 1 号点到其他点的距离是 0，其他所有点 dist[i] = 正无穷。
（2）最短距离：1号点到当前这个点的最短距离。

for(i = 1 ~ n){
   每次循环确定一个点到起点的最短路
    每次贪心的寻找不在S中的距离起点最近的点t
    S.add(t)
    用t更新其他点到起点的距离
}循环结束，确定完所有点到起点的最短距离

例子：

例题1：849. Dijkstra求最短路 I

注意：若要求任意点i到任意个点j的最短距离，只需修改 dijkstra 方法中的起源位置dist[i] = 0，以及返回为 dist[j]

是稠密图。

因为权都是正的，所以最短路一定不会出现在自环中，对于重边，只保留权最小的边。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
   
	static int N = 510;
	static int INF = Integer.MAX_VALUE >> 1;
	static int n;
	static int m;
	static int[][] g = new int[N][N];
	static int[] dist = new int[N];//dist[i]表示起点到i的距离
	static boolean[] st = new boolean[N];//st[i]表示i号点是否已经确定完
	
	public static void main(String[] args) throws Exception {
   
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] s1 = br.readLine().split(" ");
		n = Integer.parseInt(s1[0]);
		m = Integer.parseInt(s1[1]);
		//初始化邻接矩阵
		for(int i = 1;i <= n;i++) {
   
			for(int j = 1;j <= n;j++) {
   
				if(i == j) {
   
					g[i][j] = 0;
				}else {
   
					g[i][j] = INF;
				}
			}
		}
		while(m-- > 0) {
   
			String[] s2 = br.readLine().split(" ");
			int a = Integer.parseInt(s2[0]);
			int b = Integer.parseInt(s2[1]);
			int c = Integer.parseInt(s2[2]);
			g[a][b] = Math.min(g[a][b], c);//只存权最小的
		}
		int t = dijkstra();
		System.out.println(t);
	}

	private static int dijkstra() {
   
		Arrays.fill(dist, INF);//初始化为正无穷
		dist[1] = 0;
		for(int i = 0;i < n;i++) {
   //迭代n次
			//找距离起点最近的点t
			int t = -1;
			for(int j = 1;j <= n;j++) {
   //遍历所有节点
				if(!st[j] && (t == -1 || dist[t] > dist[j])) {
   
					t = j;
				}
			}
			if(t == n) break;//小优化，找到n可以提前退出迭代，可以不写
			//放入s中
			st[t] = true;
			//用t更新
			for(int j = 1;j <= n;j++) {
   
				//下面用到了加法，所以如果INF=MAX_VALUE的话可能会溢出
				dist[j] = Math.min(dist[j], dist[t] + g[t][j]);//t到起点,t到j的距离和
			}
		}
		if(dist[n] == INF) return -1;
		return dist[n];
	}
}

堆优化的Dijkstra

前面的朴素法，步骤二中具体每一行的时间复杂度：

for(i = 1 ~ n){
     O(n)
    每次贪心的寻找不在S中的距离起点最近的点t----for(节点编号j = 1--n)  O(n)
    S.add(t)  O(1)
    用t更新其他点到起点的距离 O(n)
}循环结束，确定完所有点到起点的最短距离

之所以总体是O(n²)，关键就在于内层的 for，因为外层的 for 没法优化，内层的 for 目的是在一堆数中找一个最值嘛，所以可以通过堆来优化成 O(1)，在堆中修改一个数需要O(logn)来维护堆，所以优化之后的时间复杂度：
注意，稀疏图使用堆优化的 Dijkstra，此时采用邻接表存储图。
看代码可以分析出，最终时间复杂度是O(mlogn)

堆：手写堆或者用优先队列，不用手写了，直接用优先队列

例题2：850. Dijkstra求最短路 II

用邻接表的话重边就无所谓了

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;

public class Main {
   
	static int N = 150010;
	static int INF = Integer.MAX_VALUE >> 1;
	static int n;
	static int m;
	static int[] h = new int[N];//N为顶点数
	static int[] e = new int[N];//N为边数
	static int[]