最短路dijkstra算法详解_用于求最短路的几种算法

最新推荐文章于 2021-11-03 11:01:01 发布

weixin_39898380

最新推荐文章于 2021-11-03 11:01:01 发布

阅读量696

点赞数

文章标签：最短路dijkstra算法详解

本文链接：https://blog.csdn.net/weixin_39898380/article/details/111672767

版权

最短路问题分为单源最短路和多源汇最短路。单源最短路表示一个节点到其它节点的最短距离；多源(起点)汇(终点)最短路表示起点和终点不确定的最短距离求解。

单源最短路按照边权值是否含有负数分为两种。

所有边权都是正数的情况又分为两种：稠密图和稀疏图。稠密图使用邻接矩阵来存储，求解最短路用朴素Dijkstra算法(

)；稀疏图使用邻接表来存储，求解最短路用堆优化版的DijkStra算法(

)。稀疏与否：

边数，

节点数，

稠密图，

稀疏图。

存在负边权的情况又有两种：Bellman-Ford算法和SPFA算法。前者

，后者一般

,最坏情况

。

多源汇最短路使用Floyd算法(

)。

掌握模板之后，最短路问题难点在于建图。

朴素版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[]。因为节点很多，不能遍历每个节点得到最短距离(时间复杂度高)，所以采用(小根)堆来存储距离和相应的节点标号

，此外更新距离的时候也不需要遍历所有节点，只需要更新有连接的节点

。小根堆在Java里有PriorityQueue，数据格式借用泛型来存储键值对并实现比较器接口来实现小根。

题目：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算法擅长解决有边数限制的最短路问题(

)。例如最多经过k条边的最短距离，有的时候经过的边数增多了，距离可能减小了，有负权边的时候更是如此。

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算法

三层循环暴力求解任两个节点间的最短距离

。最外层理解：f[k][i][j]代表（k的取值范围是从1到n），在考虑了

从1到k的节点作为中间经过的节点时，从i到j的最短路径的长度。

题目：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];
                }
    }
}

weixin_39898380

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最短路dijkstra算法详解_用于求最短路的几种算法

最短路问题分为单源最短路和多源汇最短路。单源最短路表示一个节点到其它节点的最短距离；多源(起点)汇(终点)最短路表示起点和终点不确定的最短距离求解。单源最短路按照边权值是否含有负数分为两种。所有边权都是正数的情况又分为两种：稠密图和稀疏图。稠密图使用邻接矩阵来存储，求解最短路用朴素Dijkstra算法( )；稀疏图使用邻接表来存储，求解最短路用堆优化版的DijkStra算法( )。稀疏与否： ...
复制链接

扫一扫