1 加权有向图
加权无向图的边没有方向,一条边会同时出现在该边的两个顶点的邻接表中,为了能够处理含有方向性的图的问题,引入了加权有向图。
1.1 加权有向边的实现
API设计:
类名 | DirectedEdge |
---|---|
构造方法 | public DirectedEdge(int v, int w, double weight):通过顶点v、w以及权重weight构造一个边对象 |
成员方法 | 1. public double weight():获取边的权重值 2.public int from():获取有向边的起点 3.public int to():获取有向边的终点 |
成员变量 | 1.private final int v:起点 2.private final int w:终点 3.private final double weight:当前边的权重 |
代码:
public class DirectedEdge {
private final int v;//起点
private final int w;//终点
private final double weight;//当前边的权重
//通过顶点v、w以及权重weight构造一个边对象
public DirectedEdge(int v, int w, double weight) {
this.v = v;
this.w = w;
this.weight = weight;
}
//获取边的权重值
public double weight(){
return weight;
}
//获取有向边的起点
public int from(){
return v;
}
//获取有向边的终点
public int to(){
return w;
}
}
1.2 加权有向图的实现
在加权无向图的基础上,把加权无向边替换成加权有向边即是加权有向图。
API设计:
类名 | EdgeWeightedDigraph |
---|---|
构造方法 | public EdgeWeightedDigraph(int V):创建一个含有V个顶点的空加权有向图 |
成员方法 | 1.public int V():获取图中顶点的数量 2.public int E():获取图中边的数量 3.public void addEdge(DirectedEdge e):向加权有向图中添加一条边e 4.public Deque adj(int v):获取由顶点v指出的所有边 5.public Deque edges():获取加权有向图的所有边 |
成员变量 | 1.private final int V:记录顶点数量 2.private int E:记录边数量 3.private Deque[] adj:邻接表 |
代码:
public class EdgeWeightedDigraph {
//顶点总数
private final int V;
//边的总数
private int E;
//邻接表
private Deque<DirectedEdge>[] adj;
//创建一个含有V个顶点的空加权有向图
public EdgeWeightedDigraph(int V) {
//初始化顶点数量
this.V = V;
//初始化边的数量
this.E = 0;
//初始化邻接表
this.adj = new Deque[V];
for (int i = 0; i < adj.length; i++) {
adj[i] = new LinkedList<>();
}
}
//获取图中顶点的数量
public int V() {
return V;
}
//获取图中边的数量
public int E() {
return E;
}
//向加权有向图中添加一条边e
public void addEdge(DirectedEdge e) {
//边e是有方向的,所以只需要让e出现在起点的邻接表中即可
int v = e.from();
adj[v].offer(e);
E++;
}
//获取由顶点v指出的所有的边
public Deque<DirectedEdge> adj(int v) {
return adj[v];
}
//获取加权有向图的所有边
public Deque<DirectedEdge> edges() {
//遍历图中的每一个顶点,得到该顶点的邻接表,遍历得到每一条边,添加到队列中返回即可
Deque<DirectedEdge> allEdges = new LinkedList<>();
for (int v=0; v<V; v++){
for (DirectedEdge edge : adj[v]) {
allEdges.offer(edge);
}
}
return allEdges;
}
}
2 最短路径
加权有向图可以应用到实际生活中的很多场景,例如在地图中,找到顶点a与顶点b之间的路径,这条路径可以是距离最短,或者是时间最短,又或者是费用最小等,如果把距离/时间/费用看作成本,问题就转换为找到a和b之间成本最小的路径,即最短路径问题。
2.1 最短路径定义及性质
1 定义
在一副加权有向图中,从顶点s到顶点t的最短路径是指所有从顶点s到顶点t的路径中总权重最小的那条路径。
2 性质
- 路径具有方向性;
- 权重不一定是距离,也可以是时间、费用等内容,最短路径指的是总权重最低;
- 只考虑连通图。如果s和t不可达,它们之间就不存在最短路径,为了简化问题,这里只考虑连通图;
- 最短路径不一定唯一。从一个顶点到另一个顶点的最短路径可能有多条,这里只需找出一条即可;
3 最短路径树
- 给定一幅加权有向图和顶点s,以s为起点的一棵最短路径树是图的一幅子图,它包含起点s以及从s可达的所有顶点;
- 这棵有向树的根结点为s,树的每条路径都是有向图中的一条最短路径;
2.2 松弛技术
松弛这个词来源于生活:一条橡皮筋沿着两个顶点的某条路径紧紧拉开,如果这两个顶点之间的路径不止一条,还有存在更短的路径,那么把皮筋转移到更短的路径上,皮筋就可以放松了,松弛这种简单的原理刚好可以用来计算最短路径树。
边的松弛:
松弛边v->w意味着检查从s到w的最短路径是否是先从s到v,再从v到w:
- 如果是,将v-w这条边加入到最短路径树中,并更新edgeTo和distTo中的内容:edgeTo[w] = v->w,distTo[w] = distTo[v] + v->w的权重;
- 如果不是,忽略v->w;
顶点的松弛:
顶点的松弛是基于边的松弛完成的,只需要把某个顶点指出的所有边松弛,那么该顶点就松弛完毕。例如要松弛顶点v,只需遍历v的邻接表,把每一条边都松弛,那么顶点v就松弛了。
2.3 Dijstra算法思想
算法解析
- 找出权重最小的顶点;
- 对于该顶点的邻居,检查是否有前往它们的最短路径,如果有,就更新其权重(松弛);
- 重复这个过程,直到对图中的每个顶点都这样做了;
算法实现
- 成员变量edgeTo存储起点到当前顶点的最短路径的最后一条边,成员变量distTo存储起点到当前顶点的最短路径的总权重;
- 开始给定图G和起点s,初始化起点s到s的最短路径的总权重distTo[s]=0,起点s到其他顶点的总权重为无穷大;
- 随着算法的执行,不断使用松弛技术处理图的边和顶点,更新edgeTo和distTo中的数据,最终就得到了最短路径树;
2.4 Dijstra算法具体实现
类名 | DijkstraSP |
---|---|
构造方法 | public DijkstraSP(EdgeWeightedDigraph G, int s):根据一幅加权有向图G和顶点s,创建一个计算顶点为s的最短路径树对象 |
成员方法 | 1.private void relax(EdgeWeightedDigraph G, int v):松弛图G中的顶点v 2.public double distTo(int v):获取从起点s到顶点v的最短路径的总权重 3.public boolean hasPathTo(int v):判断从起点s到顶点v是否可达 4.public Deque pathTo(int v):查询从起点s到顶点v的最短路径中所有的边 |
成员变量 | 1.private DirectedEdge[] edgeTo:索引代表顶点,值表示从起点s到当前顶点的最短路径上的最后一条边 2.private double[] distTo:索引代表顶点,值为从起点s到当前顶点的最短路径的总权重 3.private indexMinPriorityQueue pq:存放树中顶点与非树中顶点之间的有效横切边 |
代码:
public class DijkstraSP {
//索引代表顶点,值表示从顶点s到当前顶点的最短路径上的最后一条边
private DirectedEdge[] edgeTo;
//索引代表顶点,值表示从顶点s到当前顶点的最短路径的总权重
private double[] distTo;
//存放树中顶点与非树中顶点之间的有效横切边
private IndexMinPriorityQueue<Double> pq;
//根据一副加权有向图G和起点s,创建一个计算起点为s的最短路径树对象
public DijkstraSP(EdgeWeightedDigraph G, int s){
//初始化edgeTo
this.edgeTo = new DirectedEdge[G.V()];
//创建一个和图的顶点数一样大小的double数组,表示权重,并且初始化数组中的内容为无穷大,无穷大即表示不存在这样的边
this.distTo = new double[G.V()];
for (int i = 0; i < distTo.length; i++) {
distTo[i] = Double.POSITIVE_INFINITY;
}
//创建一个和图的顶点数一样大小的索引最小优先队列,存储有效横切边
this.pq = new IndexMinPriorityQueue<>(G.V());
//默认让顶点s进入树中,但s顶点目前没有与树中其他的顶点相连接,因此初始化distTo[s]=0.0
distTo[s] = 0.0;
//使用顶点s和权重0.0初始化pq
pq.insert(s,0.0);
//遍历pq
while(!pq.isEmpty()){
//松弛图G中的顶点
relax(G, pq.delMin());
}
}
//松弛图G中的顶点v
private void relax(EdgeWeightedDigraph G, int v){
//松弛顶点v就是松弛顶点v邻接表中的每一条边,遍历邻接表
for (DirectedEdge edge : G.adj(v)) {
//获取到该边的终点w
int w = edge.to();
//通过松弛技术,判断从起点s到顶点w的最短路径是否需要先从顶点s到顶点v再由顶点v到顶点w
if (distTo(v) + edge.weight() < distTo(w)){
distTo[w] = distTo[v] + edge.weight();
edgeTo[w] = edge;
//如果顶点w已经存在于索引最小优先队列pq中,则重置顶点w的权重
if (pq.contains(w)){
pq.changeItem(w, distTo(w));
}else{
//如果顶点w没有出现在优先队列pq中,则把顶点w及其权重加入到pq中
pq.insert(w, distTo(w));
}
}
}
}
//获取从顶点s到顶点v的最短路径的总权重
public double distTo(int v){
return distTo[v];
}
//判断从顶点s到顶点v是否可达
public boolean hasPathTo(int v){
return distTo[v]<Double.POSITIVE_INFINITY;
}
//查询从起点s到顶点v的最短路径中所有的边
public Deque<DirectedEdge> pathTo(int v){
//如果顶点s到v不可达,则返回null
if (!hasPathTo(v)){
return null;
}
//创建队列保存最短路径的边
Deque<DirectedEdge> allEdges = new LinkedList<>();
//从顶点v开始,逆向寻找,一直找到顶点s为止,而起点s为最短路径树的根结点,所以edgeTo[s]=null
while (true){
DirectedEdge e = edgeTo[v];
if (e==null){
break;
}
allEdges.offer(e);
v = e.from();
}
return allEdges;
}
}
public class Test {
public static void main(String[] args) {
EdgeWeightedDigraph g = new EdgeWeightedDigraph(8);
DirectedEdge e1 = new DirectedEdge(4,5,0.35); DirectedEdge e2 = new DirectedEdge(4,7,0.37);
DirectedEdge e3 = new DirectedEdge(5,7,0.28); DirectedEdge e4 = new DirectedEdge(5,4,0.35);
DirectedEdge e5 = new DirectedEdge(7,5,0.28); DirectedEdge e6 = new DirectedEdge(5,1,0.32);
DirectedEdge e7 = new DirectedEdge(0,4,0.38); DirectedEdge e8 = new DirectedEdge(0,2,0.26);
DirectedEdge e9 = new DirectedEdge(7,3,0.39); DirectedEdge e10 = new DirectedEdge(1,3,0.29);
DirectedEdge e11 = new DirectedEdge(2,7,0.34); DirectedEdge e12 = new DirectedEdge(6,2,0.40);
DirectedEdge e13 = new DirectedEdge(3,6,0.52); DirectedEdge e14 = new DirectedEdge(6,0,0.58);
DirectedEdge e15 = new DirectedEdge(6,4,0.93);
g.addEdge(e1);g.addEdge(e2);g.addEdge(e3);g.addEdge(e4);
g.addEdge(e5);g.addEdge(e6);g.addEdge(e7);g.addEdge(e8);
g.addEdge(e9);g.addEdge(e10);g.addEdge(e11);g.addEdge(e12);
g.addEdge(e13);g.addEdge(e14);g.addEdge(e15);
//根据图g和顶点0,构建PrimMST对象
DijkstraSP dsp = new DijkstraSP(g, 0);
//获取起点0到顶点6的最短路径
Deque<DirectedEdge> edges = dsp.pathTo(6);
//打印输出
for (DirectedEdge edge : edges) {
System.out.println(edge.from() + "->" + edge.to() + ":" + edge.weight());
}
}
}
3->6:0.52
7->3:0.39
2->7:0.34
0->2:0.26
注:
类IndexMinPriority可在索引最小优先队列的实现_sc179的博客-CSDN博客中找到