对于普通的BFS算法，无法解决有权图中的最短路径问题，因为它不能保证处于队列前面的顶点是最接近源s的顶点，所以需要对BFS加以改进，保证每次访问的节点到源点的长度是最短的。
基本思想：
1.将图上的初始点看作一个集合S，其它点看作另一个集合
2.根据初始点，求出其它点到初始点的距离d[i] （若相邻，则d[i]为边权值；若不相邻，则d[i]为无限大）
3.选取最小的d[i]（记为d[x]），并将此d[i]边对应的点（记为x）加入集合S
（实际上，加入集合的这个点的d[x]值就是它到初始点的最短距离）
4.再根据x，更新跟 x 相邻点 y 的d[y]值：d[y] = min{ d[y], d[x] + 边权值w[x][y] }，因为可能把距离调小，所以这个更新操作叫做松弛操作。
（仔细想想，为啥只更新跟x相邻点的d[y]，而不是更新所有跟集合 s 相邻点的 d 值？ 因为第三步只更新并确定了x点到初始点的最短距离，集合内其它点是之前加入的，也经历过第 4 步，所以与 x 没有相邻的点的 d 值是已经更新过的了，不会受到影响）
5.重复3，4两步，直到目标点也加入了集合，此时目标点所对应的d[i]即为最短路径长度。
（注：重复第三步的时候，应该从所有的d[i]中寻找最小值，而不是只从与x点相邻的点中寻找。想想为什么？）
图解：（动图很快，不容易理解，最好结合上面的步骤自己画一个图，一步一步消化）
原理：Dijkstra的大致思想就是，根据初始点，挨个的把离初始点最近的点一个一个找到并加入集合，集合中所有的点的d[i]都是该点到初始点最短路径长度，由于后加入的点是根据集合S中的点为基础拓展的，所以也能找到最短路径。算法实现方面可以使用堆优化，堆优化的主要思想就是使用一个优先队列（就是每次弹出的元素一定是整个队列中最小的元素）来代替最近距离的查找，用邻接表代替邻接矩阵，这样可以大幅度节约时间开销。
python代码实现：
#!/usr/bin/env python # -*- coding: utf-8 -*- # 定义不可达距离 _ = float('inf') # points点个数，edges边个数,graph路径连通图,start起点,end终点 def Dijkstra(points, edges, graph, start, end): map = [[_ for i in range(points + 1)] for j in range(points + 1)] pre = [0] * (points + 1) # 记录前驱 vis = [0] * (points + 1) # 记录节点遍历状态 dis = [_ for i in range(points + 1)] # 保存最短距离 road = [0] * (points + 1) # 保存最短路径 roads = [] map = graph for i in range(points + 1): # 初始化起点到其他点的距离 if i == start: dis[i] = 0 else: dis[i] = map[start][i] if map[start][i] != _: pre[i] = start else: pre[i] = -1 vis[start] = 1 for i in range(points + 1): # 每循环一次确定一条最短路 min = _ for j in range(points + 1): # 寻找当前最短路 if vis[j] == 0 and dis[j] < min: t = j min = dis[j] vis[t] = 1 # 找到最短的一条路径 ,标记 for j in range(points + 1): if vis[j] == 0 and dis[j] > dis[t] + map[t][j]: dis[j] = dis[t] + map[t][j] pre[j] = t p = end len = 0 while p >= 1 and len < points: road[len] = p p = pre[p] len += 1 mark = 0 len -= 1 while len >= 0: roads.append(road[len]) len -= 1 return dis[end], roads # 固定map图 def map(): map = [[_, _, _, _, _, _], [_, _, 2, 3, _, 7], [_, 2, _, _, 2, _], [_, 3, _, _, _, 5], [_, _, 2, _, _, 3], [_, 7, _, 5, 3, _] ] s, e = input("输入起点和终点：").split() dis, road = Dijkstra(5, 7, map, int(s), int(e)) print("最短距离：", dis) print("最短路径：", road) # 输入边关系构造map图 def createmap(): a, b = input("输入节点数和边数：").split() n = int(a) m = int(b) map = [[_ for i in range(n + 1)] for j in range(n + 1)] for i in range(m + 1): x, y, z = input("输入两边和长度：").split() point = int(x) edge = int(y) map[point][edge] = float(z) map[edge][point] = float(z) s, e = input("输入起点和终点：").split() start = int(s) end = int(e) dis, road = Dijkstra(n, m, map, start, end) print("最短距离：", dis) print("最短路径：", road) if __name__ == '__main__': map()
java实现：
PriorityQueue：
package com; //优先队列 public class PriorityQueue { private int size;//元素个数 private int capacity;//容量 private Entry[]arr;//保存元素 private int[]pos;//同步根据index和位置的对应关系 public PriorityQueue(int capacity) { this.capacity=capacity; arr=new Entry[capacity+1]; pos=new int[capacity+1]; } //添加一个节点 public void offer(int index,int dis) { if(size==0) { arr[++size]=new Entry(index,dis); pos[index]=size; }else { arr[++size]=new Entry(index,dis); pos[index]=size; int j=size; for(int i=j/2;i>0;j=i,i/=2) {//上滤 if(arr[j].dis<arr[i].dis) { Entry p=arr[i]; arr[i]=arr[j]; arr[j]=p; pos[arr[i].index]=i; pos[arr[j].index]=j; } } } } public int peek() {//获取头部元素 return arr[1].index; } //删除头部元素 public int poll() { Entry temp=arr[size]; int res=arr[1].index; --size; int j=1; int i=j*2; while(i<=size) {//下滤 if(i+1<=size&&arr[i+1].dis<arr[i].dis) { ++i; } if(arr[i].dis<temp.dis) { arr[j]=arr[i]; pos[arr[j].index]=j; j=i; i*=2; }else { break; } } arr[j]=temp; pos[arr[j].index]=j; return res; } //更新操作 public void increase(int index,int inc) { Entry temp=null; int i; // for(i=1;i<=size;++i) { // if(index==arr[i].index) { // temp=arr[i]; // break; // } // } i=pos[index]; temp=arr[i]; temp.dis+=inc; if(inc>0) {//下滤 int j=i; i*=2; while(i<=size) { if(i+1<=size&&arr[i+1].dis<arr[i].dis) { ++i; } if(arr[i].dis<temp.dis) { arr[j]=arr[i]; pos[arr[j].index]=j; j=i; i*=2; }else { break; } } arr[j]=temp; pos[arr[j].index]=j; }else {//上滤 int j; for(j=i,i/=2;i>0;j=i,i/=2) { if(temp.dis<arr[i].dis) { arr[j]=arr[i]; pos[arr[j].index]=j; }else { break; } } arr[j]=temp; pos[arr[j].index]=j; } } //优先队列中的节点类 public static class Entry{ int index; int dis; public Entry(int index,int dis) { this.index=index; this.dis=dis; } public int getIndex() { return index; } } public static void main(String[]args) { PriorityQueue pq=new PriorityQueue(20); pq.offer(1, 1); pq.offer(2, 2); pq.offer(3, 2); pq.increase(3, 1); pq.poll(); } }
Graph：
package com; import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; import java.util.List; //图，使用邻接表存储 public class Graph { private int n; //the number of nodes public static final int INF=Integer.MAX_VALUE; List<List<Node>> table;//邻接表 public Graph(int n) { this.n=n; table=new ArrayList<List<Node>>(n+1);// the index 0 does not use; for(int i=0;i<n+1;++i) { table.add(new LinkedList<Node>()); } } //添加边 public void addEdge(int u,int v,int weight) {//u->v table.get(u).add(new Node(v,weight)); } //朴素的实现 public List<int[]>dijkstra1(int s){ int[]dis=new int[n+1]; int[]path=new int[n+1]; boolean[]mark=new boolean[n+1]; Arrays.fill(dis, INF); dis[s]=0; path[s]=0; for(int i=1;i<n;++i) { for(Node temp:table.get(s)) { if(dis[s]+temp.weight<dis[temp.index]) { dis[temp.index]=dis[s]+temp.weight; path[temp.index]=s; } } mark[s]=true; int minDis=INF,index=0; for(int j=1;j<=n;++j) { if(!mark[j]&&dis[j]<minDis) { minDis=dis[j]; index=j; } } s=index; } ArrayList<int[]>res=new ArrayList<int[]>(2); res.add(path); res.add(dis); return res; } //采用优先队列优化 public List<int[]>dijkstra2(int s){ int[]path=new int[n+1]; int[]dis=new int[n+1]; boolean[]mark=new boolean[n+1];//记录访问过的节点 Arrays.fill(dis, INF); dis[s]=0; path[s]=0; PriorityQueue pq=new PriorityQueue(n); for(int i=1;i<n;++i) { for(Node temp:table.get(s)) { if(!mark[temp.index]&&dis[s]+temp.weight<dis[temp.index]) { if(dis[temp.index]==INF) { dis[temp.index]=dis[s]+temp.weight; pq.offer(temp.index, dis[temp.index]); }else { pq.increase(temp.index, dis[s]+temp.weight-dis[temp.index]); dis[temp.index]=dis[s]+temp.weight; } path[temp.index]=s; } } mark[s]=true; s=pq.poll(); } ArrayList<int[]>res=new ArrayList<int[]>(2); res.add(path); res.add(dis); return res; } //递归获取路径信息 private List<Integer>getPath(int[]path,int s,int cnt) { if(cnt==s) { List<Integer>lt=new LinkedList<Integer>(); lt.add(s); return lt; } List<Integer>lt=getPath(path,s,path[cnt]); lt.add(cnt); return lt; } //打印路径信息 public void printPath(List<int[]>info,int s) { List<List<Integer>> pathInfo=new LinkedList<List<Integer>>(); for(int i=1;i<info.get(0).length;++i) { List<Integer>paths=getPath(info.get(0),s,i); int sz=paths.size(); System.out.print(paths.get(0)); for(int j=1;j<sz;++j) { System.out.print("->"+paths.get(j)); } System.out.println(" 距离："+info.get(1)[i]); } } //图的节点类 private static class Node{ int weight; int index; public Node(int index,int weight) { this.index=index; this.weight=weight; } } }
StartUp：
package com; import java.io.FileNotFoundException; import java.io.FileReader; import java.util.List; import java.util.Scanner; //启动类，程序的入口 public class StartUp { public static void start() { try { Scanner scan=new Scanner(new FileReader("in.txt")); int t=scan.nextInt();//测试用例的数目 for(int i=0;i<t;++i) { int n=scan.nextInt();//节点数目 int m=scan.nextInt();//边的数目 int s=scan.nextInt(); Graph g=new Graph(n); for(int j=0;j<m;++j) { int u=scan.nextInt(); int v=scan.nextInt(); int w=scan.nextInt(); g.addEdge(u, v, w); } List<int[]>res=g.dijkstra2(s); g.printPath(res, s); } } catch (FileNotFoundException e) { e.printStackTrace(); } } public static void main(String[]args) { start(); } }
输入：
2 5 8 1 1 2 2 1 3 5 1 4 6 2 3 1 2 4 3 2 5 5 3 5 1 4 5 2 7 12 1 1 2 2 1 4 1 2 4 3 2 5 10 3 1 4 3 6 5 4 3 2 4 6 8 4 7 4 4 5 2 5 7 6 7 6 1
输出：
1 距离：0 1->2 距离：2 1->2->3 距离：3 1->2->4 距离：5 1->2->3->5 距离：4 1 距离：0 1->2 距离：2 1->4->3 距离：3 1->4 距离：1 1->4->5 距离：3 1->4->7->6 距离：6 1->4->7 距离：5