graf-jak go uprawnić?

Witam!
​ Proszę o pomoc w usprawnieniu kodu, tak aby program znalazł najszybszą drogę z pierwszego wierzchołka do każdego innego. Jestem początkująca i nie do końca wiem jak to zrobić :)

Kod źródłowy:

#include <stdio.h>
#include <iostream>
#define n 8
#define INF 9999999
using namespace std;

int W[n][n]={ // Macierz sąsiedztwa opisująca graf
{0,5,0,0,10,0,11,0},
{0,0,1,0,0,0,0,0},
{0,0,0,0,1,1,0,0},
{0,0,0,0,1,0,0,0},
{3,2,0,0,0,0,0,0},
{0,0,0,0,0,0,0,2},
{0,0,0,2,0,0,0,0},
{0,0,5,0,7,0,1,0}};
int Q[n]={1,1,1,1,1,1,1,1}; // Zbiór wuierzchołków do przetworzenia
int D[n]={INF,INF,INF,INF,INF,INF,INF,INF}; // Tablica odległości od s
int P[n]={-1,-1,-1,-1,-1,-1,-1,-1}; // Tabela poprzedników

void Dijkstra(int s){
int u,v; // Obsługiwane wierzchołki
int Dmin;

D[s]=0;

do{
Dmin=INF;
for(v=0;v<n;++v) // Szukamy takiego wierzchołka, który jest w Q
if(Q[v] && D[v]<Dmin){ // i jednocześnie ma najmniejszą wartość w D
u=v; // Znaleziony odpowiedni wierzchołek
Dmin=D[u]; // i jego najmniejsza odległość od s
}
if(Dmin==INF) break; // Jeżeli Dmin jest róna INF, to znaczy że Q jest puste
for(v=0;v<n;v++) // Przeglądamy sąsiadów wierzchołka u
if(u!=v && D[v]>W[u][v]+D[u]){ // Czy przypadkiem droga do v przez u nie jest krótsza niż wcześniej znaleziona?
D[v]=W[u][v]+D[u]; // Jeśli tak, to zapamiętujemy ten fakt (krótszą odległość)
P[v]=u; // i przez który wierzchołek jest krócej
}
}
while(1);
}

int main(){//zamieniałam void na int
int i,j;
cout<<"Nasz graf:\n";
for(i=0;i<n;++i){
for(j=0;j<n;j++) cout<<W[i][j]<<'\t';
cout<<endl;
}

Dijkstra(0);

cout<<"D = [";
for(i=0;i<n;i++) cout<<D[i]<<'\t'<<endl;
cout<<"]\nP = [";
for(i=0;i<n;i++) cout<<P[i]<<'\t'<<endl;
cout<<"]\n\n";

getchar();
return 0; //funkcja int zwraca wartośc 0
}

Algorytm Dijkstry albo bellmana Forda.

@Shalom: a po co Ci taka armata do tego?

? A ty co proponujesz? Żaden z tych algorytmów nie jest trudny a są stworzone dokładnie do tego problemu.

BFS - dostaniemy sporo lepszą złożoność zarówno czasową jak i pamięciową.

"tak aby program znalazł najszybszą drogę z pierwszego wierzchołka do każdego innego"
algorytm BFS właśnie to robi - zaczynając ze zródła analizujemy "falami" kolejne wierzchołki, tzn: aby dojść do wierzchołka oddalonego o n od zródła musimy najpierw przejść przez wierzchołki oddalone o n-1 od zródła. Czas przetworzenia wierzchołków jest zatem najkrótszą drogą ze zródła. Jeszcze bardziej łopatologicznie:
najpierw odwiedzamy sąsiadów zródła (wierzchołki oddalone o 1)
potem sąsiadów tych sąsiadów (wierzchołki oddalone o 2)
potem wierzchołki oddalone o 3
...
Oczywiście trzeba to robić sprytnie i jeśli istnieje szybsza droga, to nadpisujemy czas przetworzenia.
Złożoność liniowa, Twoja armata ma natomiast liniowo-logarytmiczną.

Brawo. Ale to działa tylko dla grafu nie-ważonego, czyli się nie nadaje...

Gdzie masz tutaj informację o tym, że graf jest ważony? Może jest, ale w tym chaosie nie widzę. Jeśli i Ty nie znajdziesz, to zdaje się, że w domyśle przyjmuje się, że bez wag.

EDIT: okej, jest. Przyznaję rację.