//inicjalizacja odbiorców
public void button1_Click(object sender, EventArgs e)
{
//wczytanie pliku
OpenFileDialog fdb = new OpenFileDialog();
fdb.Filter = "BRITE files (*.brite)|*.brite|txt files (*.txt)|*.txt|All files (*.*)|*.*";
System.Windows.Forms.DialogResult result = fdb.ShowDialog();
if (result == System.Windows.Forms.DialogResult.OK)
{
textBox1.Text = fdb.FileName;
}
//odczytanie ilości węzłów z pliku
System.IO.StreamReader file = new System.IO.StreamReader(textBox1.Text);
ile_node = Convert.ToInt32(file.ReadLine());
//utworzenie grafu z modelem sieci i inicjalizacja obiektu
graf = new siec[ile_node];
for (int i = 0; i < ile_node; i++)
graf[i] = null;
siec temp3 = new siec();
//wczytanie grafu z pliku
graf = temp3.wczytaj(textBox1.Text);
file.Close();
////test wczytania/////
for (int i = 0; i < ile_node; i++) //wyswietla Lsonsiadow
{
Debug.Write("graf[" + i + "] =");
temp3 = graf[i];
while (temp3 != null)
{
Debug.Write(temp3.to + " ");
temp3 = temp3.next;
}
Debug.WriteLine("");
}//////////////////////////////////koniec wyswietla
odbiorcy[0] = Convert.ToInt16(textBox4.Text); ;
for (int i = 1; i <= Convert.ToInt16(numericUpDown1.Value); i++)
{
var txtBox = this.Controls.Find("textBox" + (i + 4), true);
odbiorcy[i] = Convert.ToInt16(txtBox[0].Text);
}
}
//metoda - wywołanie algorytmu KPP
public void KPP(int nadawca, int[] odbiorcy, int ile_PC, siec[] graf, int n, int delta)
{
int licz = (ile_PC * (ile_PC - 1)) / 2, sc = 0;
double koszt, opuzn;
siec[] lista_sciezek = new siec[licz];
siec pomoc = new siec();
siec nowy2;
odbiorcy[0] = nadawca;
///////////////////////////////////////// Krok 1 ////////////////////////////////////////////////
#region
/////////////////konstrukcja spujnego nieskierowanego grafu N' //////////////////////////
///skladajacego sie z wszystkich odbiorcow i nadawcowi sciezek o najnizszym koszczie////
for (int i = 0; i < ile_PC; i++)
{
for (int j = i + 1; j < ile_PC; j++)
{
lista_sciezek[sc] = pomoc.sciezka(odbiorcy[i], odbiorcy[j], n, graf,"cost"); //obliczam sciezki
sc++;
}
}
/////////////////////////rozwijam graf do grafu pełnego nieskierowanego//////////////////
int b = 0, c = 0;
siec[] graf_kpp = new siec[n];
for (int i = 0; i < n; i++)
graf_kpp[i] = null;
for (int i = 0; i < licz; i++)
{
pomoc = lista_sciezek[i];
b = pomoc.to;
koszt = 0;
opuzn = 0;
while (pomoc != null)
{
koszt = koszt + pomoc.cost;
opuzn = opuzn + pomoc.delay;
if (pomoc.next == null) c = pomoc.from;
pomoc = pomoc.next;
}
siec nowy1 = new siec(koszt, opuzn, c, b, i, graf_kpp[b]);
graf_kpp[b] = nowy1;
}
///////////////////////////////////////////KROK 1 koniec/////////////////////////////////////////
#endregion
////////////////////////////////////////// KROK 2 //////////////////////////////////////////////
#region
//////////////////////obliczenie minimalnego drzewa spinajacego z grafu kpp
//////////////////////metryka jest delay
bool[] vis = new bool [n] ; //wierzcholek odwiedzony
double[] waga = new double[n]; //delay polaczenia
double[] waga_k = new double[n]; //koszt
HashSet<siec>kopiec = new HashSet<siec>();
//Dictionary<siec, siec> kopiec = new Dictionary<siec,siec>(n);
for(int i=0; i<n; i++)
{
waga_k[i]=0;
waga[i]= 0; //inicjowanie tablic
vis[i]= false;
}
int v = 0;
double waga_mst = 0;
siec[] mst = new siec[n];
for (int i = 0; i < n; i++)
mst[i] = null;
vis[0] = true; //wierzcholek startowy (nadawca)
waga[odbiorcy[0]] = 0;
waga_k[odbiorcy[0]] = 0;
kopiec.Clear();
for (pomoc = graf_kpp[odbiorcy[0]]; pomoc != null; pomoc = pomoc.next) //dodanie nie odwiedzonych sasiadow do kopca
{
nowy2 = new siec(pomoc);
kopiec.Add(nowy2);
}
while (kopiec.Count >0) //glowna petla mst
{
pomoc = kopiec.FirstOrDefault().ja;
if (vis[pomoc.to]==false)
{
if (waga[pomoc.to] + pomoc.delay < delta)
{
vis[pomoc.to] = true; //dodaje nowa krawedz do drzewa
waga[pomoc.to] = pomoc.delay;
waga_k[pomoc.to] = waga_k[pomoc.to] + pomoc.cost;
//nowy2 = new wezel(pomoc->koszt, pomoc->delay, pomoc->pi, pomoc->v, pomoc->id, mst[pomoc->v] );
//mst[pomoc->v]=nowy2;
nowy2 = new siec(pomoc.cost, pomoc.delay, pomoc.to, pomoc.from, pomoc.id, mst[pomoc.from]);
mst[pomoc.from] = nowy2;
v = pomoc.to;
}//else
//{
//kopiec.erase(kopiec.begin()); //usowam 1 element kopca
// warunek = false;
//}
}
//if(warunek){
kopiec.Remove(kopiec.FirstOrDefault());
//kopiec.erase(kopiec.begin()); //usowam 1 element kopca
for (pomoc = graf_kpp[v]; pomoc != null; pomoc = pomoc.next) //dodaje nie odwiedzonych sasiadow do kopca
{
if (vis[pomoc.to]==false)
{
nowy2 = new siec(pomoc);
kopiec.Add(nowy2);
}
}
//}
//warunek=true;
}
///////////////////////////////////////////KROK 2 KONIEC///////////////////////////////////////////////////////
#endregion
////////////////////////////////////////// KROK 3 //////////////////////////////////////////////
#region
///////////////Zastąp krawędzie powstałego drzewa oryginalnymi z grafu z modelem sieci/////////////////////////
bool [][] kontrolka = new bool[n][];
for (int i = 0; i < n; i++)
{
kontrolka[i] = new bool[n];
}
//zerowanie kontrolki
for(int f=0; f<n; f++)
{
for(int h=0; h<n; h++)
{
kontrolka[f][h]=false;
}
}
siec pomoc2=new siec();
siec[] mst2 = new siec[n];
int iterator;
for(int i=0; i<n; i++)
{
mst2[i]= null;
}
for (int i = 0; i < n; i++) //odtwarzam pierwotne mst
{
for (pomoc = mst[i]; pomoc != null; pomoc = pomoc.next) //dla kazdego graf_mst
{
iterator = 0;
b = pomoc.from;
c = -1;
while (lista_sciezek[iterator].to != b || pomoc.to != c)
{
if (lista_sciezek[iterator].to != b)
{
iterator++;
}
else
{
for (pomoc2 = lista_sciezek[iterator]; pomoc2 != null; pomoc2 = pomoc2.next) //wyszukiwanie krawedzi w liscie sciezek
{
if (pomoc2.next == null && pomoc2.from == pomoc.to) c = pomoc2.from;
}
if (c == -1)
{
iterator++;
}
}
}
for (pomoc2 = lista_sciezek[iterator]; pomoc2 != null; pomoc2 = pomoc2.next)
{
if (kontrolka[pomoc2.from][pomoc2.to] != true && kontrolka[pomoc2.to][pomoc2.from] != true)
{
nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.from, pomoc2.to, pomoc2.id, mst2[pomoc2.to]); //tworzenie nowej krawedzi
mst2[pomoc2.to] = nowy2;
nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.to, pomoc2.from, pomoc2.id, mst2[pomoc2.from]);
mst2[pomoc2.from] = nowy2;
kontrolka[pomoc2.to][pomoc2.from] = true;
kontrolka[pomoc2.from][pomoc2.to] = true;
}
}
}
}
//////////////////////////////////////////////////KROK 3 KONIEC//////////////////////////////////////////////////////////////
#endregion
///////////////////////////////////Zapis wyniku do pliku////////////////////////////////////////
#region
double delay_mst = 0;
System.IO.StreamWriter plik = new System.IO.StreamWriter(@"KPP.txt");
for (int f = 0; f < n; f++)
{ //zerowanie kontrolki
for (int h = 0; h < n; h++)
{
kontrolka[f][h] = false;
}
}
for (int i = 0; i < n; i++) //wyswietla Lsonsiadow graf_kpp
{
pomoc = mst2[i];
if (pomoc!=null)
{
while (pomoc !=null)
{
if (kontrolka[pomoc.from][pomoc.to] != true && kontrolka[pomoc.to][pomoc.from] != true)
{
waga_mst = waga_mst + pomoc.cost;
delay_mst = delay_mst + pomoc.delay;
kontrolka[pomoc.to][pomoc.from] = true;
kontrolka[pomoc.from][pomoc.to] = true;
}
pomoc = pomoc.next;
}
}
}
Debug.Write("\n");
Debug.Write("Koszt drzewa multicast wynosi = ");
Debug.Write(waga_mst);
Debug.Write("\n");
Debug.Write("\n");
Debug.Write("\n");
Debug.Write("DRZEWO MULTICAST ");
Debug.Write("\n");
Debug.Write("\n");
plik.WriteLine("\n" + "delta = " + delta+ "\n");
plik.WriteLine( "\n" + "Koszt drzewa multicast wynosi = "+waga_mst + "\n");
plik.WriteLine("\n" + "Nadawca = " + odbiorcy[0] + "\n");
plik.Write("Odbiorcy = ");
for (int i = 1; i < odbiorcy.Count(); i++)
{
plik.Write(odbiorcy[i] + ", ");
}
plik.WriteLine("");
plik.WriteLine("");
plik.WriteLine("\n" + "DRZEWO MULTICAST " + "\n");
for (int i = 0; i < n; i++) //wyswietla Lsonsiadow graf_kpp
{
pomoc = mst2[i];
if (pomoc!=null)
{
Debug.Write("DTM[");
Debug.Write(i);
Debug.Write("] =");
plik.Write("DTM[" + i + "] ->");
while (pomoc!=null)
{
Debug.Write(" "+ pomoc.to+" ");
plik.Write(" "+pomoc.to+" ");
pomoc = pomoc.next;
}
Debug.Write( "\n");
plik.WriteLine("");
}
}
Debug.Write("\n");
plik.Close();
#endregion
MessageBox.Show("Koszt drzewa transmisji grupowej wynosi: " + Convert.ToString(waga_mst) + " \n " + Convert.ToString(delay_mst));
}
//metoda - wywołanie algorytmu CSPT
public void CSPT(int nadawca, int[] odbiorcy, int ile_PC, siec[] graf, int n, int delta)
{
int sc = 0;
odbiorcy[0] = nadawca;
bool[] w_dodane = new bool[ile_PC]; //węzły które spełniały wymogi delta, dodane do grafu w pierwszym kroku
siec[] lista_sciezek = new siec[ile_PC - 1]; //lista krok 1
siec[] lista_sciezek2 = new siec[ile_PC - 1]; //lista krok 2
siec[] lista_sciezek3 = new siec[ile_PC - 1]; //lista krok 3
siec pomoc = new siec();
siec pomoc2 = new siec();
for (int i = 0; i < ile_PC - 1; i++)
{
lista_sciezek[i] = null;
lista_sciezek2[i] = null;
lista_sciezek3[i] = null;
}
//////////////////////////////// KROK 1 ////////////////////////////////////////////
// Obliczanie mst zawierającego ściezki do odbiorców, które spełniaja założone delta
//Metryką obliczania mst jest koszt scieżki
#region
for (int i = 0; i < w_dodane.Length; i++)
{
w_dodane[i] = false;
}
w_dodane[0] = true; //węzeł nadawczy musi byc dodany do drzewa
double delay;
for (int j = 1; j < ile_PC; j++)
{
delay = 0;
pomoc = pomoc.sciezka(odbiorcy[0], odbiorcy[j], n, graf, "cost");
for (pomoc2 = pomoc; pomoc2 != null; pomoc2 = pomoc2.next)
{
delay = delay + pomoc2.delay;
}
if (delay < delta)
{
lista_sciezek[sc] = pomoc; //obliczam sciezki
w_dodane[j] = true;
sc++;
}
}
Debug.WriteLine("");
///////////////////////////// KROK 1 KONIEC /////////////////////////////////////////
#endregion
///////////////////////////// KROK 2 ///////////////////////////////////////////////
// Obliczanie mst zawierającego ściezki nie obliczone w kroku 1
// Metryka obliczania mst jest opóźnienie ściezki
#region
for (int j = 0; j < ile_PC; j++)
{
if (w_dodane[j] == false)
{
delay = 0;
pomoc = pomoc.sciezka(odbiorcy[0], odbiorcy[j], n, graf, "delay");
lista_sciezek2[sc] = pomoc; //obliczam sciezki
w_dodane[j] = true;
sc++;
}
}
Debug.WriteLine("");
////////////////////////// KROK 2 KONIE ////////////////////////////////////////////
#endregion
////////////////////////// KROK 3 /////////////////////////////////////////////////
//Scalanie drzew z Kroku 1 i kroku 2
#region
for (int i = 0; i < ile_PC - 1; i++)
{
if (lista_sciezek[i] != null)
lista_sciezek3[i] = lista_sciezek[i];
if (lista_sciezek2[i] != null)
lista_sciezek3[i] = lista_sciezek2[i];
}
/////////////////////////////////////////////////////////////////////////////////
//Rozwijanie listy sciezek do grafu nieskierowanego
bool[][] kontrolka = new bool[n][];
for (int i = 0; i < n; i++)
{
kontrolka[i] = new bool[n];
}
//zerowanie kontrolki
for (int f = 0; f < n; f++)
{
for (int h = 0; h < n; h++)
{
kontrolka[f][h] = false;
}
}
siec[] mst = new siec[n];
siec nowy2;
for (int i = 0; i < n; i++)
{
mst[i] = null;
}
for (int i = 0; i < ile_PC - 1; i++)
{
for (pomoc2 = lista_sciezek3[i]; pomoc2 != null; pomoc2 = pomoc2.next)
{
if (kontrolka[pomoc2.from][pomoc2.to] != true && kontrolka[pomoc2.to][pomoc2.from] != true)
{
nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.from, pomoc2.to, pomoc2.id, mst[pomoc2.to]); //tworzenie nowej krawedzi
mst[pomoc2.to] = nowy2;
nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.to, pomoc2.from, pomoc2.id, mst[pomoc2.from]);
mst[pomoc2.from] = nowy2;
kontrolka[pomoc2.to][pomoc2.from] = true;
kontrolka[pomoc2.from][pomoc2.to] = true;
}
}
}
/////////////////////////////////////////////////// KROK 3 KONIEC////////////////////////////////////////////////
#endregion
////////////////////////////////////////////////// Zapis wyniku do pliku/////////////////////////////////////////
#region
System.IO.StreamWriter plik = new System.IO.StreamWriter(@"CSPT.txt");
double waga_cspt = 0, delay_cspt=0;
for (int f = 0; f < n; f++)
{ //zerowanie kontrolki
for (int h = 0; h < n; h++)
{
kontrolka[f][h] = false;
}
}
for (int i = 0; i < n; i++) //oblicza calkowity koszt drzewa multicast
{
pomoc = mst[i];
if (pomoc != null)
{
while (pomoc != null)
{
if (kontrolka[pomoc.from][pomoc.to] != true && kontrolka[pomoc.to][pomoc.from] != true)
{
waga_cspt = waga_cspt + pomoc.cost;
delay_cspt = delay_cspt + pomoc.delay;
kontrolka[pomoc.to][pomoc.from] = true;
kontrolka[pomoc.from][pomoc.to] = true;
}
pomoc = pomoc.next;
}
}
}
Debug.Write("\n");
Debug.Write("Koszt drzewa multicast wynosi = ");
Debug.Write(waga_cspt);
Debug.Write("\n");
Debug.Write("\n");
Debug.Write("\n");
Debug.Write("DRZEWO MULTICAST ");
Debug.Write("\n");
Debug.Write("\n");
plik.WriteLine("\n" + "delta = " + delta+ "\n");
plik.WriteLine("\n" + "Nadawca = " + odbiorcy[0] + "\n");
plik.Write("Odbiorcy = ");
for (int i = 1; i < odbiorcy.Count(); i++)
{
plik.Write(odbiorcy[i] + ", ");
}
plik.WriteLine("");
plik.WriteLine("");
plik.WriteLine("\n" + "DRZEWO MULTICAST " + "\n");
for (int i = 0; i < n; i++) //wyswietla Lsonsiadow graf_kpp
{
pomoc = mst[i];
if (pomoc != null)
{
Debug.Write("DTM[");
Debug.Write(i);
Debug.Write("] =");
plik.Write("DMT[" + i + "] ->");
while (pomoc != null)
{
Debug.Write(" " + pomoc.to + " ");
plik.Write(" " + pomoc.to + " ");
pomoc = pomoc.next;
}
Debug.Write("\n");
plik.WriteLine("");
}
}
Debug.Write("\n");
plik.Close();
#endregion
MessageBox.Show("Koszt drzewa transmisji grupowej wynosi: " + Convert.ToString(waga_cspt) + " \n " + Convert.ToString(delay_cspt));
}
public List<gen> Generowanie_YEN(siec[] graf, int ile_sciezek, int nadawca, int odbiorca)
{
List<gen> tab_r = new List<gen>(); //tablica routingu
List<gen> stos = new List<gen>(); // stos z potencjalnymi najkrutszymi ściezkami
List<siec> removed_node = new List<siec>(); //usuniete krawędzie
siec dijkastra = new siec();
siec pomoc, pomoc2, pomoc3,pomoc4;
List<int> root_path;
siec total_path =null, spur_path; //suma root_path i spur_path
siec spur_node;
int dlugosc_sciezki, usuwanie_nadawcy;
double koszt, opoznienie;
gen sciezka;
int sprawdzenie;
siec[] kopia_graf = siec.DeepCopy(graf);
koszt = 0;
opoznienie = 0;
pomoc4=dijkastra.sciezka(nadawca, odbiorca, graf.Count(), graf, "cost"); //obliczenie najkrutszej ścieżki
for (pomoc3 = pomoc4; pomoc3 != null; pomoc3 = pomoc3.next)
{
koszt = koszt + pomoc3.cost;
opoznienie = opoznienie + pomoc3.delay;
}
sciezka = new gen(pomoc4, koszt, opoznienie);
tab_r.Add(sciezka);
for (int k = 1; k < ile_sciezek; k++)//główny for ile sciezek trzeba wyznaczyć
{
dlugosc_sciezki = 0;
root_path = new List<int>(); //sciezka
spur_node = tab_r[k - 1].sciezka; //nowy wiezchołek startowy
root_path.Add(spur_node.to);
usuwanie_nadawcy = 0;
removed_node.Clear();
for (pomoc = tab_r[k - 1].sciezka; pomoc != null; pomoc = pomoc.next)//liczy ilość węzłów w ścieżce
{
dlugosc_sciezki++;
}
for(int i =0; i<dlugosc_sciezki; i++)//
{
for (int c = 0; c < tab_r.Count(); c++) //usuwa wszystkie krawędzie należące do tab_r z węzłem startowym spur_node z graf
{
for (pomoc2 = tab_r[c].sciezka; pomoc2 != null; pomoc2 = pomoc2.next)
{
if (spur_node.to == pomoc2.to) // && pour_node.from !=pomoc2.from
{
for (pomoc = kopia_graf[pomoc2.from]; pomoc != null; pomoc = pomoc.next)
{
if (spur_node.to == pomoc.to && pomoc.from == pomoc2.from)
{
if (pomoc.before == null)
{
kopia_graf[pomoc2.from] = pomoc.next;
if (kopia_graf[pomoc2.from] != null && kopia_graf[pomoc2.from].before != null)
{
kopia_graf[pomoc2.from].before = null;
}
break;
}
else
{
pomoc.before.next = pomoc.next;
if (pomoc.next != null)
{
pomoc.next.before = pomoc.before;
}
break;
}
}
} //for
for (pomoc = kopia_graf[pomoc2.to]; pomoc != null; pomoc = pomoc.next)
{
if (pomoc2.to == pomoc.from && pomoc2.from == pomoc.to)
{
if (pomoc.before == null)
{
kopia_graf[pomoc2.to] = pomoc.next;
if (kopia_graf[pomoc2.to] != null && kopia_graf[pomoc2.to].before != null)
{
kopia_graf[pomoc2.to].before = null;
}
break;
}
else
{
pomoc.before.next = pomoc.next;
if (pomoc.next != null)
{
pomoc.next.before = pomoc.before;
}
break;
}
}
} //for
}
if (i == 1&& usuwanie_nadawcy ==0)
{
int kontrolka = 0;
kopia_graf[nadawca] = null;
usuwanie_nadawcy = 1;
while (kontrolka < kopia_graf.Count())
{
for (pomoc = kopia_graf[kontrolka]; pomoc != null; pomoc = pomoc.next)
{
if (nadawca == pomoc.to)
{
if (pomoc.before == null)
{
kopia_graf[kontrolka] = pomoc.next;
if ( kopia_graf[kontrolka]!= null && kopia_graf[kontrolka].before != null)
{
kopia_graf[kontrolka].before = null;
}
break;
}
else
{
pomoc.before.next = pomoc.next;
if (pomoc.next != null)
{
pomoc.next.before = pomoc.before;
}
break;
}
}
}
kontrolka++;
}
}
}
}//koniec for usuwa
koszt = 0;
opoznienie = 0;
if (i == 0)
{
sciezka = new gen(dijkastra.sciezka(spur_node.to, odbiorca, kopia_graf.Count(), kopia_graf, "cost"), 0, 0);
if (sciezka.sciezka != null)
{
for (pomoc3 = sciezka.sciezka; pomoc3 != null; pomoc3 = pomoc3.next)
{
koszt = koszt + pomoc3.cost;
opoznienie = opoznienie + pomoc3.delay;
}
sciezka.cost = koszt;
sciezka.delay = opoznienie;
stos.Add(sciezka);
}
}
else
{
total_path = siec.DeepCopy(tab_r[k - 1].sciezka);
for (spur_path=total_path; spur_path.from != spur_node.to; spur_path = spur_path.next)
{
}
pomoc4=dijkastra.sciezka(spur_node.to, odbiorca, kopia_graf.Count(), kopia_graf, "cost");
spur_path.next = pomoc4;
if (spur_path.next == null)
{
break;
}
else
{
for (pomoc3 = total_path; pomoc3 != null; pomoc3 = pomoc3.next)
{
koszt = koszt + pomoc3.cost;
opoznienie = opoznienie + pomoc3.delay;
}
sciezka = new gen(total_path, koszt, opoznienie);
stos.Add(sciezka);
}
}
spur_node = spur_node.next;
if(spur_node!=null)
root_path.Add(spur_node.to);
// kopia_graf = siec.DeepCopy(kopia_graf);
}
kopia_graf = siec.DeepCopy(graf); //przywrucenie własności grafu
if (stos.Count() == 0)
{
break;
}
stos = stos.OrderBy(o => o.cost).ToList();
do
{
sprawdzenie = 0;
for (int spr = 0; spr < tab_r.Count(); spr++)
{
pomoc = tab_r[spr].sciezka;
if (stos.Count() != 0)
{
for (pomoc2 = stos.FirstOrDefault().sciezka; pomoc2 != null; pomoc2 = pomoc2.next)
{
if (pomoc.to == pomoc2.to && pomoc.from == pomoc2.from)
{
if (pomoc.next == pomoc2.next && pomoc.next == null && pomoc2.next == null)
{
stos.Remove(stos.FirstOrDefault());
sprawdzenie = 1;
break;
}
}else
{
break;
}
pomoc = pomoc.next;
if (pomoc == null)
{
break;
}
}
}
else
{
break;
}
if(sprawdzenie == 1)
{
break;
}
}
} while (sprawdzenie == 1);
if (stos.Count() == 0)
{
break;
}
tab_r.Add(stos.FirstOrDefault());
stos.Remove(stos.FirstOrDefault());
}//for główny
return tab_r;
}
public List<gen> Generowanie_BFS(siec[] graf, int ile_sciezek, int nadawca, int odbiorca)
{
List<siec> tab = new List<siec>();
List<gen> tab_r = new List<gen>(); //tablica routingu
bool[] vis = new bool[graf.Count()]; //kontrolka
List<int> kolejka = new List<int>(); //kolejka
List<int> gen = new List<int>(); //scieżka
siec node =new siec(); //krawędź
siec nw ;
int random = 0;
int koniec = nadawca;
int wczesniej = nadawca;
siec kopia;
int licz = 0, licz2=0;
while(licz2 <ile_sciezek)
{
kolejka.Clear();
tab.Add(null);
gen.Clear();
gen.Add(nadawca);
for (int i = 0; i < graf.Count(); i++) { vis[i] = false; } //zerowanie kontrolki
vis[nadawca] = true; //odwiedzony
for (node = graf[nadawca]; node != null; node = node.next) //dodanie sasiadow startu
{
if (vis[node.to] != true)
{
kolejka.Add(node.to);
}
} //for
do
{
while (kolejka.Count == 0 && koniec != odbiorca) //jak wejdzie w slepy zaulek
{
//cout<<gen.back();
gen.RemoveAt(gen.Count() - 1);
for (node = graf[gen[gen.Count - 1]]; node != null; node = node.next) //dodanie sasiadow startu
{
if (vis[node.to] != true)
{
kolejka.Add(node.to);
}
} //for
}
random = Multi.Form1.x.Next(0, kolejka.Count); //wylosowanie kolejnego allelu
node = graf[kolejka[random]];
koniec = kolejka[random];
gen.Add(kolejka[random]); //dodaj wylosowany wierzcholek do genu
vis[kolejka[random]] = true;
kolejka.Clear();
for (; node != null; node = node.next) //dodanie sasiadow wylosowanego wierzcholka
{
if (!vis[node.to])
{
kolejka.Add(node.to);
}
} //for
} while (koniec != odbiorca); //do while
int j = 0;
for (j = 1; j < gen.Count();j++ )
{
for (nw = graf[gen[j]]; nw != null; nw = nw.next)
{
if (nw.from == gen[j] && nw.to == gen[j - 1])
{
kopia = new siec(nw);
node = kopia;
node.next = tab[licz];
tab[licz] = node;
}
}
}
if (licz != 0)
{
for (int i = 0; i < tab.Count(); i++)
{
nw = tab[licz];
if (i != licz && nw !=null )
{
kopia = tab[i];
if (kopia != null)
{
while (kopia != null && nw !=null && kopia.to == nw.to )
{
nw = nw.next;
kopia = kopia.next;
if (nw == null && kopia == null)
{
tab.RemoveAt(licz);
licz--;
break;
}
}
}
}
}
}
licz++;
licz2++;
}//while główny
/*
Debug.WriteLine("");
for (int i = 0; i < tab_r.Count(); i++)
{
for (node = tab_r[i]; node != null; node = node.next)
{
Debug.Write(node.from + " -> ");
}
Debug.Write(nadawca);
Debug.WriteLine("");
}
*/
double koszt, opoznienie ;
siec pomoc;
gen sciezka;
for (int k = 0; k < tab.Count();k++ )
{
koszt = 0;
opoznienie = 0;
kopia = siec.DeepCopy(tab[k]);
for (pomoc = kopia; pomoc != null; pomoc = pomoc.next)
{
koszt = koszt + pomoc.cost;
opoznienie = opoznienie + pomoc.delay;
}
sciezka = new gen(kopia, koszt, opoznienie);
tab_r.Add(sciezka);
}
return tab_r;
}
public bool algorytm_genetyczny(int p_pocz, Int16 m_generowania, Int16 m_selekcji, Int16 m_krzyzowania, double p_mutacji, siec[] graf, int[] odbiorcy, int ile_sciezek, int ile_pokolen, int delta )
{
System.IO.StreamWriter plik = System.IO.File.AppendText(@"AG.txt");
System.IO.StreamWriter plikcsv = System.IO.File.AppendText(@"AG.csv");
List<List<gen>> l_tab_r = new List<List<gen>>(); //lista tablic routingu (baza genów)
List<gen> drzewo ; //drzewo transmisji multicas
List<osobnik> populacja = new List<osobnik>(); //populacja osobników
osobnik chromosom; //chromosom (drzewo transmisji)
List<int> wylosowani = new List<int>(); //lista wybranych do krzyżowania osobników
List<osobnik> dzieci = new List<osobnik>(); //lista dzieci
List<osobnik> dzieci_nowe = new List<osobnik>();
dzieci.Clear();
l_tab_r.Clear();
dzieci_nowe.Clear();
////////////////////////////// 1 Generowanie populacji poczatkowej//////////////////////////////////
#region
switch (m_generowania)
{
case 1://generuje tablice routingu przeszukując grf w szerz
int rand1 = 0;
populacja.Clear();
for (int i = 1; i < odbiorcy.Count(); i++)
{
l_tab_r.Add(Generowanie_BFS(graf, ile_sciezek, odbiorcy[0], odbiorcy[i]));
}
for (int j = 0; j < p_pocz; j++)
{
drzewo = new List<gen>(odbiorcy.Count()-1);
for (int i = 0; i < odbiorcy.Count() - 1; i++)
{
rand1 = Multi.Form1.x.Next(0, l_tab_r[i].Count());
drzewo.Add(siec.DeepCopy(l_tab_r[i][rand1]));
}
chromosom = new osobnik(drzewo, -1);
populacja.Add(chromosom);
}
/*
siec node;
for (int k = 0; k < populacja.Count(); k++)
{
Debug.WriteLine("");
Debug.WriteLine("Osobnik ("+k+")");
for (int i = 0; i < populacja[k].chromosom.Count(); i++)
{
for (node = populacja[k].chromosom[i].sciezka; node != null; node = node.next)
{
Debug.Write(node.from + " -> ");
}
Debug.Write(odbiorcy[0] + " " + populacja[k].chromosom[i].cost + " " + populacja[k].chromosom[i].delay);
Debug.WriteLine("");
}
}
Debug.WriteLine("Koniec_inicjacji");*/
break;
case 2:
populacja.Clear();
int rand2 = 0;
for (int i = 1; i < odbiorcy.Count(); i++)
{
l_tab_r.Add(Generowanie_YEN(graf, ile_sciezek, odbiorcy[0], odbiorcy[i]));
}
for (int j = 0; j < p_pocz; j++)
{
drzewo = new List<gen>(odbiorcy.Count()-1);
for (int i = 0; i < odbiorcy.Count() - 1; i++)
{
rand2 = Multi.Form1.x.Next(0, l_tab_r[i].Count());
drzewo.Add(siec.DeepCopy(l_tab_r[i][rand2]));
}
chromosom = new osobnik(drzewo, -1);
populacja.Add(chromosom);
}
/* siec node1;
for (int k = 0; k < populacja.Count(); k++)
{
Debug.WriteLine("");
Debug.WriteLine("Osobnik ("+k+")");
for (int i = 0; i < populacja[k].chromosom.Count(); i++)
{
for (node1 = populacja[k].chromosom[i].sciezka; node1 != null; node1 = node1.next)
{
Debug.Write(node1.to + " -> ");
if (node1.next == null) { Debug.Write(node1.from); }
}
Debug.Write(" " + populacja[k].chromosom[i].cost + " " + populacja[k].chromosom[i].delay);
Debug.WriteLine("");
}
}
Debug.WriteLine("Koniec_inicjacji");
*/
break;
}//Gen_populacji
#endregion//
///////////////////////////////////2 ocena populacji ///////////////////////////////////////////////
ocena_przyst(populacja, delta);
// for (int i = 0; i < populacja.Count(); i++) { Debug.WriteLine(populacja[i].przystosowanie); }
///////////////////////////////// 3 selekcja osobnikow///////////////////////////////////////////////
for (int ile_pok = 0; ile_pok < ile_pokolen; ile_pok++)
{
#region
switch (m_selekcji)
{
case 1:
wylosowani = selekcja_ruletka(populacja);
break;
case 2:
wylosowani = selekcja_turniej(populacja);
break;
case 3:
wylosowani = selekcja_ranking(populacja);
break;
}//selekcja
#endregion
/////////////////////////////////// 4 krzyżowanie ///////////////////////////////////////////////////
#region
switch (m_krzyzowania)
{
case 1:
dzieci.Clear();
dzieci = krzyzowanie_jednop(populacja, wylosowani, p_mutacji, l_tab_r);
break;
case 2:
dzieci.Clear();
dzieci = krzyzowanie_dwup(populacja, wylosowani, p_mutacji, l_tab_r);
break;
case 3:
dzieci.Clear();
dzieci = krzyzowanie_rownomierne(populacja, wylosowani, p_mutacji, l_tab_r);
break;
}//krzyżowanie
//sukcesja
#endregion
/////////////////////////////// 5 redukcja duplikatów //////////////////////////////////////////////
dzieci = redukcja_duplikatów(dzieci, l_tab_r);
populacja = sukcesja(dzieci, populacja);
ocena_przyst(populacja, delta);
}/////główna pętla iteracja pokoleń
populacja = populacja.OrderByDescending(o => o.przystosowanie).ToList();
/////////////////////////////////////6 zapis wyniku /////////////////////////////////////////////////
#region
begin:
double koszt = 0, opoznienie = 0; ;
siec pomoc = new siec();
siec pomoc2 = new siec();
int n = Convert.ToInt16(graf.Count());
siec[] lista_sciezek = new siec[odbiorcy.Count() - 1];
bool[][] kontrolka1 = new bool[n][];
for (int i = 0; i < n; i++)
{
kontrolka1[i] = new bool[n];
}
//zerowanie kontrolki
for (int f = 0; f < n; f++)
{
for (int h = 0; h < n; h++)
{
kontrolka1[f][h] = false;
}
}
siec[] mst = new siec[n];
siec nowy2;
for (int i = 0; i < n; i++)
{
mst[i] = null;
}
for (int i = 0; i < odbiorcy.Count() - 1; i++)
{
for (pomoc2 = populacja[0].chromosom[i].sciezka; pomoc2 != null; pomoc2 = pomoc2.next)
{
if (kontrolka1[pomoc2.from][pomoc2.to] != true && kontrolka1[pomoc2.to][pomoc2.from] != true)
{
nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.from, pomoc2.to, pomoc2.id, mst[pomoc2.to]); //tworzenie nowej krawedzi
mst[pomoc2.to] = nowy2;
nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.to, pomoc2.from, pomoc2.id, mst[pomoc2.from]);
mst[pomoc2.from] = nowy2;
kontrolka1[pomoc2.to][pomoc2.from] = true;
kontrolka1[pomoc2.from][pomoc2.to] = true;
}
}
}
int sc = 0;
for (int j = 1; j < odbiorcy.Count(); j++)
{
lista_sciezek[sc] = pomoc.sciezka(odbiorcy[0], odbiorcy[j], n, mst, "cost"); //obliczam sciezk
if (lista_sciezek[sc] == null)
{
plikcsv.WriteLine("zly wynik " + odbiorcy[j]);
populacja.RemoveAt(0);
goto begin;
}
sc++;
}
for (int i = 0; i < n; i++)
{
kontrolka1[i] = new bool[n];
}
siec[] mst2 = new siec[n];
for (int i = 0; i < n; i++)
{
mst2[i] = null;
}
for (int i = 0; i < lista_sciezek.Count(); i++)
{
for (pomoc2 = lista_sciezek[i]; pomoc2 != null; pomoc2 = pomoc2.next)
{
if (kontrolka1[pomoc2.from][pomoc2.to] != true && kontrolka1[pomoc2.to][pomoc2.from] != true)
{
nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.from, pomoc2.to, pomoc2.id, mst2[pomoc2.to]); //tworzenie nowej krawedzi
mst2[pomoc2.to] = nowy2;
nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.to, pomoc2.from, pomoc2.id, mst2[pomoc2.from]);
mst2[pomoc2.from] = nowy2;
kontrolka1[pomoc2.to][pomoc2.from] = true;
kontrolka1[pomoc2.from][pomoc2.to] = true;
}
}
}
for (int f = 0; f < n; f++)
{ //zerowanie kontrolki
for (int h = 0; h < n; h++)
{
kontrolka1[f][h] = false;
}
}
for (int i = 0; i < n; i++) //oblicza calkowity koszt drzewa multicast
{
pomoc = mst2[i];
if (pomoc != null)
{
while (pomoc != null)
{
if (kontrolka1[pomoc.from][pomoc.to] != true && kontrolka1[pomoc.to][pomoc.from] != true)
{
koszt = koszt + pomoc.cost;
opoznienie = opoznienie + pomoc.delay;
kontrolka1[pomoc.to][pomoc.from] = true;
kontrolka1[pomoc.from][pomoc.to] = true;
}
pomoc = pomoc.next;
}
}
}
Debug.Write("\n");
Debug.Write("Koszt drzewa multicast wynosi = ");
Debug.Write(koszt);
Debug.Write("\n");
Debug.Write("\n");
Debug.Write("\n");
Debug.Write("DRZEWO MULTICAST ");
Debug.Write("\n");
Debug.Write("\n");
plik.WriteLine("\n" + "delta = " + delta + "\n");
plik.WriteLine("\n" + "Koszt drzewa multicast wynosi = " + koszt + "\n");
plikcsv.WriteLine(koszt);
plik.WriteLine("\n" + "Nadawca = " + odbiorcy[0] + "\n");
plik.Write("Odbiorcy = ");
for (int i = 1; i < odbiorcy.Count(); i++)
{
plik.Write(odbiorcy[i] + ", ");
}
plik.WriteLine("");
plik.WriteLine("");
plik.WriteLine("\n" + "DRZEWO MULTICAST " + "\n");
for (int i = 0; i < n; i++) //wyswietla Lsonsiadow graf_kpp
{
pomoc = mst2[i];
if (pomoc != null)
{
Debug.Write("DMT[");
Debug.Write(i);
Debug.Write("] =");
plik.Write("DMT[" + i + "] ->");
while (pomoc != null)
{
Debug.Write(" " + pomoc.to + " ");
plik.Write(" " + pomoc.to + " ");
pomoc = pomoc.next;
}
Debug.Write("\n");
plik.WriteLine("");
}
}
Debug.Write("\n");
#endregion
Debug.WriteLine(koszt);
plik.Close();
plikcsv.Close();
return true;
// MessageBox.Show("Koszt drzewa transmisji grupowej wynosi: " + Convert.ToString(koszt) + " \n " + Convert.ToString(opoznienie));
}
public gen(siec sciezka, double koszt, double opoznienie)
{
this.sciezka = sciezka;
this.cost = koszt;
this.delay = opoznienie;
}
