¿Cuál es el código fuente para una implementación en lenguaje ensamblador para encontrar el camino más corto (usando el algoritmo de Dijkstra)?

Algoritmo de Dijkstra El algoritmo de Dijkstra es un algoritmo típico de ruta más corta que se utiliza para calcular la ruta más corta de un nodo a todos los demás nodos. Su característica principal es tomar el punto de partida como centro y expandirse hacia afuera paso a paso hasta extenderse hasta la fecha de finalización. El algoritmo de ruta más corta de Dijkstra puede obtener la mejor solución, pero con muchos nodos, su eficiencia transversal computacional es baja.

El algoritmo de ruta más corta en el algoritmo de Dijkstra es muy representativo y muchos cursos profesionales enseñarán su contenido básico en detalle, como estructura de datos, teoría de grafos, investigación de operaciones, etc.

Generalmente hay dos formas de expresar el algoritmo de Dijkstra, etiquetas permanentes y etiquetas temporales, uno de los métodos de tabla abierta y de tabla cerrada, que es consistente con el algoritmo A * y D. * algoritmo a continuación. Aquí están los métodos de tabla abierta y de tabla cerrada.

Método codicioso, estrategia algorítmica

El proceso aproximado es el siguiente:

Crear dos tablas, abrirlas y cerrarlas.

Abra la tabla para guardar todos los nodos generados sin investigación y cierre la tabla para registrar los nodos que se han visitado.

1. Inicio de la red vial y espera de puntos de control sin puntos de control en el grupo OPEN.

2. Abra la tabla, busque el punto más cercano al punto inicial, busque todos los nodos secundarios y cierre la tabla después de encontrar este punto.

3. Recorre los nodos secundarios accediendo a este punto. Obtiene el valor de distancia de estos nodos secundarios hasta el punto de inicio de emisión de la tabla OPEN.

4. Repita los pasos 2 y 3 hasta que la tabla OPEN esté vacía o se encuentre el punto objetivo.

La primera vez que lo vi fue V2, U = 2

//Encontré el final, MinDis dijo que no podía conectarse y regresó. Esta situación es similar a la V5.

(MinDis == no) return;

// Crea un vértice u que se usará para el vértice u, equivalente al arco [V, U + arco U, W].

Access [U] = 1;

// Encontrar el camino mínimo desde el vértice u a todos los demás vértices es en realidad encontrar el arco ubicado en [0, VerNum]] [U, Valor J, J.

// Si es un arco, entonces U [I] + kairos [U, J] ARC [I, J], ARC [I, J] = arco [I, U] + kairos [ U J ] < arco [I, J]

// Dado que la distancia [] es el resultado deseado y se ha determinado el punto de partida, el método es el siguiente:

// Si (distancia [U ] + arco [U, J) <=distancia[J]:

// distancia[J] distancia[U] + [U, J arco];

// guardar etiqueta iPath [] u puntos;

// De manera similar, establezca acceso: rutas recién descubiertas [J] = 0, y luego busque otra ruta, que no se puede utilizar.

V3

(J = 0;

(visita[J] == 0 &&arc U, J] <&& U!= J) /> {

((Distancia[U] + arco [U, J) <= Distancia[J])

{

Distancia[J] Distancia[U] + Arco[ U, J];

Acceso[J] = 0

Etiqueta iPath[J] = U

}

}

}

}

}

}/ / Función auxiliar

Prim() inválida,

{

INT I, M N = 0;

para (i = 0; I VerNum; I + +)

{

acceso = 0;

T = nuevo TreeNode();

T.Text = V

}

acceso; [N] + +;

listBox1.Items.add (V [N]

(visita()> 0)

{

((M = MinAdjNode(N))! = -1)

{ BR /> T [N].Nodes.Add (T

N = M;

Acceso [N] + +;

}

Otro

{ = MinNode(0); /p>

(N> 0) T [Min].Nodes.Add(T [Min]);

Acceso[N] + +

}

(N> 0) T [Min].

listBox1.Items.Add(V [N]); 0]);

}

}

TopoSort()

{

INT I, N;

listBox1.Items.Clear( );

Pila S = nueva pila (

para (i = 0; I VerNum, I ++)

acceso = 0;

for (= VerNum- 1> = 0; I - )

(en grado (I) == 0)

{

S.Push(I);

visita + + ....../>}

y (S .Count!= 0)

{

N = (INT) S.Pop();

listBox1.Items.Add(V [N] )

CLEARLINK(N);

for (i = VerNum-1> ; = 0; I - )

(Puntuación == 0 && Grado de entrada ( I) == 0)

{

S.Push(I

Acceso + +

}

}

}

}

}

AOETrave no válido (INT N, nodo de árbol TR, W)

{

INT I, W0;

(grado de salida (N) == 0) retorno

(i = 0;

((W0 = arco [N, I])! = 0)

{

listBox1.Items.Add (V + "\t") .+ (W + W0)'s ToString() + "（t"+ i.ToString() + "\ t "+ n.ToString()

T1 de TreeNode = new TreeNode(

T1.Text = V + "W = "+ (W + W0).ToString() + "]";

AOETrave(I, T1, W + W0

}

}

}

No válido; AOE()

{<

INT I, W = 0, M = 1

T1 de TreeNode = nuevo TreeNode ();

for (i = 0;

{

acceso = 0;

}Add("V\TW\ Agencia de Comercio e Industria\ TPID");

for (i = 0; I VerNum, I + +)

{

((W = arc[ 0, I])! = 0)

{

listBox1.Items.Add (V + "\ t".+ w.ToString() + "\ T" + i .ToString() + "\ T0");

T2 de TreeNode = nuevo TreeNode()

T2.Text = V + "W = " + w. + " "".

Nodos.Add( T2), ());

m+ +

}

}

}

<; p> treeView1.Nodes.Clear();

treeView1.Nodes.Add(T1

}

IsZero()

{

I;

para (i = 0; I VerNum, I++)

(LineIsZero (i) > = 0) return <; /p>

return -1;

}

Explicar LineIsZero (N)

{

I

(i = 0; < VerNum; I + +)

(Arc[N, I] = 0) return

return -1;}

：InvalidDepthTraverse()

{

INT I, M;

(i = 0; <. VerNum, I + +)

{

acceso = 0; BR /> T = nuevo TreeNode();

T.Text = V

R = 0; /p>

}

AND ()

y ((M = IsZero()) > = 0)

{

(Visita[M] == 0)

{

listBox1.Items.Add(V [M]); 1 ;}

Visita[M] + +;

DTrave(M);

}

as (i = 0; {

(R == 1)

treeView1.Nodes.Add(T

}

}

;

}

DTrave(N) /> no válido {

I

(LineIsZero(N) <0) retorno

<; p>for (i = VerNum-1 > = 0; I - )

(Arc[N] = 0)

{

Arc[N, I] = 0;

Arco[I, N] = 0;

(Acceso = = 0)

{

listBox1 .Items.Add(V);

T [N].Nodos.Add(T

R = 0

}

;

acceso + +;

DTrave(I);

}

}

} : BreadthTraverse() no válido. p>

{

INT I, M

(i = 0) ; < VerNum, I++)

{

acceso = 0;

T = nuevo TreeNode();

T.Text = V

R = 0; >}

}

AND ()

y ((M = IsZero()) > = 0 )<

/p>

{<

(Visita[M] == 0)

{

listBox1.Items agregar (V [M]) ;

R [M] = 1

}

Visita[M] + +

BTrave(M); /p>

}BR /> (i = 0; I VerNum, I + +)

{

(R == 1)

treeView1.Nodes.Add(T);

}

}

}

BTrave(N) no válido

{

I

Cola Q = nueva Cola ();

Q.Enqueue(N)

y (Q. Count! = 0)

{

para (i = 0; I VerNum, I + +)

{

(arc N, I] = 0)

{

arco[N, I] = 0

Arco[N] = 0; p>(Acceso == 0)

{

listBox1.Items.Add(V

T [N].Nodes.Add(T) ;

diámetro = 0;

}

acceso + +

Q.Enqueue(I); p>}

}BR /> N = (int) de Q.Dequeue();

}

}

}

}

}

Explicar MinNode (VN)

{

INT I, J, N, m, min = no;

N = -1, M = -1;

para (i = VN I VerNum, I++)

en para (j = 0; J < VerNum; + +)

（arc[I , J] = &&Arc[I, J] min&&min == 0 &&&Visit[J] == 1)

{ BR />Min = Arco[I, J]; p>Regresar n;

}BR /> Interpretar MinAdjNode (N)

{

I, Min, M

Min; = No, M = -1;

(i = 0; I < VerNum, I + +)

(Arc[N, I] = sin acceso && == 0 &&) Arco mínimo[N, I] && acceso[N] == 1){BR /> BR /> Mínimo = arco[N, I], M = I;}

Devuelve m ;

}

INT acceso()

{

INT I, S = 0

para ( i = 0; <NúmVer, I + +

)

(visita == 0) + +;

return s;

>}

[editar] Pascal implementa el algoritmo de Dijkstra. ：

Programa Dijkstra;

VAR

ARRAY [1 .... 100,1 ... 100 enteros

Bandera; : matriz [1] ...100] Valor booleano

W, X, N, I, J, min, Minnesota: entero

comenzar

readln (N);

I：= 1 an

comenzar

para j = 1 an

leer ( A

readln;

I: = 1 to n do

(W >) y ([W, I]

p>

Inicio

Puntuación: = [];

Minnesota: = I

Fin;

Bandera [ Minnesota ]: = VERDADERO;

J：1 a n hacer

p>(J > Minnesota) y (A [1, Minnesota] + A [Minnesota, J], A [ 1, J) y (bandera [J] = FALSO), luego BR /> A [1, J] = [1, Minnesota] + A [Minnesota, J]

END p>

I：= 1 a n hacer

Escribir ( [ 1]);

Fin.