Single-source menor problema de caminho
Se o caminho para o outro vértice (ponto final) de um vértice do gráfico (fonte) pode ser mais do que um, como encontrar um caminho de tal modo que a soma dos pesos de cada uma das arestas ao longo deste caminho é minimizado.
algoritmo de Origem de Dijkstra
Dijkstra (Dijkstra) foi apresentado em 1959 pelo cientista da computação holandês Dick Stella, assim chamado Dijkstra algoritmo. O resto é de um vértice para os vértices do algoritmo de caminho mais curto para resolver o problema do caminho mais curto tem o direito de figura. o algoritmo de Dijkstra é as principais características do ponto de partida, usando a estratégia algoritmo guloso, cada nó atravessado adjacente ao ápice do ponto de partida e não o mais próximo visitada até estendida até o ponto final.
idéia específica do algoritmo
matriz auxiliar
① usando um conjunto de caminhos [] a caminho de armazenamento: caminho [a] = b representa o vértice caminho mais curto vértice é um B;
② a distância mais curta uma matriz info [] para armazenar o respectivo vértice no ponto de origem, e esta também tem um efeito marcado da matriz, isto é, informação de [X] = 0, X significa um vértice que tem no caminho.
processo específico
① auxiliar inicialização de matriz, que determinam os pontos de origem (orign)
Estrutura ② na FIG distância mais curta a ser actualizado de cortina auxiliar:
Ⅰ, a um ponto em que pode ser alcançado: Informação [x] = mapa [ orign] [x]; estes pontos e a fonte de pré-conjunto de pontos : caminho [X] = orign
ⅱ, para pontos inacessíveis: info [x] = ∞
③ Localização ponto de informação mínima nos pesos da matriz (excepto 0,0 indica adição) (min), remover o peso mínimo minInfo, os pontos adicionados ao caminho, a informação fornecida [min] = 0, e o vértice de acordo mínimo, auxiliar não matriz vértice adicionado é actualizado:
Se minInfo + mapa [min] [X ] <Informação [x], de modo que a informação [x] = + minInfo mapa [min] [x], e para a frente do vértice do caminho x ponto superior é definida como vértices min
Ps: este passo pode ser armazena minInfo certas um valor correspondente ao tamanho, isto é, o ponto de origem até ao ponto do comprimento do percurso mais curto.
Repetir passos ④ ③, até que todos os vértices vieram para o caminho mais curto, isto é, a informação matriz [] são todos os valores zero
caminho de saída
informações específicas armazenadas na matriz de caminho de percurso []: o caminho mais curto à frente do vértice trajecto da corrente
pode ser feita utilizando as características da pilha em que os dados de saída:
path[] = dijkstra(sMap, 1);
int end = 5;
//借助栈的特性
int stack[] = new int[sMap.num];
int top = 0;
end--; //从零开始
while(end != -1) {
stack[top++] = end;
end = path[end];
}
System.out.print(stack[--top]+1);
while(top > 0) {
//位置比索引大一
System.out.print("---->"+(stack[--top]+1));
}
implementação de código
/**
* 得出最小路径表
* @param map 用二维数组存储的图结构
* @return 路径数组
*/
public static int[] dijkstra(SimpleMap sMap,int first) {
//路径数组
int[] path = new int[sMap.num];
//标记与权值数组(权值为0，表示已加入路径)
int[] markAndInfo = new int[sMap.num];
//辅助数组初始化
for(int i=0; i<sMap.num; i++) {
path[i] = -1;
markAndInfo[i]= CreateAMap.MAX;
}
//定位初始位置(从零开始）
first = first-1;
for(int j=0; j<sMap.num; j++) {
if(j != first) {
path[j] = first;
}
markAndInfo[j]= sMap.map[first][j];
}
//已经加入到路径的顶点
int judge = 1;
while(judge < sMap.num) {
//从权值数组中找出最小的的值
int index = 0;
int min = CreateAMap.MAX;
for(int i=0; i<sMap.num; i++) {
//需判断当前点是否已经在路径中
if(markAndInfo[i] != 0 && markAndInfo[i] < min) {
index = i;
min = markAndInfo[i];
}
}
//更新权值数组以及路径数组
markAndInfo[index] = 0;
for (int i = 0; i < sMap.num; i++) {
if(markAndInfo[i] !=0 && min+sMap.map[index][i] < markAndInfo[i]) {
markAndInfo[i] = min+sMap.map[index][i];
path[i] = index;
}
}
judge++;
}
return path;
}
E os resultados do teste: A FIG
fonte 1, a extremidade 5:
