Dijkstra bzw. Shortest Path Algorithms...

AdHa

Hallo zusammen,

ich habe mir einen Dijkstra Algorithmus gebastelt,
der eine Matrix in ein 1d-Array einließt
(zumal jedes Array >= 2d intern im Rechner als 1d abgelegt wird...),
und die kürzesten Wege vom StartVertex nach allen Knoten im
Array Distance ablegt.

Meine Frage ist nun:
kennt jemand einen Dijkstra-Algorithmus,
der NUR die rechte obere Dreiecksmatrix zum berechnen der Wege verwendet?
(entspräche dann einem ungerichteten, gewichteten Graph,
die übrigen Zellen würde ich dann für andere Daten benötigen...)
Oder weiß jemand ob es eine zeit oder speichersparendere Methode gibt
kürzeste Wege zu erkennen?

Grüße
Adrian

P.S.: hier der Code für Interessenten...

int* Dijkstra(int* Matrix, int VerticesAnzahl)
{

	int StartVertex = 0;
	int CurrentWeight = 0;
	int SourceVertex = 0;
	int DestinationVertex = 0;

     int Checked[VerticesAnzahl];
     for (Dummy = 0; Dummy < VerticesAnzahl; Dummy++)
         Checked[Dummy] = 0;
     int Distance[Vertices];
     for (Dummy = 0; Dummy < VerticesAnzahl; Dummy++)
         Distance[Dummy] = INT_MAX;

int* Anfangsadresse = Distance;

    Distance[StartVertex] = 0;

    for (YAxis = 0; YAxis < VerticesAnzahl; YAxis++)
    {
        CurrentWeight = 128;

        for (XAxis = 0; XAxis < VerticesAnzahl; XAxis++)
        {
            if ((Checked[XAxis] == 0) && (Distance[XAxis] < CurrentWeight))
            {
               CurrentWeight = Distance[XAxis];
               StartVertex = XAxis;
            }
        }

        Checked[StartVertex] = 1;

        for (Dummy = 0; Dummy < VerticesAnzahl; Dummy++)
        {
                SourceVertex = StartVertex * VerticesAnzahl + Dummy;
                DestinationVertex = VerticesAnzahl * VerticesAnzahl + Dummy;

                if ((Matrix[SourceVertex] + CurrentWeight) < Distance[Dummy])
                   Distance[Dummy] = Matrix[SourceVertex] + CurrentWeight;
        }
    }
return Anfangsadresse;
}