Beispiel #1
0
        // dugme za Dajkstrin algoritam
        private async void dijkstraBtn_Click(object sender, EventArgs e)
        {
            var dijkstraObj = new Dijkstra(this);

            ucCanvas.reset_colors();                                        // stavljamo boje na default

            try
            {
                if (Platno.nodes.Any())                                     // ukoliko postoji makar jedan cvor Dajkstra moze da radi
                {
                    int pocetni;

                    while (true)
                    {
                        var nova = new cvorForma();
                        nova.ShowDialog();
                        if (nova.mNode == -1)
                        {
                            return;
                        }

                        pocetni = nova.mNode;
                        try
                        {
                            nodes.First(x => x.ID == pocetni);
                            break;
                        }
                        catch { MessageBox.Show("Izabrani čvor ne postoji. Birajte ponovo."); }
                    }

                    if (distanceForm != null)                                   // Gasimo vec postojece forme za put i rastojanje
                    {
                        distanceForm.Close();
                    }

                    if (traversalForm != null)
                    {
                        traversalForm.Close();
                    }
                    // Pravimo nove forme sa odgovarajucim koordinatama
                    distanceForm  = new resultsMatrices(dijkstraObj, Platno.numberOfNodes, 1, pocetni, this);
                    traversalForm = new resultsMatrices(dijkstraObj, Platno.numberOfNodes, 0, pocetni, this);

                    distanceForm.StartPosition  = FormStartPosition.Manual;
                    traversalForm.StartPosition = FormStartPosition.Manual;

                    distanceForm.Location  = new Point(50, 0);
                    traversalForm.Location = new Point(50, distanceForm.Height);

                    traversalForm.Show();
                    distanceForm.Show();

                    controlUI(false);                                                          // Kada pocinje da radi zabranimo koriscenje svih dugmadi i ostalog
                    var y = await Task.Run(() => dijkstraObj.dijkstraAlgorithm(pocetni));      // Cekamo da se algoritam zavrsi i ponovo dozvoljavamo koriscenje interfejsa

                    controlUI(y);
                }
                else
                {
                    throw new Exception();
                }
            } catch {
                MessageBox.Show("Graf je prazan.");                                             // Ukoliko je graf prazan ispisujemo poruku
            }
        }
Beispiel #2
0
        // Dugme za Floyd Warshallov algoritam
        private void floydBtn_Click(object sender, EventArgs e)
        {
            ucCanvas.reset_colors();                                                    // Resetujemo boje
            var noNodes = Platno.numberOfNodes;                                         // Makar dva cvora neophodna za pocetak rada

            if (noNodes < 2)
            {
                MessageBox.Show("Ubacite makar dva čvora, zatim pokušajte ponovo.");
                return;
            }

            warshallMatrix = new double[noNodes, noNodes];                              // Matrica rastojanja
            double[,] path = new double[noNodes, noNodes];                              // Matrica puta

            // Inicijalizacija tezinske matrice i matrice puta
            foreach (var i in nodes)
            {
                foreach (var j in nodes)
                {
                    var vr = i.weights.Find(x => x.Key == j.ID).Value;
                    if (i == j)
                    {
                        warshallMatrix[i.ID, j.ID] = 0;
                    }
                    else if (vr == 0)
                    {
                        warshallMatrix[i.ID, j.ID] = double.PositiveInfinity;
                    }
                    else
                    {
                        warshallMatrix[i.ID, j.ID] = vr;
                    }

                    if (i.Connected.Any(a => a == j.ID))
                    {
                        path[i.ID, j.ID] = j.ID;
                    }
                    else
                    {
                        path[i.ID, j.ID] = double.PositiveInfinity;
                    }
                }
            }


            for (int i = 0; i < noNodes; i++)
            {
                path[i, i] = i;
            }

            for (var i = 0; i < noNodes; i++)                                                           // Novi cvor preko koga se ide
            {
                for (var j = 0; j < noNodes; j++)                                                       // sledece dve petlje prolaze kroz sve puteve izmedju cvorova
                {
                    for (var k = 0; k < noNodes; k++)
                    {
                        if (warshallMatrix[j, k] > warshallMatrix[j, i] + warshallMatrix[i, k])         // pitamo se da li je kraci put preko novog cvora
                        {
                            warshallMatrix[j, k] = warshallMatrix[j, i] + warshallMatrix[i, k];         // ako jeste, on postaje novi put (distance)
                            path[j, k]           = path[j, i];                                          // dodajemo u putanju odgovarajuci cvor
                        }
                    }
                }
            }

            // Ako je ovu funkciju pozvalo dugme za Floyd-ov algoritam ispisujemo matricu rastojanja
            if (sender == floydBtn)
            {
                var resForm = new resultsMatrices(null, noNodes, 2, -1, this);
                resForm.Show();
            }
            else if (sender == prikazSredisteBtn)               // ukoliko ju je pozvalo dugme za srediste radimo sledece
            {
                var rowsMaxes = new List <double>(noNodes);     // lista maksimalnih vrednosti potrebna za odredjivanje sredista grafa

                for (var i = 0; i < noNodes; i++)
                {
                    // Ukoliko je rastojanje bilo plus beskonacno pretvaramo ga u minus beskonacno i dodajemo u listu, u suprotnom samo dodajemo pocetne vrednosti u listu
                    if (warshallMatrix[i, 0] == double.PositiveInfinity)
                    {
                        rowsMaxes.Add(double.NegativeInfinity);
                    }
                    else
                    {
                        rowsMaxes.Add(warshallMatrix[i, 0]);
                    }

                    // proveravamo da li u ostatku redova matrice postoji neka vrednost veca od odgovarajuce vrednosti u listi maksimalnih
                    // za odgovarajucu vrstu, ukoliko postoji onda ona postaje nova maksimalna vrednost
                    for (var j = 1; j < noNodes; j++)
                    {
                        if (warshallMatrix[i, j] > rowsMaxes[i] && warshallMatrix[i, j] != double.PositiveInfinity)
                        {
                            rowsMaxes[i] = warshallMatrix[i, j];
                        }
                    }
                }

                // inicijalizujemo minimalnu vrednost na prvi element liste
                var minValue = rowsMaxes[0];
                // ukoliko je slucajno prva vrednost bila -beskonacno trazimo prvu koja nije to i nju postavljamo kao minimalnu liste
                for (var i = 1; i < noNodes; i++)
                {
                    if (rowsMaxes[i] != double.NegativeInfinity)
                    {
                        minValue = rowsMaxes[i];
                        break;
                    }
                }

                // ako postoji vise sredista
                var sredistaLista = new List <int>();

                // gledamo da li postoji manja vrednost od nase prethodne, inicijalizovane
                for (var i = 0; i < noNodes; i++)
                {
                    if (rowsMaxes[i] == double.NegativeInfinity)
                    {
                        continue;
                    }

                    if (rowsMaxes[i] < minValue)
                    {
                        minValue = rowsMaxes[i];
                    }
                }

                StringBuilder sb = new StringBuilder();                         // pravimo poruku o sredistima grafa
                for (var i = 0; i < noNodes; i++)
                {
                    if (rowsMaxes[i] == minValue)                               // sredista su ako imaju minimalnu vrednost u nizu maksimalnih vrednosti svake vrste
                    {
                        ucCanvas.changeNodeColor(i, Color.Goldenrod, 0);        // menjamo im boju i dodajemo u poruku
                        sb.Append(" " + i.ToString());
                    }
                }

                MessageBox.Show("Središte grafa je čvor " + sb.ToString());     // ispis poruke
            }
            else                                                                // Ukoliko je funkcija pozvana od strane dugmeta za prikaz puta
            {
                var start  = int.Parse(prviCvorCb.SelectedItem.ToString());
                var end    = int.Parse(drugiCvorCb.SelectedItem.ToString());
                var travel = new List <int>();
                var noWay  = false;

                if (start == end)
                {
                    MessageBox.Show("Ne postoji najkraći put od čvora do samog sebe."); return;
                }

                // Prolazimo kroz matricu puta i u niz travel koji predstavlja ,,put'' od cvora start do end
                // dodajemo sve indekse ostalih cvorova preko kojih idemo
                travel.Add(start);
                while (start != end)
                {
                    if (path[start, end] == double.PositiveInfinity)
                    {
                        noWay = true; break;                                    // ukoliko naidjemo na +beskonacno ne postoji put od start do end cvora
                    }
                    start = (int)path[start, end];
                    travel.Add(start);
                }

                // ukoliko je put veci od jedan i postoji put od cvora do cvora promenicemo boje izmedju njih u suprotnom ne postoji put
                if (travel.Count != 1 && noWay == false)
                {
                    int i;
                    for (i = 0; i < travel.Count - 1; i++)
                    {
                        ucCanvas.changeConnectionColor(travel[i], travel[i + 1], Color.Orange, 0);
                    }
                    ucCanvas.changeConnectionColor(travel[i - 1], end, Color.Orange, 0);
                }
                else if (noWay == true)
                {
                    MessageBox.Show("Ne postoji put između odabranih čvorova."); return;
                }
            }
        }