Esempio n. 1
0
        public DP[] Szukaj(Graf graf, Wierzcholek start)
        {
            DP[] dp;
            List <Wierzcholek> q, s;
            Wierzcholek        aktualny;
            int i, j;

            q = new List <Wierzcholek>();
            s = new List <Wierzcholek>();

            q.AddRange(graf.Wierzcholki);
            dp = new DP[q.Count];
            InicjalizujDP(dp, q);

            while (q.Count > 0)
            {
                i        = ZnajdzIndeksMinimalny(dp, q);
                aktualny = dp[i].Wierzcholek;
                q.Remove(aktualny);
                s.Add(aktualny);

                foreach (WierzcholekKoszt sasiad in Sasiedzi(aktualny, q))
                {
                    j = ZnajdzIndeksWiercholka(dp, sasiad.Wierzcholek);

                    if (dp[j].Koszt > (dp[i].Koszt + sasiad.Koszt))
                    {
                        dp[j].Koszt      = dp[i].Koszt + sasiad.Koszt;
                        dp[j].Poprzednik = i;
                    }
                }
            }

            return(dp);
        }
        // metoda pomocnicza usuwająca krawędź (usuwa krawędź A -> B oraz B -> A)
        private void UsunKrawedz(Wierzcholek wierzcholek, Krawedz krawedz, int i)
        {
            Krawedz symetryczna;

            wierzcholek.Krawedzie.RemoveAt(i);
            symetryczna = krawedz.Cel.Krawedzie.Find((w) => w.Cel == wierzcholek);
            krawedz.Cel.Krawedzie.Remove(symetryczna);
        }
        // metoda prywatna szukająca cyklu rekurencyjnie
        private void ZnajdzCyklRekurencyjnie(Wierzcholek wierzcholek, ref List <Wierzcholek> rezultat)
        {
            Krawedz krawedz;

            while (wierzcholek.Krawedzie.Count > 0)
            {
                krawedz = wierzcholek.Krawedzie[0];
                UsunKrawedz(wierzcholek, krawedz, 0);
                ZnajdzCyklRekurencyjnie(krawedz.Cel, ref rezultat);
            }

            rezultat.Add(wierzcholek);
        }
Esempio n. 4
0
        private int ZnajdzIndeksWiercholka(DP[] dp, Wierzcholek wierzcholek)
        {
            int i;

            for (i = 0; i < dp.Length; i++)
            {
                if (dp[i].Wierzcholek == wierzcholek)
                {
                    return(i);
                }
            }

            throw new InvalidOperationException();
        }
        // metoda publiczna zwracająca listę wierzchołków wchodzących w skład cyklu
        public List <Wierzcholek> ZnajdzCykl(Graf graf, Wierzcholek poczatek)
        {
            List <Wierzcholek> rezultat;

            rezultat = new List <Wierzcholek>();

            if (!graf.PosiadaCyklEulera())
            {
                UzupelnijNieparzysteKrawedzie(graf);
            }

            ZnajdzCyklRekurencyjnie(poczatek, ref rezultat);

            return(rezultat);
        }
Esempio n. 6
0
        public List <Wierzcholek> Szukaj(Graf graf, Wierzcholek start, Wierzcholek stop)
        {
            DP[] dp;
            List <Wierzcholek> sciezka;
            int i;

            dp      = Szukaj(graf, start);
            i       = ZnajdzIndeksWiercholka(dp, stop);
            sciezka = new List <Wierzcholek>();

            while (i != -1)
            {
                sciezka.Insert(0, dp[i].Wierzcholek);
                i = dp[i].Poprzednik;
            }

            return(sciezka);
        }
Esempio n. 7
0
        private IEnumerable <WierzcholekKoszt> Sasiedzi(Wierzcholek aktualny, List <Wierzcholek> q)
        {
            Wierzcholek nastepny;

            foreach (Krawedz krawedz in aktualny.Krawedzie)
            {
                nastepny = krawedz.Cel;

                if (q.Contains(nastepny))
                {
                    yield return(new WierzcholekKoszt()
                    {
                        Wierzcholek = nastepny,
                        Koszt = krawedz.Waga
                    });
                }
            }
        }
Esempio n. 8
0
        // dodaje krawędź do grafu
        public void DodajKrawedz(string a, string b, double waga)
        {
            Wierzcholek wierzcholekA, wierzcholekB;

            wierzcholekA = wierzcholki.Find((w) => w.Nazwa == a);
            wierzcholekB = wierzcholki.Find((w) => w.Nazwa == b);

            if (wierzcholekA == null)
            {
                wierzcholekA = new Wierzcholek(a);
                wierzcholki.Add(wierzcholekA);
            }

            if (wierzcholekB == null)
            {
                wierzcholekB = new Wierzcholek(b);
                wierzcholki.Add(wierzcholekB);
            }

            wierzcholekA.DodajKrawedz(wierzcholekB, waga);
            wierzcholekB.DodajKrawedz(wierzcholekA, waga);
        }
Esempio n. 9
0
 // dodaje krawędź
 public void DodajKrawedz(Wierzcholek cel, double waga)
 {
     krawedzie.Add(new Krawedz(cel, waga));
 }