public void wyznaczWezly(Wezel Skad)
{
//znalezienie lacza wychodzacego od wezla
Lacze lacze = KrawedzieSciezki.Find(x => x.Wezel1 == Skad);
if (lacze != null)
{
if (!ListaWezlowSciezki.Contains(lacze.Wezel1))
{
ListaWezlowSciezki.Add(lacze.Wezel1);
}
if (!ListaWezlowSciezki.Contains(lacze.Wezel2))
{
ListaWezlowSciezki.Add(lacze.Wezel2);
}
//Wyznaczamy wezly dalej, zaczynajac od drugiego wezla
wyznaczWezly(lacze.Wezel2);
}
/*
* foreach (Lacze lacze in ListaKrawedziSciezki)
* {
* if (!ListaWezlowSciezki.Contains(lacze.Wezel1))
* ListaWezlowSciezki.Add(lacze.Wezel1);
* if (!ListaWezlowSciezki.Contains(lacze.Wezel2))
* ListaWezlowSciezki.Add(lacze.Wezel2);
* else
* continue;
* } */
}
public void wprowadzenieIndeksowKrawedzi(Lacze ktore)
{
doprowadzoneKrawedzie.Add(ktore);
}
public void algorytmFloyda()
{
aktualizujLiczniki();
// ustawWagiLaczy();
float INFINITY = 64 * 64; //Nieskonoczonosc
//Ustawiamy początkowe wartości
if (ustawPoczatkoweKoszty)
{
//tablica kosztow - zawiera koszt z wezla o identyfikatorze nr a do wezla nr b
//Koszt dostania się z a do b to tablicaKosztow[a,b] przechowuje koszt dostania się z węzła a do węzła b
tablicaKosztow = new float[liczbaWezlow, liczbaWezlow];
// tablica kierowania wezlami - zawiera referencje do Wezla, do ktorego nalezy sie udac w drodze z a do b
tablicaKierowaniaWezlami = new Wezel[liczbaWezlow, liczbaWezlow];
// tablica kierowania krawedziami - zawiera indeks krawedzi ktora prowadzi z wzezla a do b, gdzie a i b sa sasiadami
tablicaKierowaniaLaczami = new Lacze[liczbaWezlow, liczbaWezlow];
ustawPoczatkoweKoszty = false;
}
//indeksy wezlow w tabeli
int w1, w2;
foreach (Lacze lacze in krawedzie)
{
w1 = wezly.FindIndex(x => x.idWezla == lacze.wezel1);
w2 = wezly.FindIndex(x => x.idWezla == lacze.wezel2);
if (w1 >= 0 && w2 >= 0)
{
if (tablicaKierowaniaLaczami[w1, w2] == null) //Jezeli jeszcze nic nie bylo tutaj, to przypisujemy wartosci
{
tablicaKierowaniaLaczami[w1, w2] = lacze; //przypisanie wartosci do tablicy. Odejmuje 1, bo na wejsciu numeracja wezlow zaczyna sie od 1
//tablicaKierowaniaLaczami[w2, w1] = lacze; //Z b do a tez idziemy przez dane lacze
tablicaKierowaniaWezlami[w1, w2] = lacze.Wezel2; //Idac z wezla1 do wezla2 dostaniemy sie do wezla2
//tablicaKierowaniaWezlami[w2, w1] = lacze.Wezel1; //I vice versa
}
else
{
Lacze temp = tablicaKierowaniaLaczami[w1, w2];
if (temp.Waga > lacze.Waga) //Jesli dotychczasowa waga byla wieksza, podmieniamy. Jesli nie - nic nie robimy.
{
tablicaKierowaniaLaczami[w1, w2] = lacze; //przypisanie wartosci do tablicy. Odejmuje 1, bo na wejsciu numeracja wezlow zaczyna sie od 1
//tablicaKierowaniaLaczami[w2, w1] = lacze; //Z b do a tez idziemy przez dane lacze
tablicaKierowaniaWezlami[w1, w2] = lacze.Wezel2; //Idac z wezla1 do wezla2 dostaniemy sie do wezla2
//tablicaKierowaniaWezlami[w2, w1] = lacze.Wezel1; //I vice versa
}
}
}
}
/*
* foreach (Lacze lacze in krawedzie)
* {
* w1 = wezly.FindIndex(x => x.idWezla == lacze.wezel1);
* w2 = wezly.FindIndex(x => x.idWezla == lacze.wezel2);
* if (tablicaKierowaniaWezlami[w1, w2] == null)
* {
* tablicaKierowaniaWezlami[w1, w2] = lacze.Wezel2; //Idac z wezla1 do wezla2 dostaniemy sie do wezla2
* //tablicaKierowaniaWezlami[w2, w1] = lacze.Wezel1; //I vice versa
* }
* else
* {
* Lacze temp = tablicaKierowaniaLaczami[w1, w2];
* if (temp.Waga > lacze.Waga) //Jesli dotychczasowa waga byla wieksza, podmieniamy. Jesli nie - nic nie robimy.
* {
* tablicaKierowaniaWezlami[w1, w2] = lacze.Wezel2; //Idac z wezla1 do wezla2 dostaniemy sie do wezla2
* //tablicaKierowaniaWezlami[w2, w1] = lacze.Wezel1; //I vice versa
* }
* }
* } */
//Potrzebujemy niby polowy z tego zakresu, ale nie wiem czy nie bedzie wprowadzonych lacz skierowanych. W tym przypadku trzeba by znowu wykorzystac
// [liczbaWezlow, liczbaWezlow]
// tablicaKierowaniaWezlami[a, b] zwroci Wezel, przez ktory mamy przejsc idac z a do b
// tablicakierowaniaLaczami[a, b] zwroci Lacze, ktore laczy bezposrednio a i b
// jesli zawartosc komorki [a,b] to null, to znaczy, ze nie ma bezposredniego lacza z a do b
// jesli zawartosc tablicaKierowaniaWelzami[a, b] = b, to istnieje bezposrednie polaczenie miedzy nimi
// W przypadku bezposredniego polaczenia miedzy wezlami,tablica kierowania laczami [a, b] bedzie zawierala krawedz
// o najmniejszym koszcie
/*
* Console.WriteLine("Tablica poczatkowych kosztow:");
* for (int i = 0; i < liczbaWezlow; i++) //Wyswietlanie tablic: kosztow i kierowania wezlami
* {
* Console.WriteLine();
* for (int j = 0; j < liczbaWezlow; j++)
* {
* //Odejmowanie floatow
* if (Math.Abs(tablicaKosztow[i, j] - INFINITY) < 1)
* Console.Write("inf\t\t");
* else
* Console.Write($"{tablicaKosztow[i, j]}\t\t");
* }
* } */
for (int i = 0; i < liczbaWezlow; i++)
{
for (int j = 0; j < liczbaWezlow; j++)
{
if (i == j)
{
tablicaKosztow[i, j] = 0; //Koszt dojscia do samego siebie to 0
}
else if (tablicaKierowaniaLaczami[i, j] != null) //Czyli istnieje pojedyncze lacze pomiedzy wezlem i a wezlem j
{
tablicaKosztow[i, j] = tablicaKierowaniaLaczami[i, j].Waga;
}
else
{
tablicaKosztow[i, j] = INFINITY;
}
}
}
for (int k = 0; k < liczbaWezlow; k++) //Tak jak na slajdzie wykladowym
{
for (int i = 0; i < liczbaWezlow; i++)
{
for (int j = 0; j < liczbaWezlow; j++)
{
if (tablicaKosztow[i, j] > tablicaKosztow[i, k] + tablicaKosztow[k, j])
{
tablicaKosztow[i, j] = tablicaKosztow[i, k] + tablicaKosztow[k, j];
//tablicaKosztow[j, i] = tablicaKosztow[i, k] + tablicaKosztow[k, j];
/*
* Wezel w = znajdzNajblizszegoSasiadaProwadzocegoDo(wezly[i], wezly[j]);
*
* if (w != null)
* {
* tablicaKierowaniaWezlami[i, j] = w; //k-ty Wezel lub blizszy
* tablicaKierowaniaWezlami[j, i] = w;
* }
*/
tablicaKierowaniaWezlami[i, j] = wezly[k];
}
}
}
}
for (int i = 0; i < liczbaWezlow; i++)
{
tablicaKierowaniaWezlami[i, i] = wezly[i];
}
/*for (int k = 0; k < liczbaWezlow; k++) //Tak jak na slajdzie wykladowym
* for (int i = 0; i < liczbaWezlow; i++)
* for (int j = 0; j < liczbaWezlow; j++)
* if (tablicaKosztow[i, j] > tablicaKosztow[i, k] + tablicaKosztow[k, j])
* {
* tablicaKierowaniaWezlami[i, j] = wezly[k];
* //tablicaKierowaniaWezlami[j, i] = wezly[k];
* }
*/
//tabliceFloyd(zwrocTabliceKierowaniaLaczami, tablicaKierowaniaWezlami, tablicaKosztow);
/*foreach (Sciezka sciezka in sciezki)
* {
* sciezka.KrawedzieSciezki = sciezka.wyznaczSciezke(sciezka.Wezel1, sciezka.Wezel2, tablicaKierowaniaLaczami,
* tablicaKierowaniaWezlami, ref wezly, 1, Koszty);
* sciezka.wyznaczWezly(sciezka.Wezel1);
* //sciezka.pokazSciezke();
* //Console.WriteLine();
* } */
//testFloyd(ref tablicaKierowaniaLaczami, ref tablicaKierowaniaWezlami);
}
public int algorytmPrima()
{
//Bedziemy szukac najtanszych krawedzi, ktore spelniaja zalozenia algorytmu Prima, czyli: jeden wierzcholek krawedzi nalezy do drzewa, a drugi nie.
//
//Najtansza krawedź jest pierwsza bo Lista będzie posortowana
// try
// {
//Dwa konce lacza o najtanszej wadze oznaczamy jako odwiedzone
// krawedzie[0].Wezel1.Odwiedzony = true;
// krawedzie[0].Wezel2.Odwiedzony = true;
// tablicaMST.Add(krawedzie[0].idKrawedzi);
for (int i = 0; i < wezly.Count; i++)
{
wezly[i].Odwiedzony = false;
}
wezly[0].Odwiedzony = true;
//Sa to dwa konce najtanszej krawedzi
int liczbaOdwiedzonychWezlow = 1;
int najlepszeLacze = 0;
int wykorzystaneKrawedzie = 0;
int koniec = 0;
Lacze pomocnicze = new Lacze(0, 0, 0);
do
{
//Petla do-While nie bedzie sprawdzala wykorzystanych juz krawedzi.
int k = 0;
koniec = 0;
//za kazdym razem szukam najlepszego wierzcholka ktory pasuje do warunkow algorytmu
do
{
//Jeden z wierzcholkow musi byc nalezec do drzewa drugi-nie. Sprawdzam czy ten warunek zachodzi.
//Odwoluje sie do wlasnosci klasy Wezel "Odwiedzony". Numer indeksu pomniejszony o 1 gdyz ID zaczyna sie od 1 a indeksowanie od 0
//Pierwsze poloczenie ktore spelnia warunki algorytmu zapisuje jako najlepsze po przez zapisanie indeksu do tego poloczenia.
if (krawedzie[k].Wezel1.Odwiedzony == true ^ krawedzie[k].Wezel2.Odwiedzony == true)
{
najlepszeLacze = k;
koniec = 1;
}
k++;
} while (koniec == 0);
//Petla nie sprawdza juz wykorzystanych Krawedzi
for (int i = wykorzystaneKrawedzie; i < zwroc_lacza.Count; i++)
{
//jeden z wierzcholkow musi byc nalezec do drzewa drugi-nie
//Przeszukuje liste krawedzi w poszukiwaniu takich, ktore spelniaja warunki i maja mniejsza wage niz dotychczas najlepsze lacze
if (krawedzie[i].Wezel1.Odwiedzony == true ^ krawedzie[i].Wezel2.Odwiedzony == true)
{
if (krawedzie[i].Waga < krawedzie[najlepszeLacze].Waga)
{
najlepszeLacze = i;
}
}
}
//Wezly nalezace do krawedzi oznaczam jako odwiedzone
krawedzie[najlepszeLacze].Wezel1.Odwiedzony = true;
krawedzie[najlepszeLacze].Wezel2.Odwiedzony = true;
tablicaMST.Add(krawedzie[najlepszeLacze].idKrawedzi);
//Tu jest to usprawnienie
//Po sprawdzeniu krawedzi przesuwam ja na miejsce zalezace od ilosci sprawdzonych krawedzi
//Gdy kolejny raz wchodzi do petli for to nie sprawdza juz tej krawedzi, mniej razy chodzi petla.
if (najlepszeLacze != wykorzystaneKrawedzie)
{
pomocnicze = krawedzie[najlepszeLacze];
krawedzie.RemoveAt(najlepszeLacze);
krawedzie.Insert(wykorzystaneKrawedzie, pomocnicze);
}
wykorzystaneKrawedzie++;
liczbaOdwiedzonychWezlow++;
//no wiadomo krazy do czasu az wszystkie wierzcholki beda nalezaly do drzewa
}while (liczbaOdwiedzonychWezlow != wezly.Count);
// }
// catch (Exception)
// {
// brakPowodzenia = true;
// }
return(0);
}