数据结构 JAVA描述（八） 最短路径+拓扑排序+关键路径

最短路径

迪杰斯特拉算法

原文分析思路（理解不了这里就pass掉）：在有向网中，从某一源点到其余各点都有一条最短路径。首先在这些最短路径中，长度最短的必定只有一条弧，且它的权值是从源点出发的所有弧上权的最小值；其次，第二条长度次短的最短路径只可能有两种情况：

从源点出发的一条弧，权值大于已求的最短路径的那条弧，但小于其他的从源点出发的弧的权值

是一条经过已求得最短路径的路径

该算法需要引入辅助数组D，每个分量D[i]存放当前所找到的从源点到各个终点vi的最短路径的长度。过程是：

(1)令S = ｛v｝，其中v为源点，并设定D[i] 的初始值为：D[i] = |v，vi|

(2)选择顶点vj使得：D[j] = min｛D[i]｝（i∈V-S），并将vj并入到S中

(3)对集合V-S的所有顶点vk，若D[j] + |vj，vk| < D[k]，则修改D[k]的值

(4)重复(2)、(3)的操作共n-1次，由此求得的所有最短路径是按路径长度递增的序列

ShortestPath_DIJ

package Graph;

/**
* @description 求最短路径的问题 迪杰斯特拉  算法
*              (1)令S = ｛v｝，其中v为源点，并设定D[i] 的初始值为：D[i] = |v，vi|
*              (2)选择顶点vj使得：D[j] = min｛D[i]｝（i∈V-S），并将vj并入到S中
*              (3)对集合V-S的所有顶点vk，若D[j] + |vj，vk| < D[k]，则修改D[k]的值
*              (4)重复(2)、(3)的操作共n-1次，由此求得的所有最短路径是按路径长度递增的序列
* @date  2015年12月31日
*/
public class ShortestPath_DIJ {
// v0到其余顶点的最短路径，若p[v][w]为true，则w是从v0到v当前求得最短路径上的顶点
private boolean[][] P;

// v0到其余顶点的最小带权长度 （是变化的，一旦发现更小的，就重新赋值，到最后就是最短路径长度了）
private int[] D;

private final static int INFINITY = Integer.MAX_VALUE;

public boolean[][] getP() {
return P;
}

public int[] getD() {
return D;
}

/**
* @description 用迪杰斯特拉算法求有向网的v0到其余顶点的最短路径p[v]及其权值D[v]
* @date  2015年12月31日
*/
public void DIJ(MGraph G, int v0){
int vexNum = G.getVexNum(); // 顶点数
this.P = new boolean[vexNum][vexNum];
this.D = new int[vexNum];
//finish[v]为true当且仅当v属于S，即已经求得从v0到v的最短路径
boolean[] finish = new boolean[vexNum];

//初始化所有数据
for(int v = 0; v < vexNum; v++){
finish[v] = false;
D[v] = G.getArcs()[v0][v];
for(int w = 0; w < vexNum; w++){
P[v][w] = false;
}
if(D[v] < INFINITY){
P[v][v0] = true;
P[v][v] = true;
}
}

D[v0] = 0; //从v0开始，并入S集
finish[v0] = true;

int v = -1 ; // 这里的赋值没有什么实际意义，只是为了保证编译正确
//开始主循环，每次求得v0到某个v顶点的最短路径，并将v加入到S集.循环n-1次
for(int i = 1; i < vexNum; i++){
int min = INFINITY; //当前所知离v0最近的距离
for(int w = 0; w < vexNum; w++){
if( !finish[w]){
if(D[w] < min){
v = w;
min = D[w];
}
}
}
finish[v] = true; //离v0最近的v并入S

//更新当前最短路径和距离
for(int w = 0; w < vexNum; w++){
if( !finish[w] && G.getArcs()[v][w] < INFINITY && (min + G.getArcs()[v][w] < D[w])){
D[w] = min + G.getArcs()[v][w];
//下面两句这么理解，现在路径是v0-v-w，所以经过了v点，那么v0到v的最小路径自然要给w，同时再加上w点（P[W][W] = true）
System.arraycopy(P[v], 0, P[w], 0, P[v].length);
P[w][w] = true;
}
}

}
}

// 测试
public static void main(String[] args) throws Exception {
Object[] vexs = { "v0", "v1", "v2", "v3", "v4", "v5" };
int[][] arcs = { { INFINITY, INFINITY, 10, INFINITY, 30, 100 },
{ INFINITY, INFINITY, 5, INFINITY, INFINITY, INFINITY },
{ INFINITY, INFINITY, INFINITY, 50, INFINITY, INFINITY },
{ INFINITY, INFINITY, INFINITY, INFINITY, INFINITY, 10 },
{ INFINITY, INFINITY, INFINITY, 20, INFINITY, 60 },
{ INFINITY, INFINITY, INFINITY, INFINITY, INFINITY, INFINITY } };
MGraph G = new MGraph(GraphKind.DG, 6, 8, vexs, arcs);
ShortestPath_DIJ dij = new ShortestPath_DIJ();
dij.DIJ(G, 0);

for(int i = 0; i < vexs.length; i++){
System.out.println("从v0出发，到" + G.getVex(i) + "的最短路径长度是：" + (dij.getD()[i] == INFINITY ? "∞" : dij.getD()[i]) );
System.out.print("经过结点有：");
for(int j = 0; j < vexs.length; j++){
if(dij.getP()[i][j]) //即从v0到i位置的顶点经过了j位置的顶点
System.out.print(G.getVex(j) + " ");
}
System.out.println();
}
}

}

测试分析图

从源点v0到各个终点的D值和最短路径的求解过程：

终点	1	2	3	4	5
v1	∞	∞	∞	∞	∞无
v2	10(v0,v2)
v3	∞	60(v0,v2,v3)	50(v0,v4,v3)
v4	30(v0,v4)	30(v0,v4)
v5	100(v0,v5)	100(v0,v5)	90(v0,v4,v5)	60(v0,v4,v3,v5)
vj	v2	v4	v3	v5
S	{v0,v2}	{v0,v2,v4}	{v0,v2,v3,v4}	{v0,v2,v3,v4,v5}

弗洛伊德算法

基本思想是：求得一个n阶方阵序列：｛D(-¹),D(º)，D(¹) …… D（n-1）｝，其中D(-¹)[i][j]表示从vi出发，不经过其他顶点直接到达vj的路径长度，D（k）则表示从vi到vj的中间只可能经过v0，v1……，vk，而不可能经过v k+1，v k+2等顶点的最短路径长度。

ShortestPath_FLOYD

package Graph;

/**
* @description 求最短路径的问题 弗洛伊德  算法   注意其成员变量的含义和迪杰斯特拉算法的完全不一样
* @date  2015年12月31日
*/
public class ShortestPath_FLOYD {
//顶点v和w之间的最短路径P[v][w],若P[v][w][u]为true，则u是从v到w当前求得最短路径上的顶点
private boolean[][][] P;

//顶点v和w之间的最短路径的带权长度D[v][w]
private int[][] D;

public final static int INFINITY = Integer.MAX_VALUE;

public boolean[][][] getP() {
return P;
}

public int[][] getD() {
return D;
}

public void FLOYD(MGraph G){
int vexNum = G.getVexNum();
this.P = new boolean[vexNum][vexNum][vexNum];
this.D = new int[vexNum][vexNum];

//初始化所有数据
for(int v = 0; v < vexNum; v++){
for(int w = 0; w < vexNum; w++){
D[v][w] = G.getArcs()[v][w];
for(int u = 0; u < vexNum; u++)
P[v][w][u] = false;

if(D[v][w] < INFINITY) {  //从v到w有直接路径
P[v][w][v] = true;
P[v][w][w] = true;
}
}
}

for(int u = 0; u < vexNum; u++)
for(int v = 0; v < vexNum; v++)
for(int w = 1; w < vexNum; w++)
if(D[v][u] < INFINITY && D[u][w] < INFINITY && D[v][u] + D[u][w] < D[v][w]){
D[v][w] = D[v][u] + D[u][w];
for(int i = 0; i< vexNum; i++)
P[v][w][i] = P[v][u][i] || P[u][w][i];
}
}

public static void main(String[] args) throws Exception {
Object[] vexs = { "A", "B", "C", "D"};
int[][] arcs = { { 0, 15, 3, INFINITY},
{ 10, 0, 2, INFINITY},
{ INFINITY, INFINITY, 0, 2},
{ INFINITY, 8, 4, 0} };
MGraph G = new MGraph(GraphKind.DG, 4, 7, vexs, arcs);
ShortestPath_FLOYD floyd = new ShortestPath_FLOYD();
floyd.FLOYD(G);

for(int i = 0; i < vexs.length; i++){
System.out.println("从" + G.getVex(i) + "出发：");
for(int j = 0; j < vexs.length; j++){
System.out.println("到" + G.getVex(j) + "的最短路径长度是：" + (floyd.getD()[i][j] == INFINITY ? "∞" : floyd.getD()[i][j]) );
System.out.print("经过结点有：");
for(int k = 0; k < vexs.length; k++){
if(floyd.getP()[i][j][k])  //即从vi到vj经过了k位置的顶点
System.out.print(G.getVex(k) + " ");
}
System.out.println();
}
}
}

}

测试分析图

弗洛伊德算法求各点间最短路径长度过程

拓扑排序

判断有向网中是否存在有向环的一个办法是：针对AOV（活动顶点图，Activity On Vertex Network）网进行拓扑排序

在AOV网中选择一个没有前驱的结点并输出

从AOV网中删除该结点以及从它出发的弧

重复以上过程，直至AOV网为空，或者剩余子图中不存在没有前驱的顶点（说明该AOV网中存在有向环）

Topological

package Graph;

import Stack.LinkStack;

/**
* @Description 拓扑排序算法
* @author liuquan
* @time 2016年1月1日 下午3:58:13
*/
public class Topological {

/**
* @description 求各个顶点入度的算法
* @param G
* @return
* @throws Exception
* @time 2016年1月1日 下午4:02:49
*/
public static int[] findInDegree(ALGraph G) throws Exception{
int[] indegree  = new int[G.getVexNum()];
for(int i = 0; i < G.getVexNum(); i++)
for(ArcNode arc = G.getVexs()[i].getFirstArc(); arc != null; arc = arc.getNextArc())
++ indegree[arc.getAdjVex()]; //入度增1

return indegree;
}

/**
* @description 若G无回路，则输出G的顶点的一个拓扑排序序列并返回true
* @param G
* @return
* @throws Exception
* @time 2016年1月1日 下午4:13:04
*/
public static boolean topologicalSort(ALGraph G) throws Exception{
int count = 0; //输出顶点计数
int[] indegree = findInDegree(G); //求各个顶点的入度
LinkStack S = new LinkStack();  //零入度的 顶点栈
for(int i = 0; i < G.getVexNum(); i++)
if(indegree[i] == 0)
S.push(i);  //入度为0的进栈
while( !S.isEmpty()){
int i = (Integer) S.pop();
System.out.print(G.getVex(i) + " "); //输出v号顶点并计数
++count;
for(ArcNode arc = G.getVexs()[i].getFirstArc(); arc != null; arc = arc.getNextArc()){
int k = arc.getAdjVex();
if(--indegree[k] == 0) // 对k号顶点的每个邻接点的入度减1
S.push(k);
}
}
if(count < G.getVexNum())
return false;  //该有向图有回路
else
return true;
}

// 测试
public static void main(String[] args) throws Exception {
ArcNode ab = new ArcNode(1);
VNode A = new VNode("A", ab);

ArcNode bc = new ArcNode(2);
ArcNode be = new ArcNode(4, 0, bc);
VNode B = new VNode("B", be);

ArcNode cd = new ArcNode(3);
VNode C = new VNode("C", cd);

VNode D = new VNode("D");

ArcNode ed = new ArcNode(3);
VNode E = new VNode("E", ed);

ArcNode fa = new ArcNode(0);
ArcNode fb = new ArcNode(1, 0, fa);
ArcNode fe = new ArcNode(4, 0, fb);
VNode F = new VNode("F", fb);

VNode[] vexs = {A, B, C, D, E, F};
ALGraph G = new ALGraph(GraphKind.DG, 6, 8, vexs);
System.out.println(topologicalSort(G));
}
}

测试分析图：

关键路径：

以弧表示活动，弧上的权值表示进行该项活动所需的时间，以顶点表示“事件”，称这种有向图为活动网，简称AOE（Activity On Edge）。

从源点v0出发，令ve0=0，按拓扑排序序列，求其余各顶点的ve(j)=max{ve(i) + |i，j|}，i,j∈T,T是所有以第j个顶点为头的弧的集合

从汇点vn-1出发，令vl（n-1） = ve（n-1），按逆拓扑排序求其余顶点允许的最迟开始时间为：vl（i）= min{vl（j）-|i，j|}，i，j∈S，S是所有以第j个顶点为尾的弧的集合

求每一项活动ai的最早开始时间e（i）=ve（j）和最迟开始时间l（i）=vl（j）-|i，j|。若满足e（i）=l（i），则它是关键路径。

测试分析图：

事件	ve	vl
v0	0	0
v1	6	6
v2	4	6
v3	5	8
v4	7	7
v5	7	10
v6	16	16
v7	14	14
v8	18	18

活动	e	l	l-e
a1	0(ve0)	0(vl1-/v0v1/)	0
a2	0(ve0)	2(vl2-/v0v2/)	2
a3	0(ve0)	3(vl3-/v0v3/)	3
a4	6(ve1)	6(vl4-/v1v4/)	0
a5	4(ve2)	6(vl4-/v2v4/)	2
a6	5(ve3)	8(vl5-/v3v5/)	3
a7	7(ve4)	7(vl6-/v4v6/)	0
a8	7(ve4)	7(vl7-/v4v7/)	0
a9	7(ve5)	10(vl7-/v5v7/)	3
a10	16(ve10)	16(vl8-/v6v8/)	0
a11	14(ve11)	14(vl8-/v7v8/)	0

CriticalPath ：

package Graph;

import Stack.LinkStack;

/**
* @Description AOE网的关键路径
* @time 2016年1月2日 下午10:24:51
*/
public class CriticalPath {

private LinkStack T = new LinkStack(); //拓扑排序的顶点栈
private int[] ve, vl; //各顶点的最早发生时间和最迟发生时间

/**
* @description 求各个顶点入度的算法
* @param G
* @return
* @throws Exception
* @time 2016年1月1日 下午4:02:49
*/
public  int[] findInDegree(ALGraph G) throws Exception{
int[] indegree  = new int[G.getVexNum()];
for(int i = 0; i < G.getVexNum(); i++)
for(ArcNode arc = G.getVexs()[i].getFirstArc(); arc != null; arc = arc.getNextArc())
++ indegree[arc.getAdjVex()]; //入度增1

return indegree;
}

/**
* @description 求各个顶点的最早发生时间ve，若G无回路，用栈T存放一个拓扑排序，且函数返回true
* @param G
* @return
* @throws Exception
* @time 2016年1月1日 下午4:13:04
*/
public  boolean topologicalOrder(ALGraph G) throws Exception{
int count = 0; //输出顶点计数
int[] indegree = findInDegree(G); //求各个顶点的入度
LinkStack S = new LinkStack();  //零入度的 顶点栈
for(int i = 0; i < G.getVexNum(); i++)
if(indegree[i] == 0)
S.push(i);  //入度为0的进栈
this.ve = new int[G.getVexNum()]; //初始化

while( !S.isEmpty()){
int i = (Integer) S.pop();
this.T.push(i); //i号顶点入T栈并计数
++count;
for(ArcNode arc = G.getVexs()[i].getFirstArc(); arc != null; arc = arc.getNextArc()){
int k = arc.getAdjVex();
if(--indegree[k] == 0) // 对k号顶点的每个邻接点的入度减1
S.push(k);
if(ve[i] + arc.getValue() > ve[k])
ve[k] = ve[i] + arc.getValue();
}
}
if(count < G.getVexNum())
return false;  //该有向图有回路
else
return true;
}

/**
* @description 输出G的各项关键活动
* @param G
* @return
* @throws Exception
* @time 2016年1月2日 下午10:53:20
*/
public boolean criticalPath(ALGraph G) throws Exception{
if( !topologicalOrder(G))
return false;
vl = new int[G.getVexNum()];
// 初始化各顶点事件的最迟发生时间
for(int i = 0; i < G.getVexNum(); i++){
vl[i] = ve[G.getVexNum() - 1];
}
while( !T.isEmpty()){ // 按拓扑序列 逆序 求各顶点的vl值
int i = (int) T.pop();
for(ArcNode arc = G.getVexs()[i].getFirstArc(); arc != null; arc = arc.getNextArc()){
int k = arc.getAdjVex();
int value = arc.getValue();
if(vl[k] - value < vl[i])
vl[i] = vl[k] - value;
}
}

for(int i = 0; i < G.getVexNum(); i++){
//求ee，el和关键路径
for(ArcNode arc = G.getVexs()[i].getFirstArc(); arc != null; arc = arc.getNextArc()){
int k = arc.getAdjVex();
int value = arc.getValue();
int ee = ve[i];
int el = vl[k] - value;
System.out.println(G.getVex(i) + "->" + G.getVex(k) + "\t最早开始时间：" + ee + "，最迟开始时间："+ el +"。" + (ee == el ? "YES" : "NO"));
}
}
return true;
}

public static void main(String[] args) throws Exception {
ArcNode v01 = new ArcNode(1, 6);
ArcNode v02 = new ArcNode(2, 4, v01);
ArcNode v03 = new ArcNode(3, 5, v02);
VNode v0 = new VNode("v0", v03);

ArcNode v14 = new ArcNode(4, 1);
VNode v1 = new VNode("v1", v14);

ArcNode v24 = new ArcNode(4, 1);
VNode v2 = new VNode("v2", v24);

ArcNode v35 = new ArcNode(5, 2);
VNode v3 = new VNode("v3", v35);

ArcNode v46 = new ArcNode(6, 9);
ArcNode v47 = new ArcNode(7, 7, v46);
VNode v4 = new VNode("v4", v47);

ArcNode v57 = new ArcNode(7, 4);
VNode v5 = new VNode("v5", v57);

ArcNode v68 = new ArcNode(8, 2);
VNode v6 = new VNode("v6", v68);

ArcNode v78 = new ArcNode(8, 4);
VNode v7 = new VNode("v7", v78);

VNode v8 = new VNode("v8");

VNode[] vexs = {v0, v1, v2, v3, v4, v5, v6, v7, v8};
ALGraph G = new ALGraph(GraphKind.DG, 9, 11, vexs);
new CriticalPath().criticalPath(G);

}

}

需要注意的是：并不是加快任何一个关键路径活动都可以缩短整个工程完成的时间，只有在不改变AOE网的关键路径的前提下，加快包含在关键路径上的活动才可以缩短整个工程的完成时间。