Dijkstra - irányítatlanban is működjön?

A c++-ban megírt Dijkstra algoritmusomat kéne javítani úgy, hogy irányítatlan gráfokban is működjön. Tudna valaki segíteni? A kód:

#include <iostream>

#include <fstream>

#include <vector>

#include <sstream>

//#include <queue>

using namespace std;

struct El { // 1 db. élnek a konstrukciója

private:

int kezdo;

int veg;

int koltseg;

public:

El(){ kezdo=0; veg=0; koltseg=0; } // Nem adtunk meg parametereket az él létrehozásakor

El(int k,int u,int s) // Megadtunk paramétereket -||-

{

kezdo=k;

veg=u;

koltseg=s;

}

int ReturnKezdo() //Az él kezdõcsúcsát adja vissza

{

return kezdo;

}

int ReturnVeg() //Az él végcsúcsát adja vissza

{

return veg;

}

int ReturnKoltseg() //Az él költségét adja vissza

{

return koltseg;

};

void SetParameters(int kezd,int vegz, int kolts) // Beallíthatja egy él kezdõ/vég - csúcsát , valamint költségét

{

kezdo=kezd;

veg=vegz;

koltseg=kolts;

}

};

struct Csucs { // 1. db csúcsnak a konstrukciója

private:

int csucsNumber;

int currentKoltseg;

public:

Csucs(){ csucsNumber=0; currentKoltseg=0; }

Csucs(int k,int s)

{

csucsNumber=k;

currentKoltseg=s;

}

int ReturnCsucsNumber()

{

return csucsNumber;

}

int ReturnCurrentKoltseg()

{

return currentKoltseg;

};

void SetParameters(int kezd, int kolts)

{

csucsNumber=kezd;

currentKoltseg=kolts;

}

};

struct PriorityQueue

{

Csucs pSor[100]; //max 100 csúcsból álló prioritásos sor

int elemszam;

//Konstruktorok:

PriorityQueue(){ elemszam=0; } // kezdetben 0 elembõl áll a Prio. Sor

//PriorityQueue()

int Beszur(int k,int ko) // Beszúrunk 1 elemet

{

int x=Elemee(k);

if(elemszam==0) //ha még üres a sor, akkor csak szúrunk

{

pSor[0].SetParameters(k,ko);

elemszam++;

}else if(x==-1)

{

for(int i=0;i<elemszam;i++)

{

if(pSor[i].ReturnCurrentKoltseg()>ko)

{

Helyetcsinal(i);

pSor[i].SetParameters(k,ko);

elemszam++;

}

}

}else if(x!=-1)

{

for(int j=elemszam;j>=x;j--)

{

pSor[j+1]=pSor[j]; //CopyConstruktor

}

pSor[x].SetParameters(k,ko);

}

};

int Elemee(int csucs) //Eleme-e e egy csúcs a sornak

{

for(int i=0;i<elemszam;i++)

if(pSor[i].ReturnCsucsNumber()==csucs)

return i;

return -1;

}

Csucs Elvesz() // kiveszünk 1 elemet a sorból

{

Csucs elso=pSor[0];

for(int i=0;i<elemszam-1;i++)

{

pSor[i].SetParameters(pSor[i+1].ReturnCsucsNumber(),pSor[i+1].ReturnCurrentKoltseg());

}

elemszam--;

return elso;

}

Csucs First() // lekérdezzük a legnagyobb prioritású elemet

{

return(pSor[0]);

}

void Helyetcsinal(int hely) // ha be kell szúrnunk 1 elemet kettõ közzé akkor helyet csinalunk neki (az utána lévõket hátrább csúsztatjuk)

{

for(int i=elemszam;i>=hely;i--)

{

pSor[i+1].SetParameters(pSor[i].ReturnCsucsNumber(),pSor[i].ReturnCurrentKoltseg());

}

}

bool Ures() // üres-e a sor

{

if(elemszam>0) return false;

else return true;

}

};

int main()

{

int csucsszam ; // csucsok szama

int elszam=-2; //elek szama

El _elek[1000]; //elek vektora

int b,c,d; //temp valtozok

PriorityQueue pQ; // prioritasos sor

int Keszi=-1; //Keszen levo csucsokra vonatkozo léptetõ

//beolvassuk az adatokat

fstream myfile("Dijkstra.txt");

if(myfile.is_open() )

{

while(!myfile.eof())

{

elszam++;

if(elszam==-1)

myfile>>csucsszam;

else

{

myfile>>b;

myfile>>c;

myfile>>d;

}

_elek[elszam].SetParameters(b,c,d);

}

}

myfile.close();

if(elszam<=0)

{

cout<<"Nincs el megadva!";

return 1;

}

if(csucsszam<=0)

{

cout<<"Nincs csucs megadva!";

return 2;

}

int Parent[csucsszam]; //Parent vektor

int Distance[csucsszam]; // Tavolsag vektor

int Kesz[csucsszam]; // Tavolsag azon csucsokhoz, ahova mar tudjuk a vegleges MIN tavolsagot

for(int i=0;i<csucsszam;i++)

{

Parent[i]=-1;

Distance[i]=0;

Kesz[i]=-1;

}

pQ.Beszur(1,0);

while(!pQ.Ures())

{

Csucs aktualis=pQ.Elvesz(); // a legkisebb prioritasu

Keszi++;

Kesz[Keszi]=aktualis.ReturnCsucsNumber(); //beirunk meg 1 elemet a keszek halmazaban, NOVELJUK A KESZi-t

for(int i=0;i<=elszam;i++) //keresunk az osszes el kozott

{

if(_elek[i].ReturnKezdo()==aktualis.ReturnCsucsNumber()) //megnezzuk az osszes csucsbol kimeno eleket

{

bool joLesz=true; // szerepel-e mar a vegzett csucsok kozott ?

for(int j=0;j<Keszi;j++) // megnezzuk, hogy nem-e szerepel mar a keszek kozott a mostani csucs

{

if(_elek[i].ReturnVeg()==Kesz[j]) //ha mar szerepel a nezett csucsok kozott akkor nem nezzuk

joLesz=false;

}

if(joLesz==true) // ha viszont nem szerepel

{

if(Distance[_elek[i].ReturnVeg()]>Distance[aktualis.ReturnCsucsNumber()]+_elek[i].ReturnKoltseg());

{

Distance[_elek[i].ReturnVeg()]=Distance[aktualis.ReturnCsucsNumber()]+_elek[i].ReturnKoltseg();

pQ.Beszur(_elek[i].ReturnVeg(),Distance[_elek[i].ReturnVeg()]);

Parent[_elek[i].ReturnVeg()]=_elek[i].ReturnKezdo();

}

}

}

}

}

cout<<Distance[csucsszam]<<endl;

int j=csucsszam;

std::ostringstream oss;

oss<<j;

while(j!=-1)

{

oss<<","<<Parent[j];

j=Parent[j];

}

string kiir;

kiir+=oss.str();

for(int i=kiir.size()-4;i>=0;i--)

{

cout<<kiir[i];

}

return 0;

}