最短路问题分为单源最短路和多源汇最短路。单源最短路表示一个节点到其它节点的最短距离;多源(起点)汇(终点)最短路表示起点和终点不确定的最短距离求解。
单源最短路按照边权值是否含有负数分为两种。
所有边权都是正数的情况又分为两种:稠密图和稀疏图。稠密图使用邻接矩阵来存储,求解最短路用朴素Dijkstra算法(
存在负边权的情况又有两种:Bellman-Ford算法和SPFA算法。前者
多源汇最短路使用Floyd算法(
掌握模板之后,最短路问题难点在于建图。
![7cfd11fa736fd8cfe0e1f2825fec41eb.png](https://i-blog.csdnimg.cn/blog_migrate/a306788133de42f4f60c42b973f9b620.jpeg)
朴素版Dijkstra算法
属性g[][],dist[][],state[][]分别表示图、节点到节点1的最短距离,节点是否找到最短路。(也可以求解节点i到节点j的最短距离,令dist[i]=0返回dist[j]即可)。
算法流程:首先令dist[1]=0,dist[其它]=+∞(0x3f3f3f3f,int型)。然后遍历每个节点将距离最短的节点放入state,然后用该节点更新其他节点到节点1的距离。
题目:Acwing849
给定一个n个点m条边的有向图,图中可能存在重边和自环,所有边权均为正值。
请你求出1号点到n号点的最短距离,如果无法从1号点走到n号点,则输出-1。![]()
java代码如下:
import java.util.*;
import java.io.*;
class Main{
static int N = 510;
static int[][] g = new int[N][N]; //稠密图
static int[] dist = new int[N]; //每个节点到节点1的距离
static boolean[] state = new boolean[N]; //每个节点的最短距离是否确定
static int n;
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] str = br.readLine().split(" ");
n = Integer.parseInt(str[0]);
int m = Integer.parseInt(str[1]);
for(int i = 1;i <= n;i++) dist[i] = 0x3f3f3f3f;
for(int i = 1;i <=n;i++)
for(int j = 1;j <= n;j++)
g[i][j] = 0x3f3f3f3f; //为了之后进行距离比较
while(m-- > 0){
String[] nums = br.readLine().split(" ");
int x = Integer.parseInt(nums[0]);
int y = Integer.parseInt(nums[1]);
int z = Integer.parseInt(nums[2]);
if(g[x][y] > z) g[x][y] = z; //因为找最短距离,所以重边时保留最短的边
}
int distance = dijkstra();
System.out.println(distance);
br.close();
}
static int dijkstra(){
dist[1] = 0;
for(int i = 1;i <= n;i++){
int t = -1; //state为false的距离节点1最短的节点
for(int j = 1;j <= n;j++){ //找出state为false的距离节点1最短的节点
if(!state[j] && (t == -1 || dist[j]< dist[t]))
t = j;
}
state[t] = true;
for(int j = 1;j <= n;j++){
if(dist[j] > dist[t] + g[t][j]) dist[j] = dist[t] + g[t][j]; //画图理解
}
}
if(dist[n] > 0x3f3f3f3f/2) return -1;
else return dist[n];
}
}
堆优化版Dijksttra算法
稀疏图用邻接表来存储,属性h[],value[],next[],w[],index,dist[],state[]。因为节点很多,不能遍历每个节点得到最短距离(时间复杂度高),所以采用(小根)堆来存储距离和相应的节点标号
题目:AcWing850
给定一个n个点m条边的有向图,图中可能存在重边和自环,所有边权均为非负值。
请你求出1号点到n号点的最短距离,如果无法从1号点走到n号点,则输出-1。![]()
java代码如下:
import java.util.*;
import java.io.*;
public class Main{
static int N = 150010;
//稀疏有向图图
static int[] h = new int[N];
static int[] value = new int[N];
static int[] next = new int[N];
static int[] w = new int[N];
static int index = 1;
static boolean[] state = new boolean[N];
static int[] dist = new int[N];
static int INF = 0x3f3f3f3f;
static int n;
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Arrays.fill(h,-1); //数组赋初值,只能对一维数组这样初始化
Arrays.fill(w,INF);
Arrays.fill(dist,INF);
String[] str = br.readLine().split(" ");
n = Integer.parseInt(str[0]);
int m = Integer.parseInt(str[1]);
while(m-- > 0){
String[] nums = br.readLine().split(" ");
int x = Integer.parseInt(nums[0]);
int y = Integer.parseInt(nums[1]);
int z = Integer.parseInt(nums[2]);
add(x,y,z);
}
int d = dijkstra();
System.out.println(d);
br.close();
}
static void add(int x,int y,int z){
value[index] = y;
w[index] = z;
next[index] = h[x];
h[x] = index++;
}
static int dijkstra(){
PriorityQueue<PIIs> queue = new PriorityQueue<PIIs>(); //优先队列:堆
dist[1] = 0;
queue.add(new PIIs(0,1));
while(!queue.isEmpty()){
PIIs p = queue.poll(); //就是距离最小的节点,不需要遍历来寻找距离最小的节点
int t = p.getSecond();
int distance = p.getFirst();
if(state[t]) continue;
state[t] = true;
for(int i = h[t];i != -1;i = next[i]){ //只遍历有连接的节点
int j = value[i];
if(dist[j] > distance + w[i]){
dist[j] = distance + w[i];
queue.add(new PIIs(dist[j],j));
}
}
}
if(dist[n] == INF) return -1;
else return dist[n];
}
}
class PIIs implements Comparable<PIIs>{
int first; //距离
int second; //节点
public PIIs(int first,int second){
this.first = first;
this.second = second;
}
public int getFirst(){
return this.first;
}
public int getSecond(){
return this.second;
}
public int compareTo(PIIs o){
return Integer.compare(first,o.first);
}
}
Bellman-Ford算法
bellman - ford算法擅长解决有边数限制的最短路问题(
bellman - ford算法遍历的是所有边(内层循环),用该边更新距离,因为前面更新的距离会影响后面更新的距离(串联效应),所以在每次用边更新距离前备份一个dist1,用这个来更新距离(但是有的边的起始点a的dist[a]没有被更新过,那么dist[b]就不会被更新,这样就浪费了时间,SPFA就是对这一步进行了优化,只有被更新过的点才能更新别的点)。外层循环是经过的边数,如果进行n-1条边之后,dist[n]还能更新,那么1到n中间存在负环(1到n间最多有n-1条边)。
此外在节点1到n间如果有负权回路时,在经过k条边更新距离时会使距离小于INF,所以用INF/2判断是否存在距离。
题目:AcWing853
给定一个n个点m条边的有向图,图中可能存在重边和自环, 边权可能为负数。
请你求出从1号点到n号点的最多经过k条边的最短距离,如果无法从1号点走到n号点,输出impossible。
注意:图中可能 存在负权回路 。![]()
java代码如下:
import java.util.*;
import java.io.*;
public class Main{
static int N = 510;
static int M = 10010;
static int[] dist = new int[N];
static Link[] links = new Link[M];
static int[] backup = new int[N];
static int n;
static int k;
static int m;
static int INF = 0x3f3f3f3f;
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Arrays.fill(dist,INF);
String[] str = br.readLine().split(" ");
n = Integer.parseInt(str[0]);
m = Integer.parseInt(str[1]);
k = Integer.parseInt(str[2]);
for(int i = 1;i <= m;i++){
String[] nums = br.readLine().split(" ");
int x = Integer.parseInt(nums[0]);
int y = Integer.parseInt(nums[1]);
int z = Integer.parseInt(nums[2]);
Link l = new Link(x,y,z);
links[i] = l;
}
int length = bellman_ford();
if(length == -1) System.out.println("impossible");
else System.out.println(length);
br.close();
}
static int bellman_ford(){
dist[1] = 0;
for(int i = 1;i <= k;i++){ //外层循环是经过的边数所更新的最短距离
//下面个循环是更新各个节点的最短距离,用dist更新距离的话,前面新更新的会影响后面的,所以用备份数组进行更新
backup = Arrays.copyOf(dist,n+1);
for(int j = 1;j <= m;j++){ //遍历每条边
Link l = links[j];
if(dist[l.b] > backup[l.a] + l.w) dist[l.b] = backup[l.a] + l.w;
}
}
if(dist[n] > INF/2) return -1;
return dist[n];
}
}
class Link{
int a;
int b;
int w;
public Link(int a,int b,int w){
this.a = a;
this.b = b;
this.w = w;
}
}
SPFA算法
spfa算法还能解决正权图的最短路问题,遇到题目可以试试。
spfa算法是bellman_ford算法的改进版,就是在原节点的距离被更新后才进行其目标节点距离的更新,而不是遍历所有的边。将距离更新后的节点加入队列,并改变state[]表示其在队列中。出队后再设置其为false。
题目:AcWing851
给定一个n个点m条边的有向图,图中可能存在重边和自环, 边权可能为负数。
请你求出1号点到n号点的最短距离,如果无法从1号点走到n号点,则输出impossible。
数据保证不存在负权回路。![]()
java代码如下:
import java.util.*;
import java.io.*;
class Main{
static int N = 100010;
static int[] h = new int[N];
static int[] value = new int[N];
static int[] next = new int[N];
static int[] w = new int[N];
static int index = 1;
static int[] dist = new int[N];
static boolean[] state = new boolean[N];
static int n;
static int m;
static int INF = 0x3f3f3f3f;
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Arrays.fill(h,-1);
Arrays.fill(w,INF);
Arrays.fill(dist,INF);
String[] str = br.readLine().split(" ");
n = Integer.parseInt(str[0]);
m = Integer.parseInt(str[1]);
for(int i = 1;i <= m;i++){
String[] nums = br.readLine().split(" ");
int x = Integer.parseInt(nums[0]);
int y = Integer.parseInt(nums[1]);
int z = Integer.parseInt(nums[2]);
add(x,y,z);
}
int length = spfa();
if(length == -1) System.out.println("impossible");
else System.out.println(length);
}
static void add(int x,int y,int z){
value[index] = y;
w[index] = z;
next[index] = h[x];
h[x] = index++;
}
static int spfa(){
Queue<Integer> q = new LinkedList<>();
dist[1] = 0;
q.add(1);
state[1] = true; //只在更新距离后入队,进行入队为true,出队为false
while(!q.isEmpty()){
int t = q.poll();
state[t] = false;
for(int i = h[t];i != -1; i =next[i]){
int j = value[i];
if(dist[j] > dist[t] + w[i]){
dist[j] = dist[t] + w[i];
if(!state[j]){
q.add(j);
state[j] = true;
}
}
}
}
if(dist[n] > INF/2) return -1;
else return dist[n];
}
}
spfa算法还能判断是否存在负环(负权回路):维护一个count数组,记录count[i]记录某节点到节点i最短路径所经历的边数,当count[i]>=n时,说明有负环,有环是因为任意两节点之间最多存在n-1条边,负的是因为更新距离总是朝着减小的方向进行。所以环是负的。此外负环可能与节点1无关(到达不了),所以刚开始队列将所有数都加进去。
题目:AcWing852
给定一个n个点m条边的有向图,图中可能存在重边和自环, 边权可能为负数。
请你判断图中是否存在负权回路。![]()
java代码如下:
import java.io.*;
import java.util.*;
class Main{
static int N = 2010;
static int M = 10010;
static int[] h = new int[N];
static int[] value = new int[M];
static int[] next = new int[M];
static int[] w = new int[M];
static int index = 1;
static int[] dist = new int[N];
static boolean[] state = new boolean[N];
static int[] count = new int[N];
static int INF = 0x3f3f3f3f;
static int n,m;
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] str = br.readLine().split(" ");
n = Integer.parseInt(str[0]);
m = Integer.parseInt(str[1]);
Arrays.fill(h,-1);
while(m-- > 0){
String[] nums = br.readLine().split(" ");
int x = Integer.parseInt(nums[0]);
int y = Integer.parseInt(nums[1]);
int z = Integer.parseInt(nums[2]);
add(x,y,z);
}
if(spfa()) System.out.println("Yes");
else System.out.println("No");
br.close();
}
static void add(int x,int y,int z){
value[index] = y;
w[index] = z;
next[index] = h[x];
h[x] = index++;
}
static boolean spfa(){
Queue<Integer> q = new LinkedList<>();
//因为不需要求解距离,所以距离不需要初始化
for(int i = 1;i <= n;i++){ //负环的位置不确定,所以每个节点都是起点
q.add(i);
state[i] = true;
}
while(!q.isEmpty()){
int t = q.poll();
state[t] = false;
for(int i = h[t] ;i != -1;i = next[i]){
int j = value[i];
if(dist[j] > dist[t] + w[i]){
dist[j] = dist[t] + w[i]; //每次更新距离的时候,边数加1,画图理解
count[j] += 1;
if(count[j] >= n) return true;
if(!state[j]){
q.add(j);
state[j] = true;
}
}
}
}
return false;
}
}
Floyd算法
三层循环暴力求解任两个节点间的最短距离
题目:AcWing854
给定一个n个点m条边的有向图,图中可能存在重边和自环,边权可能为负数。
再给定k个询问,每个询问包含两个整数x和y,表示查询从点x到点y的最短距离,如果路径不存在,则输出“impossible”。
数据保证图中不存在负权回路。![]()
java代码如下:
import java.util.*;
import java.io.*;
class Main{
static int N = 210;
static int[][] d = new int[N][N]; //邻接矩阵
static int n,m,q;
static int INF = 0x3f3f3f3f;
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
for(int i = 0;i < N;i++)
for(int j = 0;j < N;j++)
if(i == j) d[i][j] = 0; //自环距离为0
else d[i][j] = INF;
String[] str = br.readLine().split(" ");
n = Integer.parseInt(str[0]);
m = Integer.parseInt(str[1]);
q = Integer.parseInt(str[2]);
while(m-- > 0){
String[] nums = br.readLine().split(" ");
int x = Integer.parseInt(nums[0]);
int y = Integer.parseInt(nums[1]);
int z = Integer.parseInt(nums[2]);
if(d[x][y] > z) d[x][y] = z;
}
floyd();
while(q -- > 0){
String[] nums = br.readLine().split(" ");
int x = Integer.parseInt(nums[0]);
int y = Integer.parseInt(nums[1]);
if(d[x][y] > INF/2) bw.write("impossible" + "n"); //有负权边,可能会使本来没有连接的两节点距离小于INF
else bw.write(d[x][y]+ "n");
}
bw.flush();
bw.close();
br.close();
}
static void floyd(){
for(int k = 1; k <= n;k++)
for(int i = 1;i <= n;i++)
for(int j = 1;j <= n;j++){
if(d[i][j] > d[i][k] + d[k][j])
d[i][j] = d[i][k] + d[k][j];
}
}
}