ALGA/ALGA/Adatszerkezetek/12_SulyozottGraf.cs

using System;
using System.Security.Cryptography.X509Certificates;


namespace OE.ALGA.Adatszerkezetek
{
    public class SulyozottEgeszGrafEl : EgeszGrafEl, SulyozottGrafEl<int>
    {
        public float Suly {get;}
        public SulyozottEgeszGrafEl(int honnan, int hova, float suly) : base(honnan, hova)
        {
            Suly = suly;
        }


    }
    public class CsucsmatrixSulyozottEgeszGraf : SulyozottGraf<int, SulyozottEgeszGrafEl>
    {
        int n;
        float[,] M;
        public int CsucsokSzama {get{return n;}}

        public int ElekSzama 
        {
            get
            {
                int elek = 0;
                for (int i = 0; i < n; i++)
                {
                    for (int j = 0; j < n; j++)
                    {
                        if (M[i,j] != 0.0)
                        {
                            elek++;
                        }
                    }
                }
                return elek;
            }
        }
        public CsucsmatrixSulyozottEgeszGraf(int n)
        {
            this.n = n;
            M = new float[n,n];
        }
        public Halmaz<int> Csucsok
        {
            get
            {
                FaHalmaz<int> fahalmaz = new FaHalmaz<int>();
                for (int i = 0; i < n; i++)
                {
                    fahalmaz.Beszur(i);
                }
                return fahalmaz;
            }
        }

        public Halmaz<SulyozottEgeszGrafEl> Elek
        {
            get
            {
                FaHalmaz<SulyozottEgeszGrafEl> fahalmaz = new FaHalmaz<SulyozottEgeszGrafEl>();
                for (int i = 0; i < n; i++)
                {
                    for (int j = 0; j < n; j++)
                    {
                        if (M[i,j] != 0.0)
                        {
                            SulyozottEgeszGrafEl egeszgrafel = new SulyozottEgeszGrafEl(i, j, M[i,j]);
                            fahalmaz.Beszur(egeszgrafel);
                        }
                    }
                }
                return fahalmaz;
            }
        }

        public float Suly(int honnan, int hova)
        {
            if(M[honnan, hova] != 0.0)
            {
                return M[honnan, hova];
            }
            else
            {
                throw new NincsElKivetel();
            }
        }

        public Halmaz<int> Szomszedai(int csucs)
        {
            FaHalmaz<int> fahalmaz = new FaHalmaz<int>();
            for (int i = 0; i < n; i++)
            {
                if (M[csucs, i] != 0.0)
                {
                    fahalmaz.Beszur(i);
                }
            }
            return fahalmaz;
        }

        public void UjEl(int honnan, int hova, float suly)
        {
            M[honnan, hova] = suly;
        }

        public bool VezetEl(int honnan, int hova)
        {
            return (M[honnan, hova]!= 0.0);        
        }
    }
    public class Utkereses
    {
        public static Szotar<V, float> Dijkstra<V, E>(SulyozottGraf<V, E> g, V start) where V: IComparable
        {
            Szotar<V, float> legrovidebb = new HasitoSzotarTulcsordulasiTerulettel<V, float>(g.CsucsokSzama);
            Szotar<V, V> P = new HasitoSzotarTulcsordulasiTerulettel<V,V>(g.CsucsokSzama);
            KupacPrioritasosSor<V> S = new KupacPrioritasosSor<V>(g.CsucsokSzama, (ez, ennel) => legrovidebb.Kiolvas(ez) < legrovidebb.Kiolvas(ennel));

            g.Csucsok.Bejar(x =>
            {
                legrovidebb.Beir(x, int.MaxValue);
                S.Sorba(x);
            });

            legrovidebb.Beir(start, 0);
            S.Frissit(start);

            while(!S.Ures)
            {
                V u = S.Sorbol();
                
                g.Szomszedai(u).Bejar(x =>
                {
                    if(legrovidebb.Kiolvas(u) + g.Suly(u,x) < legrovidebb.Kiolvas(x))
                    {
                        legrovidebb.Beir(x, legrovidebb.Kiolvas(u) + g.Suly(u,x));
                        P.Beir(x, u);
                        S.Frissit(x);
                    }
                });
            }
            return legrovidebb;
        }
    }

    public class FeszitofaKereses
    {
        public static Szotar<V, V> Prim<V, E>(SulyozottGraf<V, E> g, V start) where V: IComparable
        {
            Szotar<V, float> feszito = new HasitoSzotarTulcsordulasiTerulettel<V, float>(g.CsucsokSzama);
            Szotar<V, V> P = new HasitoSzotarTulcsordulasiTerulettel<V,V>(g.CsucsokSzama);
            KupacPrioritasosSor<V> S = new KupacPrioritasosSor<V>(g.CsucsokSzama, (ez, ennel) => feszito.Kiolvas(ez) < feszito.Kiolvas(ennel));
            FaHalmaz<V> helper = new FaHalmaz<V>();
            g.Csucsok.Bejar(x =>
            {
                feszito.Beir(x, int.MaxValue);
                S.Sorba(x);
                helper.Beszur(x);
            });
            feszito.Beir(start, 0);
            S.Frissit(start);

            while(!S.Ures && helper.gyoker != null)
            {
                V minimum = S.Sorbol();
                helper.Torol(minimum);

                g.Szomszedai(minimum).Bejar(x =>
                {
                    if(helper.Eleme(x) && g.Suly(x, minimum) < feszito.Kiolvas(x))
                    {
                        feszito.Beir(x, g.Suly(x, minimum));
                        P.Beir(x, minimum);
                    }
                });

            }

            return P;
        }

        public static Halmaz<E> Kruskal<V, E>(SulyozottGraf<V, E> g) where E: SulyozottGrafEl<V>, IComparable
        {
            Szotar<V, int> vhalmaz = new HasitoSzotarTulcsordulasiTerulettel<V, int>(g.CsucsokSzama);
            FaHalmaz<E> A = new FaHalmaz<E>();
            PrioritasosSor<E> S = new KupacPrioritasosSor<E>(g.ElekSzama, (ez, ennel) => ez.Suly < ennel.Suly); 
            int i = 0;
            g.Csucsok.Bejar(x =>
            {
               vhalmaz.Beir(x, i++);
            });
            g.Elek.Bejar(x =>
            {
               S.Sorba(x); 
            });

            while(!S.Ures)
            {
                E minimum = S.Sorbol();

                if (vhalmaz.Kiolvas(minimum.Honnan) != vhalmaz.Kiolvas(minimum.Hova))
                {
                    A.Beszur(minimum);
                    int h = vhalmaz.Kiolvas(minimum.Honnan);
                    g.Csucsok.Bejar(x =>
                    {
                        if(h == vhalmaz.Kiolvas(x))
                        {
                            vhalmaz.Beir(x, vhalmaz.Kiolvas(minimum.Hova));
                        }
                    });
                }
            }

            return A;
        }
    }
}