Lab 02 Cmasmas

Algoritmo de Dijkstra
C++
10/09/2019
1. Visita los vértices no visitados por la menor distancia.
2. Para el vértice actual examinar que vértices no hemos visitado.
3. Para el vértice actual calcular la distancia de cada vecino al vértice

inicial
4. Si la distancia calculada de un de los vértices es menor a la

anteriormente conocida, reemplazarla.
5. Añadir el vértice visitado a la lista.
6. Si faltan visitar regresar al nodo 1.
10/09/2019
6
A B
1 C
2 2
D E
1
10/09/2019
C++
Entradas = Matriz de adyacencia, número de vértices, vértice de inicio.
Salida = Distancias a cada nodo
6
A B
5
 0 6 0 1 0
 6 0 5 2 2
 0 5 0 0 5
1 C
2 2  1 2 0 0 1
 0 2 5 1 0
5
D E Matriz de adyacencia
1
10/09/2019
OCTAVE
DEFINIR COMO CONSTANTES INFINITO Y MAXIMO (NRO DE NODOS)
DEFINIR LA FUNCION DIJKSTRA CON LAS VARIABLES DE ENTRADA
PROGRAMAR LA FUNCIÓN PRINCIPAL CON LOS DATOS DEL GRAFO Y LLAMAR A
DIJSKTRA
6  #define infinito 9999

A B  #define max 5
5  void dijkstra(int G[max][max],int n,int nodo_inicio);
 int main() { int G[max][max]={{0,6,0,1,0},{6,0,5,2,2},{0,5,0,0,5},

{1,2,0,0,1},{0,2,5,1,0}};
 int n=5;
1 C  int u=0;
2 2  dijkstra(G,n,u);
 return 0;
}
5
D E
1
10/09/2019
OCTAVE
PROGRAMAR LA FUNCIÓN DIJSKTRA
DEFINIMOS:
• TABLAS (MATRIZ): COSTOS TOTALES.
• LISTAS (VECTOR):DISTANCIAS PARA EL NODO ACTUAL, NODOS PREDECESORES EN
EL CAMINO, NODOS VISITADOS.
• VARIABLES: CONTEO, MINIMA DISTANCIA, NODO SIGUIENTE, COORDENADAS
6
A B
5
 void dijkstra(int G[max][max],int n,int nodo_inicio) {
 int costo[max][max],distancia[max],pred[max];
C  int visitados[max],conteo,mindistancia,nodo_sig,i,j;
1
2 2
D E
1
10/09/2019
OCTAVE
CREAR MATRIZ DE COSTO A PARTIR DE LA DE ADYACENCIA
 0 6 0 1 0  INF 6 INF 1 INF

 6 0 5 2 2  6 INF 5 2 2
 0 5 0 0 5  INF 5 INF INF 5
 1 2 0 0 1  1 2 INF INF 1
 0 2 5 1 0  INF 2 5 1 INF
10/09/2019
OCTAVE
CREAR MATRIZ DE COSTO A PARTIR DE LA DE ADYACENCIA
for(i=0;i<n;i++){
 INF 6 INF 1 INF  for(j=0;j<n;j++){
 6 INF 5 2 2  if(G[i][j]==0)
 INF 5 INF INF 5  costo[i][j]=infinito;
 else
 1 2 INF INF 1
 costo[i][j]=G[i][j];
 INF 2 5 1 INF }
}
10/09/2019
OCTAVE
INICIAMOS MATRIZ VISITADOS
INICIALMENTE NINGUNO ESTA VISITADO
MARCAMOS EL NODO INICIO COMO VISITADO
Visitados=[0 0 0 0 0]
 for(i=0;i<n;i++) {
Visitados=[1 0 0 0 0]  visitados[i]=0;
 }
 visitados[nodo_inicio]=1;
10/09/2019
OCTAVE
CREAMOS EL VECTOR DE DISTANCIAS
CONTIENE EL COSTO DESDE EL NODO EVALUADO HASTA CADA NODO
LO INICIAMOS CON LOS VALORES PARA EL NODO DE INICIO
LA DISTANCIA AL NODO INICIO ES 0
for(i=0;i<n;i++) {
distancia=[0 6 0 1 0]
distancia[i]=costo[nodo_inicio][i];
}
distancia[nodo_inicio]=0;
10/09/2019
OCTAVE
CREAMOS EL VECTOR DE NODOS PREDECESORES
INCIAMOS LOS ELEMENTOS DE ESTE VECTOR COMO EL NODO DE INICIO
 for(i=0;i<n;i++) {
predecesores=[0]
 pred[i]=nodo_inicio;
 }
10/09/2019
OCTAVE
INICIAMOS EL CONTEO EN 1
Visitados=[1 0 0 0 0]  for(i=0;i<n;i++) {
distancia=[0 6 0 1 0]  pred[i]=nodo_inicio;
 }
predecesores=[0]
 conteo=1;
10/09/2019
OCTAVE
HAREMOS EL PROCESO MIENTRAS EL CONTEO NO SEA MAYOR QUE LA CANTIDAD DE
NODOS
INICIAMOS MINDISTANCIA COMO INFINITO
6
A B
5
 while(conteo<n-1) {
1 C
2 2  mindistancia=infinito;
D E
1
10/09/2019
mindistancia=infinito
OCTAVE
EVALUAMOS PARA TODAS LAS DISTANCIAS DEL NODO ACTUAL.
6
A B
5 for(i=0;i<n;i++)
1 C
2 2
D E
1
10/09/2019
OCTAVE
SI LA DISTANCIA AL NODO EVALUADO ES MENOR A LA DISTANCIA A LOS NODOS NO VISITADOS.
6
A B
5 for(i=0;i<n;i++)
1 C
if(distancia[i]<mindistancia&&!visitados[i])
2 2
D E
1
10/09/2019
mindistancia=infinito Visitados=[1 0 0 0 0]
OCTAVE
SI LA DISTANCIA AL NODO EVALUADO ES MENOR A LA DISTANCIA A LOS NODOS NO VISITADOS.
DE SER ASI ACTUALIZAMOS LA DISTANCIA MINIMA Y ESTABLECEMOS ESE NODO COMO EL NODO
SIGUIENTE.
6
A B
5 for(i=0;i<n;i++)
1 C
if(distancia[i]<mindistancia&&!visitados[i]) {
2 2 mindistancia=distancia[i];
nodo_sig=i;
5 }
D E
1
10/09/2019
mindistancia=0 distancia=[0 6 0 1 0]
OCTAVE
ACTUALIZAMOS VISITADOS CON EL NODO_SIG
A B
5 visitados[nodo_sig]=1;
1 C
2 2
Visitados=[1 0 0 1 0]
5
D E
1
10/09/2019
OCTAVE
EVALUAMOS PARA TODAS LAS DISTANCIAS DEL NODO ACTUAL HASTA ENCONTRAR UN NO
VISITADO
A B for(i=0;i<n;i++){
5 if(!visitados[i]){
1 C
2 2
D E
1
10/09/2019
OCTAVE
SI LA DISTANCIA MINIMA ANTERIORMENTE ENCONTRADA MAS EL COSTO DEL NODO SIGUIENTE
AL NODO EVALUADO ES MENOR A LA DISTANCIA AL NODO EVALUADO.
if(mindistancia+costo[nodo_sig][i]<distancia[i]) {
1 C
2 2
D E
1
10/09/2019
OCTAVE
DE SER ASI ACTUALIZAMOS LA DISTANCIA AL NODO EVALUADO CON ESE VALOR Y AGREGAMOS
EL NODO SIGUIENTECOMO PREDECESOR.
6
distancia[i]=mindistancia+costo[nodo_sig][i];
1
2
C pred[i]=nodo_sig;
2
}
}
5
D E
1
10/09/2019
OCTAVE
AUMENTAMOS EL CONTEO Y CERRAMOS EL WHILE.
6
distancia[i]=mindistancia+costo[nodo_sig][i];
1
2
C pred[i]=nodo_sig;
2
}
}
5
conteo++;
D E }
1
}
10/09/2019
OCTAVE
PARA TODOS LOS NODOS QUE SEAN DISTINTOS AL NODO DE INICIO.
for(i=0;i<n;i++)
6
A B
if(i!=nodo_inicio) {
5
1 C
2 2
D E
1
10/09/2019
OCTAVE
IMPRIMIMOS UN MENSAJE INDICANDO QUE NODO Y QUE CAMINO
for(i=0;i<n;i++)
6
A B
5 cout<<"\n distancia del nodo "<<i<<" = "<<distancia[i];
cout<<"\n El camino es "<<i;
1 C
2 2
D E
1
10/09/2019
OCTAVE
INICIAMOS j CON EL NODO EVALUADO
for(i=0;i<n;i++)
6
A B
1 C j=i;
2 2
D E
1
10/09/2019
OCTAVE
HACEMOS QUE j TOME EL VALOR ENCONTRADO EN LA LISTA DE NODOS PREDECESORES E
IMPRIMIMOS DICHO VALOR.
MIENTRAS j SEA DISTINTO AL NODO DE INICIO
for(i=0;i<n;i++)
6
A B
1 C j=i;
2 2
do {
5 j=pred[j];
D E
cout<<" ------ "<<j;
1 }while(j!=nodo_inicio);
10/09/2019
}

Lab 02 Cmasmas

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lab 02 Cmasmas

Cargado por

Copyright:

Formatos disponibles

Algoritmo de Dijkstra

1. Visita los vértices no visitados por la menor distancia.

2. Para el vértice actual examinar que vértices no hemos visitado.

3. Para el vértice actual calcular la distancia de cada vecino al vértice

4. Si la distancia calculada de un de los vértices es menor a la

5. Añadir el vértice visitado a la lista.

6. Si faltan visitar regresar al nodo 1.

Salida = Distancias a cada nodo

6  #define infinito 9999

5  void dijkstra(int G[max][max],int n,int nodo_inicio);

 int main() { int G[max][max]={{0,6,0,1,0},{6,0,5,2,2},{0,5,0,0,5},

 0 6 0 1 0  INF 6 INF 1 INF

INICIALMENTE NINGUNO ESTA VISITADO

MARCAMOS EL NODO INICIO COMO VISITADO

CONTIENE EL COSTO DESDE EL NODO EVALUADO HASTA CADA NODO

LO INICIAMOS CON LOS VALORES PARA EL NODO DE INICIO

LA DISTANCIA AL NODO INICIO ES 0

INCIAMOS LOS ELEMENTOS DE ESTE VECTOR COMO EL NODO DE INICIO

INICIAMOS MINDISTANCIA COMO INFINITO

SI LA DISTANCIA AL NODO EVALUADO ES MENOR A LA DISTANCIA A LOS NODOS NO VISITADOS.

SI LA DISTANCIA AL NODO EVALUADO ES MENOR A LA DISTANCIA A LOS NODOS NO VISITADOS.

MIENTRAS j SEA DISTINTO AL NODO DE INICIO

También podría gustarte