最短路径和
最短路径是指两点之间权值之和最小的路径之和，广泛应用于路径规划问题，有向图、无向图均适用，但不能有负权环：
上图C - D - F之间构成了负权环，A 到 F之间的最短路径A -> C -> D -> F -> C -> D -> F…可以无限缩短，即不存在最短路径。
单源最短路径最经典的实现有Dijkstra、Bellman-Ford两种算法。
Dijkstra算法实现
使用前提：单源最短路径，不能有负权边
算法原理：按路径长度递增的次序依次产生最短路径
时间复杂度：O(ElogV)
以下图为例，求A到个点的最短路径：
举一个贴近生活的例子：将连在一起的一堆石头以某一个为源点向上顺势拧起，直至石头全被提起。Dijkstra算法实现原理和拧石头类似，后离开桌面的石头一定是被先离开桌面的石头提起的，并且当可能被多条绳子提起时，只有最短那根绳子才能将其提起。
算法模拟
Dijkstra算法实现过程；
黑色：源点
红色：当前正在被更新最短路径的点
紫色：求出最短路径的点
首先，A到A的最短路径为0，将A提起，下一步有可能被提起的点是与A直接相连的点，所以对A的所有出度的边进行松弛操作，即更新B D E的最短路径：
扫描路径和列，路径和最小的即是下一个被提起的点，求出了该点 （B点) 的最短路径。下一个有可能被提起的点必然是与A、C直接相连的点，对B的所有出度进行松弛操作，更新与B直接相连的点C的最短路径：
同样扫描路径和列（标位紫色的是已经求出最短路径的点，不再扫描)，找出这轮最短路径点D点，更新与D相连的点E、C的最短路径：
同样扫描，找出这轮的最短路径是C点，更新与C直接相连的E点的最短路径：
再次扫描，只有E点一点，找出E点最短路径，到此求出了所有点的最短路径：
封装
封装边：
private static class Edge<V, E>{
E weight;
Vertex<V, E> from; //源顶点
Vertex<V, E> to; //目的顶点
Edge(Vertex<V, E> from, Vertex<V, E> to){
this.from = from;
this.to = to;
}
Edge(Vertex<V, E> from, Vertex<V, E> to, E weight){
this(from, to);
this.weight = weight;
}
//！！！边集用Set、顶点集Map存储 底层都是hash表+链表+红黑树 必须在Edge、Vertex类里实现各自的HashCode和equals方法
@Override
public boolean equals(Object obj) {
Edge<V, E> edge = (Edge<V, E>)obj;
//如果两条边源顶点和目的顶点都相同则视为同一条边
return Objects.equals(this.from, edge.from) && Objects.equals(this.to, edge.to);
}
@Override
public int hashCode() {
return from.hashCode() * 31 + to.hashCode();
}
}
封装顶点：
private static class Vertex<V, E>{
V value;
Set<Edge<V, E>> inEdges = new HashSet<>();
Set<Edge<V, E>> outEdges = new HashSet<>();
Vertex(V value){
this.value = value;
}
@Override
public boolean equals(Object obj) {
return Objects.equals(value, ((Vertex<V, E>)obj).value);
}
@Override
public int hashCode() {
return value == null ? 0 : value.hashCode();
}
}
封装路径信息：
public static class PathInfo<V, E>{
private E weight;
private List<Edge<V, E>> path = new LinkedList<>(); //用链表存储路径
public String getPathInfo() {
StringBuilder s = new StringBuilder();
for (Edge<V, E> edge : path) {
s = s.append(edge.from.value +"-->" + edge.to.value + " ");
}
return s.toString();
}
public E getWeight() {
return weight;
}
}
用HashSet集合存储边信息，用HashMap集合存储顶点信息，key为封装顶点的值，value为封装顶点对象：
private Map<V, Vertex<V, E>> vertices = new HashMap<>(); //顶点集
private Set<Edge<V, E>> edges = new HashSet<>(); //边集
定义权重管理器接口；实现自定义权重的加法：
public interface WeightManager<E>{
E add(E w1, E w2);
}
定义边添加接口addEdge() ：
/**
* @param from 源顶点的value值
* @param to 目的顶点的value值
* @param weight 权重
*/
public void addEdge(V from, V to, E weight) { };
定义求最短路径diikstra接口：
/**
* 求最短路径
* @param origin 起点
* @param weightManager 权重累加器
* @param comparator 权重比较器
* @return 起点到各个点的最短路径
*/
private Map<V, PathInfo<V, E>> dijkstra(V origin,WeightManager<E> weightManager, Comparator<E> comparator){
利用JDK的比较器实现自定义权重比较：
private int compare(E e1, E e2) { //默认要求 E 是具有可比较性的
if(comparator != null) { //有比较器
return comparator.compare(e1, e2);
}
return ((Comparable<E>)e1).compareTo(e2); //外部自定义对象内部默认实现
}
具体细节参考代码注解：
代码
Bellman-Ford算法实现
使用前提：单源最短路径，可以有负权边，能检测出负权环
算法原理：对所有的边进行 V-1 次（V-节点数量）松弛操作即可求得到所有点的最短路径
时间复杂度：O(EV)
算法模拟
仍以下图举例：
假设按 DC BC AD CE AE DE AB 的顺序对上图所有边进行V-1次松弛操作：
红色 ： 一轮松弛后更新最短路径的结果
绿色 ：这轮松弛不需要更新最短路径
第一轮松弛：
第二轮松弛：
第三轮松弛：
第三轮松弛后已经求出了到所有点的最短路径，在进行第四轮松弛也是同样的结果，也就是说可能提前求出最短路径。
代码
Bellman-Ford算法代码是基于求Dijkstra算法时搭建的框架上实现的，具体细节见代码注解
Floyd算法实现
使用前提：多源最短路径，可以有负权边
算法原理：求顶点 i，j 的最短路径dist( i, j )，引入中间节点k，如果dist( i, k ) + dist( k, j ) < dist( i, j ) 则更新最短路径，再枚举i, j, k所有可能的位置
时间复杂度：O(V^3)
仍使用下图为例：
具体细节见代码注解
代码
Floyd算法代码实现
public class ShortestPath<V, E> {
private Map<V, Vertex<V, E>> vertices = new HashMap<>(); //顶点集
private Set<Edge<V, E>> edges = new HashSet<>(); //边集
private Comparator<E> comparator;
public void addEdge(V from, V to) {
addEdge(from, to, null);
}
/**
* @param from 源顶点的value值
* @param to 目的顶点的value值
* @param weight 权重
*/
public void addEdge(V from, V to, E weight) {
//拿到源顶点-判断源顶点是否已经存在
Vertex<V, E> fromVertex = vertices.get(from);
if(fromVertex == null) {
fromVertex = new Vertex<>(from);
vertices.put(from, fromVertex);
}
//拿到目的顶点-判断目的顶点是否已经存在
Vertex<V, E> toVertex = vertices.get(to);
if(toVertex == null) {
toVertex = new Vertex<>(to);
vertices.put(to, toVertex);
}
//判断要添加的边是否存在
//如果有边存在则删除,之后统一重新添加
Edge<V, E> edge = new Edge<>(fromVertex, toVertex, weight);
if(fromVertex.outEdges.remove(edge)) {
toVertex.inEdges.remove(edge);
edges.remove(edge);
}
fromVertex.outEdges.add(edge);
toVertex.inEdges.add(edge);
edges.add(edge);
}
/**
* 求多源最短路径
* @return 任意两对节点之间的最短路径
*/
public Map<V, Map<V, PathInfo<V, E>>> shortestPaths(WeightManager<E> weightManager){
return shortestPaths(weightManager, null);
}
public Map<V, Map<V, PathInfo<V, E>>> shortestPaths(WeightManager<E> weightManager, Comparator<E> comparator){
return floyd(weightManager, comparator);
}
private Map<V, Map<V, PathInfo<V, E>>> floyd(WeightManager<E> weightManager, Comparator<E> comparator){
this.comparator = comparator;
Map<V, Map<V, PathInfo<V, E>>> paths = new HashMap<>();
//初始化paths-将所有可行的边加到paths中
for (Edge<V, E> edge : edges) {
Map<V, PathInfo<V, E>> map = paths.get(edge.from.value);
if(map == null) {
map = new HashMap<>();
paths.put(edge.from.value, map);
}
PathInfo<V, E> pathInfo = new PathInfo<>();
pathInfo.weight = edge.weight;
pathInfo.path.add(edge);
map.put(edge.to.value, pathInfo);
}
//三重for循环遍历所有顶点-枚举任意一对顶点之间的最短路径
vertices.forEach((V v2, Vertex<V, E> vertex2)->{
vertices.forEach((V v1, Vertex<V, E> vertex1)->{
vertices.forEach((V v3, Vertex<V, E> vertex3)->{
if(v1.equals(v2) || v2.equals(v3) || v1.equals(v3)) return; //排掉自己和自己找最短路径的情况
//取出v1到v2的最短路径信息
if(paths.get(v1) == null) return; //不存在最短路径
PathInfo<V, E> pathInfo12 = paths.get(v1).get(v2);
if(pathInfo12 == null) return; //不存在最短路径
//取出v2到v3的最短路径信息
if(paths.get(v2) == null) return;
PathInfo<V, E> pathInfo23 = paths.get(v2).get(v3);
if(pathInfo23 == null) return;
//取出v1到v3的最短路径信息
if(paths.get(v1) == null) return;
PathInfo<V, E> pathInfo13 = paths.get(v1).get(v3);
E oldWeight = pathInfo13 == null ? null : pathInfo13.weight;
E newWeight = weightManager.add(pathInfo12.weight, pathInfo23.weight);
if(oldWeight == null || compare(newWeight, oldWeight) < 0) {
PathInfo<V, E> pathInfo = new PathInfo<>();
pathInfo.weight = newWeight;
pathInfo.path.addAll(pathInfo12.path);
pathInfo.path.addAll(pathInfo23.path);
paths.get(v1).put(v3, pathInfo);
}
});
});
});
return paths;
}
private int compare(E e1, E e2) { //默认要求 E 是具有可比较性的
if(comparator != null) { //有比较器
return comparator.compare(e1, e2);
}
return ((Comparable<E>)e1).compareTo(e2); //外部自定义对象内部默认实现
}
//定义权重管理器
public interface WeightManager<E>{
E add(E w1, E w2);
E zero();
}
//封装顶点
private static class Vertex<V, E>{
V value;
Set<Edge<V, E>> inEdges = new HashSet<>();
Set<Edge<V, E>> outEdges = new HashSet<>();
Vertex(V value){
this.value = value;
}
@Override
public boolean equals(Object obj) {
return Objects.equals(value, ((Vertex<V, E>)obj).value);
}
@Override
public int hashCode() {
return value == null ? 0 : value.hashCode();
}
}
//封装边
private static class Edge<V, E>{
E weight;
Vertex<V, E> from; //源顶点
Vertex<V, E> to; //目的顶点
Edge(Vertex<V, E> from, Vertex<V, E> to){
this.from = from;
this.to = to;
}
Edge(Vertex<V, E> from, Vertex<V, E> to, E weight){
this(from, to);
this.weight = weight;
}
//！！！边集用Set、顶点集Map存储 底层都是hash表+链表+红黑树 必须在Edge、Vertex类里实现各自的HashCode和equals方法
@Override
public boolean equals(Object obj) {
Edge<V, E> edge = (Edge<V, E>)obj;
//如果两条边源顶点和目的顶点都相同则视为同一条边
return Objects.equals(this.from, edge.from) && Objects.equals(this.to, edge.to);
}
@Override
public int hashCode() {
return from.hashCode() * 31 + to.hashCode();
}
}
//封装路径信息
public static class PathInfo<V, E>{
private E weight;
private List<Edge<V, E>> path = new LinkedList<>(); //用链表存储路径
public String getPathInfo() {
StringBuilder s = new StringBuilder();
for (Edge<V, E> edge : path) {
s = s.append(edge.from.value +"-->" + edge.to.value + " ");
}
return s.toString();
}
public E getWeight() {
return weight;
}
}
}
测试：
public class Test {
public static void main(String[] args) {
ShortestPath<String, Integer> s = new ShortestPath<>();
s.addEdge("A", "E", 100); //添加边时发现顶点不存在自动创建顶点
s.addEdge("A", "D", 30);
s.addEdge("A", "B", 10);
s.addEdge("B", "C", 50);
s.addEdge("D", "C", 20);
s.addEdge("C", "E", 10);
s.addEdge("D", "E", 60);
//Test for Floyd
Map<String, Map<String, PathInfo<String, Integer>>> result = s.shortestPaths(new WeightManager<Integer>(){
@Override
public Integer add(Integer w1, Integer w2) {
return w1 + w2;
}
@Override
public Integer zero() {
return 0;
}
});
result.forEach((String key, Map<String, PathInfo<String, Integer>> value)->{
value.forEach((String key2, PathInfo<String, Integer> value2)->{
System.out.println(key+"->"+key2+" minPath: "+value2.getPathInfo()+" "+value2.getWeight());
});
});
}
}
测试结果
自此，通用最短路径实现完成，单源、多源皆可使用，基本数据类型，自定义数据类型皆可使用
475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
