contente
Introdução ao algoritmo
O algoritmo de Dijkstra é um típico algoritmo de caminho mais curto , que é usado para calcular o caminho mais curto de um nó para outros nós. Sua principal característica é que se expande do ponto inicial para a camada externa (a ideia de busca em largura) até chegar ao ponto final.
Formulários
Etapa do algoritmo
1) Defina o vértice inicial como v, o conjunto de vértices VfvI, v2, vi.), a distância de v a cada vértice de V constitui o conjunto de distâncias Dis, Dis (dI, d2, di.), Dis set registra v para cada vértice no gráfico A distância de (para si mesmo pode ser considerada como 0, a distância de v para vi corresponde a di)
2) Selecione di com o menor valor de Dis e saia do conjunto Dis, e ao mesmo tempo mova o item correspondente ponto vi no conjunto V, neste momento v para vi Ou seja, o caminho mais curto
3) Atualize o conjunto Dis. A regra de atualização é: compare o valor da distância de v com os vértices no V set, e a distância de v até os vértices no conjunto V através de vi, e mantenha
aquele com o menor valor (o vértice também deve ser atualizado ao mesmo tempo). O nó predecessor de é vi, indicando que ele foi alcançado a vi)
4) Repita os dois passos até que o vértice do caminho mais curto seja o vértice alvo.
Código
import java.util.Arrays;
public class _最短路{
static int[] vis;//标记已经访问的顶点 0未访问 1 访问
static int[] dis;//出发顶点到各个下标对应顶点的最短距离
static int[] pre;//每个下标对应的上一个顶点下标
static char[] vertex;//顶点
static int[][] matrix;//邻接矩阵
public static void main(String[] args) {
vertex= new char[]{'A','B','C','D','E','F','G'};
matrix = new int[vertex.length][vertex.length];
chushihua(matrix);//初始化邻接矩阵
djstl(vertex.length,6);//调用算法
}
public static void djstl(int length,int start) {
vis=new int[length];
dis=new int[length];
pre=new int[length];
Arrays.fill(dis, 9999);//初始化距离为较大值
dis[start] = 0;//初始化出发顶点到自身的距离0
/* 先将起始点到与其连通的顶点的路径及pre前一个顶点进行更新*/
update(start);
//在以与起始点相连的顶点为起点 更新距离和路径
for (int i = 1; i < vertex.length; i++) {
int minIndex = -1;
int mindis=9999;
//找到一个最短路径
for (int j = 0; j < vertex.length; j++) {
if(vis[j]==0 && dis[j] < mindis) {
minIndex = j;
mindis = dis[j];
}
}
vis[minIndex] = 1;
update(minIndex);//继续更新
}
System.out.println(Arrays.toString(dis));
}
/**
* 以index顶点向下查找！！！以起点start到index附近的邻接结点的最短路径!!!
* @param index
*/
public static void update(int index) {
vis[index] = 1;//index标记为已访问
int len= 0;//len：从start顶点到index顶点的距离+上从index再到i顶点的距离
//循环遍历每个邻接结点顶点，找到真正意义上的最短路径
for (int i = 0; i < matrix[index].length; i++) {
//记录从start顶点到index顶点的距离+上从index再到i顶点的距离
len = dis[index] + matrix[index][i];
//将dis[i] 即从start直接到i 的距离 与len进行比较
if(vis[i] == 0 && len < dis[i]) {
dis[i] = len;//更新最短路径
pre[i] = index;//更新前置顶点
}
}
}
/**
* 初始化邻接矩阵
* @param matrix
*/
public static void chushihua(int[][] matrix) {
final int N = 9999;
matrix[0]=new int[]{N,5,7,N,N,N,2};
matrix[1]=new int[]{5,N,N,9,N,N,3};
matrix[2]=new int[]{7,N,N,N,8,N,N};
matrix[3]=new int[]{N,9,N,N,N,4,N};
matrix[4]=new int[]{N,N,8,N,N,5,4};
matrix[5]=new int[]{N,N,N,4,5,N,6};
matrix[6]=new int[]{2,3,N,N,4,6,N};
}
}