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 void mutacja(double prawdop, List<gen> dzieco, List<List<gen>> tab_r)
{
prawdop =prawdop* 100;
int m,m2,p,p2,l;
m = Multi.Form1.x.Next(1, 101); //czy wystąpi mutacja
gen scie;
if(m<prawdop)
{
if (dzieco.Count() > 16) // losowanie ile mutacji wystąpi
{
l = Multi.Form1.x.Next(1, 3);
}
else { l = 1; }
if (l == 1) //jeśli 1 mutacja to
{
m = Multi.Form1.x.Next(0, dzieco.Count()); //który gen mutuje
p = Multi.Form1.x.Next(0, tab_r[m].Count() );
scie = new gen(tab_r[m][p].sciezka, tab_r[m][p].cost, tab_r[m][p].delay);
dzieco[m] = scie;
}
if (l == 2) //jeśli 1 mutacja to
{
m = Multi.Form1.x.Next(0, dzieco.Count()); //który gen mutuje
p = Multi.Form1.x.Next(0, tab_r[m].Count());
m2 = Multi.Form1.x.Next(0, dzieco.Count()); //który gen mutuje
p2 = Multi.Form1.x.Next(0, tab_r[m2].Count());
scie = new gen(tab_r[m][p].sciezka, tab_r[m][p].cost, tab_r[m][p].delay);
dzieco[m] = scie;
scie = new gen(tab_r[m2][p2].sciezka, tab_r[m2][p2].cost, tab_r[m2][p2].delay);
dzieco[m2] = scie;
}
}
}
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;
}
