最短路径算法

一、弗洛伊德（Floyd）算法

可以求出所有点之间的最短路径

public final int INFILITY=1000;// 无穷远
public  final int N=35;// N是图中顶点的个数
public  int[][] distance=new int

;
public  int[][] path=new int

;
// distance是邻接矩阵
// path[i][j]表示i到j的最短路径上j的前驱结点

// 初始化path矩阵
int i,j,k;
for(i=0;i<N;++i){
for(j=0;j<N;++j)
path[i][j]=i;//
}
// Floyd算法
for (k = 0; k < N; ++k)
for (i = 0; i < N; ++i)
for (j = 0; j < N; ++j)
if(distance[i][j]>distance[i][k]+distance[k][j]){
// 有更短的路径
distance[i][j]=distance[i][k]+distance[k][j];
path[i][j]=path[k][j];
}

需要注意，在初始化path矩阵的时候，

1.如果将path初始化为j

path[i][j]=j;

则在Floyd算法中更新path的时候要这样更新：

path[i][j]=path[i][k];

2.如果这样初始化path

path[i][j]=i;

则需要这样更新：

path[i][j]=path[k][j];

二、迪杰斯特拉（Dijkstra）算法

求某个点到其它结点的最短路径

public static class Graph{
public String[] vertexs;// 顶点数组
public int[][] edges;// 邻接矩阵
public int vertexNum,edgeNum;// 顶点和边的数目
}

public static int INFILITY = 1000;// 无穷远
public int[] path = new int[vertexNum];// 起点到其他结点的最短路径上的前驱结点
public int[] dis = new int[vertexNum];// 起点到其他结点的最短距离

public void dijkstra(int start) {

boolean[] visited = new boolean[vertexNum];

int i, j, k, minDis, minIdx = 0;
// 初始化
for (i = 0; i < vertexNum; ++i) {
dis[i] = edges[start][i];// dis初始为权值
path[i] = 0;// path初始为0
}
// 主循环，执行N-1次
for (k = 1; k < vertexNum; ++k) {
minDis = INFILITY;
// 找与起点最近的没找到最短路径的结点
for (j = 0; j < vertexNum; ++j) {
if (!visited[j] && dis[j] < minDis) {
minDis = dis[j];
minIdx = j;
}
}
visited[minIdx] = true;// 找到了一个最近邻居
// 遍历所有未找到最短路径的结点，更新最短路径
for (j = 0; j < vertexNum; ++j) {
// 如果从起点到j的当前距离大于从起点经过minIdx到j的距离，那么最短路径应当经过minIdx
if (!visited[j] && (dis[j] > minDis + edges[minIdx][j])) {
dis[j] = minDis + edges[minIdx][j];
path[j] = minIdx;
}
}
}
}