예제 #1
0
파일: Program.cs 프로젝트: wardasz/sem3
        public static List <int> DFS(List <wierzcholek> lista, int start)
        {
            List <int> rozwiazanie = new List <int>();
            List <int> stos        = new List <int>();

            stos.Add(start);
            rozwiazanie.Add(start);
            wybierzWierzcholek(lista, start).odwiedz();
            while (stos.Count > 0)
            {
                wierzcholek obecny   = wybierzWierzcholek(lista, stos.Last());
                List <int>  sasiedzi = obecny.dajSasiadow();
                bool        znalazl  = false;
                foreach (int i in sasiedzi)
                {
                    wierzcholek nowy = wybierzWierzcholek(lista, i);
                    if (nowy.CzyOdwiedzony() == false)
                    {
                        znalazl = true;
                        nowy.odwiedz();
                        stos.Add(nowy.dajNumer());
                        rozwiazanie.Add(nowy.dajNumer());
                        break;
                    }
                }
                if (znalazl == false)
                {
                    stos.Remove(stos.Last());
                }
            }
            return(rozwiazanie);
        }
예제 #2
0
 public int porownaj(wierzcholek a)
 {
     if (stopienAkt > a.dajAktualny())
     {
         return(-1);
     }
     else
     {
         return(1);
     }
 }
예제 #3
0
        public static void usun(List <wierzcholek> drzewo, krawedz k)
        {
            int         a = k.dajA();
            int         b = k.dajB();
            wierzcholek A = wybierzWierzcholek(drzewo, a);
            wierzcholek B = wybierzWierzcholek(drzewo, b);

            A.usunSasiada(b);
            B.usunSasiada(a);
            if (A.dajSasiadow().Count == 0)
            {
                drzewo.Remove(A);
            }
            if (B.dajSasiadow().Count == 0)
            {
                drzewo.Remove(B);
            }
        }
예제 #4
0
        public static void usunKrawedz(List <wierzcholek> lista, int a, int b)
        {
            Console.WriteLine("Usuwam krawędź " + a + "-" + b);
            wierzcholek roboczy = wybierzWierzcholek(lista, a);

            roboczy.usunSasiada(b);
            if (roboczy.dajStopien() == 0)
            {
                lista.Remove(roboczy);
                Console.WriteLine("Usuwam wierzcholek " + a);
            }

            roboczy = wybierzWierzcholek(lista, b);
            roboczy.usunSasiada(a);
            if (roboczy.dajStopien() == 0)
            {
                lista.Remove(roboczy);
                Console.WriteLine("Usuwam wierzcholek " + b);
            }
        }
예제 #5
0
        public static void dodaj(List <wierzcholek> drzewo, krawedz k)
        {
            int         a = k.dajA();
            int         b = k.dajB();
            wierzcholek A = wybierzWierzcholek(drzewo, a);
            wierzcholek B = wybierzWierzcholek(drzewo, b);

            if (A == null)
            {
                A = new wierzcholek(a);
                drzewo.Add(A);
            }
            if (B == null)
            {
                B = new wierzcholek(b);
                drzewo.Add(B);
            }
            A.dodajSasiada(b);
            B.dodajSasiada(a);
        }
예제 #6
0
        public static bool czySpojny(List <wierzcholek> lista)
        {
            if (lista.Count == 0)
            {
                return(true);
            }
            if (lista.Count != 0 && wybierzWierzcholek(lista, 1) == null)
            {
                return(false);
            }

            List <int> kolejka = new List <int>();
            List <int> zbadane = new List <int>();

            kolejka.Add(1);
            zbadane.Add(1);
            while (kolejka.Count > 0)
            {
                wierzcholek obecny   = wybierzWierzcholek(lista, kolejka.ElementAt(0));
                List <int>  sasiedzi = obecny.dajSasiadow();
                foreach (int i in sasiedzi)
                {
                    if (czyNaLiscie(zbadane, i) == false)
                    {
                        kolejka.Add(i);
                        zbadane.Add(i);
                    }
                }
                kolejka.Remove(kolejka.ElementAt(0));
            }
            if (zbadane.Count == lista.Count)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
예제 #7
0
        public static void dodajKrawedz(List <wierzcholek> lista, int a, int b)
        {
            Console.WriteLine("Dodaje krawędź " + a + "-" + b);
            wierzcholek roboczy = wybierzWierzcholek(lista, a);

            if (roboczy == null)
            {
                roboczy = new wierzcholek(a);
                lista.Add(roboczy);
                Console.WriteLine("Dodaje wierzcholek " + a);
            }
            roboczy.dodajSasiada(b);

            roboczy = wybierzWierzcholek(lista, b);
            if (roboczy == null)
            {
                roboczy = new wierzcholek(b);
                lista.Add(roboczy);
                Console.WriteLine("Dodaje wierzcholek " + b);
            }
            roboczy.dodajSasiada(a);
        }
예제 #8
0
        public static bool czyCykl(List <wierzcholek> drzewo, int i)
        {
            foreach (wierzcholek w in drzewo)
            {
                w.odznacz();
            }
            List <int> kolejka = new List <int>();

            kolejka.Add(i);
            int ileWiezcholkow = 0;
            int ileKrawedzi    = 0;

            while (kolejka.Count != 0)
            {
                wierzcholek sprawdzany = wybierzWierzcholek(drzewo, kolejka.ElementAt(0));
                if (sprawdzany.CzyOdwiedzony() == false)
                {
                    ileWiezcholkow++;
                    ileKrawedzi += sprawdzany.dajSasiadow().Count;
                    foreach (int x in sprawdzany.dajSasiadow())
                    {
                        kolejka.Add(x);
                    }
                    sprawdzany.odwiedz();
                }
                kolejka.Remove(kolejka.ElementAt(0));
            }
            ileKrawedzi = ileKrawedzi / 2;
            ileWiezcholkow--;
            if (ileWiezcholkow == ileKrawedzi)
            {
                return(false);
            }
            else
            {
                return(true);
            }
        }
예제 #9
0
파일: Program.cs 프로젝트: wardasz/sem3
        public static List <int> DFS(List <wierzcholek> lista)
        {
            List <int> rozwiazanie = new List <int>();

            List <int>  stos   = new List <int>();
            wierzcholek obecny = lista.ElementAt(0);

            stos.Add(obecny.dajNumer());
            rozwiazanie.Add(obecny.dajNumer());
            while (stos.Count > 0)
            {
                List <int> sasiedzi = obecny.dajSasiadow();
                bool       znalazl  = false;
                foreach (int i in sasiedzi)
                {
                    wierzcholek nowy = wybierzWierzcholek(lista, i);
                    if (czyWybrany(rozwiazanie, nowy.dajNumer()) == false)
                    {
                        znalazl = true;
                        stos.Add(nowy.dajNumer());
                        rozwiazanie.Add(nowy.dajNumer());
                        obecny = nowy;
                        break;
                    }
                }
                if (znalazl == false)
                {
                    stos.Remove(stos.Last());
                    if (stos.Count > 0)
                    {
                        obecny = wybierzWierzcholek(lista, stos.Last());
                    }
                }
            }

            return(rozwiazanie);
        }
예제 #10
0
        static void Main(string[] args)
        {
            List <List <int> > macierz = new List <List <int> >();

            var    s       = new FileInfo(Directory.GetCurrentDirectory());
            var    s2      = s.Directory.Parent.Parent;
            String sciezka = s2.ToString() + "\\dane.csv";

            using (var reader = new StreamReader(sciezka))
            {
                while (!reader.EndOfStream)
                {
                    var        line   = reader.ReadLine();
                    var        values = line.Split(',');
                    List <int> zad    = new List <int>();
                    for (int x = 0; x < values.Length; x++)
                    {
                        zad.Add(Convert.ToInt32(values[x]));
                    }
                    macierz.Add(zad);
                }
            }

            bool flaga = true;

            for (int x = 1; x <= macierz.Count; x++)
            {
                for (int y = x + 1; y <= macierz.Count; y++)
                {
                    int jeden = dajPole(macierz, x, y);
                    int dwa   = dajPole(macierz, y, x);
                    if (jeden != dwa)
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz nie jest grafem");
                Console.ReadKey();
                return;
            }

            flaga = true;
            for (int x = 1; x <= macierz.Count; x++)
            {
                if (dajPole(macierz, x, x) != 0)
                {
                    flaga = false;
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podany graf ma pętle");
                Console.ReadKey();
                return;
            }

            List <wierzcholek> wierzcholki = new List <wierzcholek>();

            for (int numer = 1; numer <= macierz.Count; numer++)
            {
                wierzcholek nowy = new wierzcholek(numer);
                List <int>  zad  = macierz.ElementAt((numer - 1));
                for (int i = 1; i <= zad.Count; i++)
                {
                    int a = i - 1;
                    if (zad.ElementAt(a) != 0)
                    {
                        nowy.dodajSasiada(i);
                    }
                }
                wierzcholki.Add(nowy);
            }

            foreach (wierzcholek w in wierzcholki)
            {
                w.napisz();
            }
            Console.WriteLine();

            List <krawedz> krawedzie = new List <krawedz>();

            for (int x = 1; x <= macierz.Count; x++)
            {
                for (int y = x + 1; y <= macierz.Count; y++)
                {
                    if (dajPole(macierz, x, y) != 0)
                    {
                        krawedz nowa = new krawedz(x, y, dajPole(macierz, x, y));
                        krawedzie.Add(nowa);
                    }
                }
            }
            krawedzie.Sort((a, b) => a.porownaj(b));
            foreach (krawedz k in krawedzie)
            {
                k.napisz();
            }

            List <wierzcholek> drzewo = new List <wierzcholek>();
            int max = wierzcholki.Count();

            max--;
            int ile = 0;

            Console.WriteLine();
            while (ile < max)
            {
                krawedz dodawana = krawedzie.ElementAt(0);
                dodaj(drzewo, dodawana);
                if (czyCykl(drzewo, dodawana.dajA()) == true)
                {
                    usun(drzewo, dodawana);
                    Console.WriteLine("Nie dodano krawędzi o masie " + dodawana.dajWage());
                }
                else
                {
                    ile++;
                    Console.WriteLine("Dodano krawędź o masie " + dodawana.dajWage());
                }
                krawedzie.Remove(dodawana);
            }
            Console.WriteLine();
            Console.WriteLine("Minimalne drzewo rozpinające:");
            foreach (wierzcholek w in drzewo)
            {
                w.napisz();
            }

            Console.ReadKey();
        }
예제 #11
0
파일: Program.cs 프로젝트: wardasz/sem3
        static void Main(string[] args)
        {
            List <List <int> > macierz = new List <List <int> >();

            var    s       = new FileInfo(Directory.GetCurrentDirectory());
            var    s2      = s.Directory.Parent.Parent;
            String sciezka = s2.ToString() + "\\dane.csv";

            using (var reader = new StreamReader(sciezka))
            {
                while (!reader.EndOfStream)
                {
                    var        line   = reader.ReadLine();
                    var        values = line.Split(',');
                    List <int> zad    = new List <int>();
                    for (int x = 0; x < values.Length; x++)
                    {
                        zad.Add(Convert.ToInt32(values[x]));
                    }
                    macierz.Add(zad);
                }
            }

            bool flaga = true;

            for (int x = 1; x <= macierz.Count; x++)
            {
                if (dajPole(macierz, x, x) != 0)
                {
                    flaga = false;
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podany graf ma pętle");
                Console.ReadKey();
                return;
            }

            List <wierzcholek> wierzcholki = new List <wierzcholek>();

            for (int numer = 1; numer <= macierz.Count; numer++)
            {
                wierzcholek nowy = new wierzcholek(numer);
                List <int>  zad  = macierz.ElementAt((numer - 1));
                for (int i = 1; i <= zad.Count; i++)
                {
                    int a = i - 1;
                    if (zad.ElementAt(a) != 0)
                    {
                        nowy.dodajSasiada(i);
                    }
                }
                wierzcholki.Add(nowy);
            }

            foreach (wierzcholek w in wierzcholki)
            {
                w.napisz();
            }

            List <wierzcholek> odwrocony = new List <wierzcholek>();

            foreach (wierzcholek w in wierzcholki)
            {
                wierzcholek nowy = new wierzcholek(w.dajNumer());
                odwrocony.Add(nowy);
            }
            foreach (wierzcholek w in wierzcholki)
            {
                foreach (int i in w.dajSasiadow())
                {
                    wybierzWierzcholek(odwrocony, i).dodajSasiada(w.dajNumer());
                }
            }

            Console.WriteLine();
            foreach (wierzcholek w in odwrocony)
            {
                w.napisz();
            }

            List <int> stosKosaraju = new List <int>();

            foreach (wierzcholek w in wierzcholki)
            {
                if (w.CzyOdwiedzony() == false)
                {
                    DFS(wierzcholki, w.dajNumer(), stosKosaraju);
                }
            }

            Console.WriteLine();
            string wypis = "Stos: ";

            foreach (int i in stosKosaraju)
            {
                wypis += i;
                wypis += ", ";
            }
            Console.WriteLine(wypis);
            Console.WriteLine();
            int licznik = 1;

            while (stosKosaraju.Count > 0)
            {
                foreach (wierzcholek w in odwrocony)
                {
                    w.odznacz();
                }
                List <int> skladowa = DFS(odwrocony, stosKosaraju.Last());
                string     napis    = licznik + " składowa spójności składa sie z wierzchołków: ";
                foreach (int i in skladowa)
                {
                    napis += i;
                    napis += ", ";
                    stosKosaraju.Remove(i);
                    odwrocony.Remove(wybierzWierzcholek(odwrocony, i));
                    foreach (wierzcholek w in odwrocony)
                    {
                        w.usunSasiada(i);
                    }
                }
                licznik++;
                Console.WriteLine(napis);
            }



            Console.ReadKey();
        }
예제 #12
0
파일: Program.cs 프로젝트: wardasz/sem3
        static void Main(string[] args)
        {
            Console.WriteLine("Witam w analizatorze ciągów grafowych by wardasz");
            Console.WriteLine("Podaj ciąg:");
            string ciag = Console.ReadLine();

            List <wierzcholek> elementy = new List <wierzcholek>();
            var czesci = ciag.Split(',');

            for (int x = 0; x < czesci.Length; x++)
            {
                int a = x + 1;
                int b = Convert.ToInt32(czesci[x]);
                elementy.Add(new wierzcholek(a, b));
            }

            while (suma(elementy) > 0)
            {
                elementy.Sort((a, b) => (a.porownaj(b)));
                wierzcholek kasowany = elementy.ElementAt(0);
                int         ile      = kasowany.dajAktualny();
                kasowany.zeruj();
                int kasowanyNumer = kasowany.dajNumer();

                for (int x = 1; x <= ile; x++)
                {
                    wierzcholek roboczy      = elementy.ElementAt(x);
                    int         roboczyNumer = roboczy.dajNumer();
                    roboczy.obniz();
                    kasowany.dodajSasiada(roboczyNumer);
                    roboczy.dodajSasiada(kasowanyNumer);
                }

                foreach (wierzcholek w in elementy)
                {
                    if (w.dajAktualny() < 0)
                    {
                        Console.WriteLine("Podany ciąg nie jest ciągiem grafowym");
                        Console.ReadKey();
                        return;
                    }
                }
            }

            //tworzenie maciezy
            List <List <int> > maciez = new List <List <int> >();

            for (int x = 0; x < elementy.Count; x++)
            {
                List <int> nowa = new List <int>();
                for (int y = 0; y < elementy.Count; y++)
                {
                    nowa.Add(0);
                }
                maciez.Add(nowa);
            }

            foreach (wierzcholek w in elementy)
            {
                int numer = w.dajNumer();
                numer--;
                List <int> sasiedzi = w.dajSasiadow();
                foreach (int i in sasiedzi)
                {
                    int n = i - 1;
                    maciez.ElementAt(numer)[n]++;
                }
            }

            //wypisywanie
            int    rozmiar = maciez.Count;
            string szczyt  = "  | ";
            string linia   = "--+";

            for (int x = 1; x <= rozmiar; x++)
            {
                szczyt += x;
                if (x < 10)
                {
                    szczyt += " ";
                }
                szczyt += " ";
                linia  += "---";
            }
            Console.WriteLine(szczyt);
            Console.WriteLine(linia);

            int licznik = 1;

            foreach (List <int> zad in maciez)
            {
                string kolejna = licznik.ToString();
                if (licznik < 10)
                {
                    kolejna += " ";
                }
                kolejna += "|";
                foreach (int pole in zad)
                {
                    kolejna += " ";
                    kolejna += pole.ToString();
                    if (pole < 10)
                    {
                        kolejna += " ";
                    }
                }
                Console.WriteLine(kolejna);
                licznik++;
            }

            Console.ReadKey();
        }
예제 #13
0
        static void Main(string[] args)
        {
            List <List <int> > macierz = new List <List <int> >();

            var    s       = new FileInfo(Directory.GetCurrentDirectory());
            var    s2      = s.Directory.Parent.Parent;
            String sciezka = s2.ToString() + "\\dane.csv";

            using (var reader = new StreamReader(sciezka))
            {
                while (!reader.EndOfStream)
                {
                    var        line   = reader.ReadLine();
                    var        values = line.Split(',');
                    List <int> zad    = new List <int>();
                    for (int x = 0; x < values.Length; x++)
                    {
                        zad.Add(Convert.ToInt32(values[x]));
                    }
                    macierz.Add(zad);
                }
            }

            bool flaga = true;

            for (int x = 1; x <= macierz.Count; x++)
            {
                for (int y = x + 1; y <= macierz.Count; y++)
                {
                    int jeden = dajPole(macierz, x, y);
                    int dwa   = dajPole(macierz, y, x);
                    if (jeden != dwa)
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz nie jest grafem");
                Console.ReadKey();
                return;
            }

            List <wierzcholek> wierzcholki = new List <wierzcholek>();

            for (int numer = 1; numer <= macierz.Count; numer++)
            {
                wierzcholek nowy = new wierzcholek(numer);
                List <int>  zad  = macierz.ElementAt((numer - 1));
                for (int i = 1; i <= zad.Count; i++)
                {
                    int a       = i - 1;
                    int licznik = zad.ElementAt(a);
                    while (licznik > 0)
                    {
                        nowy.dodajSasiada(i);
                        licznik--;
                    }
                }
                wierzcholki.Add(nowy);
            }

            flaga = true;
            foreach (wierzcholek w in wierzcholki)
            {
                if (w.dajStopien() % 2 == 1)
                {
                    flaga = false;
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Graf nie jest grafem eulerowskim");
                Console.ReadKey();
                return;
            }

            if (czySpojny(wierzcholki) == false)
            {
                Console.WriteLine("Graf nie jest grafem spójnym");
                Console.ReadKey();
                return;
            }

            foreach (wierzcholek w in wierzcholki)
            {
                w.napisz();
            }
            Console.WriteLine();

            List <int> euler = new List <int>();

            euler.Add(1);
            while (wierzcholki.Count > 0)
            {
                int        a        = euler.Last();
                List <int> sasiedzi = new List <int>();
                foreach (int i in wybierzWierzcholek(wierzcholki, a).dajSasiadow())
                {
                    sasiedzi.Add(i);
                }
                foreach (int b in sasiedzi)
                {
                    usunKrawedz(wierzcholki, a, b);
                    if (czySpojny(wierzcholki) == true)
                    {
                        euler.Add(b);
                        break;
                    }
                    else
                    {
                        dodajKrawedz(wierzcholki, a, b);
                    }
                }
            }

            string wynik = "Cykl Eulera w podanym grafie: ";

            foreach (int i in euler)
            {
                wynik += i;
                wynik += ", ";
            }
            Console.WriteLine(wynik);
            Console.ReadKey();
        }
예제 #14
0
파일: Program.cs 프로젝트: wardasz/sem3
        static void Main(string[] args)
        {
            List <List <int> > macierz = new List <List <int> >();

            var    s       = new FileInfo(Directory.GetCurrentDirectory());
            var    s2      = s.Directory.Parent.Parent;
            String sciezka = s2.ToString() + "\\dane.csv";

            using (var reader = new StreamReader(sciezka))
            {
                while (!reader.EndOfStream)
                {
                    var        line   = reader.ReadLine();
                    var        values = line.Split(',');
                    List <int> zad    = new List <int>();
                    for (int x = 0; x < values.Length; x++)
                    {
                        zad.Add(Convert.ToInt32(values[x]));
                    }
                    macierz.Add(zad);
                }
            }

            bool flaga = true;

            for (int x = 1; x <= macierz.Count; x++)
            {
                for (int y = x + 1; y <= macierz.Count; y++)
                {
                    int jeden = dajPole(macierz, x, y);
                    int dwa   = dajPole(macierz, y, x);
                    if (jeden != dwa)
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz nie jest grafem");
                Console.ReadKey();
                return;
            }

            flaga = true;
            foreach (List <int> zad in macierz)
            {
                foreach (int i in zad)
                {
                    if (i == 0 || i == 1)
                    {
                    }
                    else
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz reprezentuje graf, który nie jest grafem prostym");
                Console.ReadKey();
                return;
            }

            List <wierzcholek> wierzcholki = new List <wierzcholek>();

            for (int numer = 1; numer <= macierz.Count; numer++)
            {
                wierzcholek nowy = new wierzcholek(numer);
                List <int>  zad  = macierz.ElementAt((numer - 1));
                for (int i = 1; i <= zad.Count; i++)
                {
                    int a = i - 1;
                    if (zad.ElementAt(a) == 1)
                    {
                        nowy.dodajSasiada(i);
                    }
                }
                wierzcholki.Add(nowy);
            }

            int minStopien = wierzcholki.ElementAt(0).dajStopien();

            foreach (wierzcholek w in wierzcholki)
            {
                if (w.dajStopien() < minStopien)
                {
                    minStopien = w.dajStopien();
                }
            }
            if (minStopien < 2)
            {
                Console.WriteLine("Graf ma za mały minimalny stopień");
                Console.ReadKey();
                return;
            }

            List <lancuch> lancuchy = new List <lancuch>();

            foreach (wierzcholek w in wierzcholki)
            {
                lancuch nowy = new lancuch(w.dajNumer());
                lancuchy.Add(nowy);
            }

            flaga = true;
            while (flaga == true)
            {
                foreach (lancuch l in lancuchy)
                {
                    l.napisz();
                }
                Console.WriteLine();
                flaga = false;
                List <lancuch> nowe = new List <lancuch>();
                foreach (lancuch l in lancuchy)
                {
                    wierzcholek krancowy  = dajWierzcholek2(wierzcholki, l.dajOstatni());
                    List <int>  sasiednie = krancowy.dajSasiadow();
                    foreach (int i in sasiednie)
                    {
                        if (l.czyW(i) == false)
                        {
                            lancuch nowy = new lancuch(l, i);
                            nowe.Add(nowy);
                            flaga = true;
                        }
                    }
                }
                if (flaga == true)
                {
                    lancuchy = nowe;
                }
            }

            foreach (lancuch l in lancuchy)
            {
                flaga = true;
                while (flaga == true)
                {
                    if (l.dajDlugosc() > minStopien)
                    {
                        int         kraniec  = l.dajOstatni();
                        wierzcholek ostatni  = dajWierzcholek2(wierzcholki, kraniec);
                        int         pierwszy = l.dajPierwszy();

                        if (ostatni.czySasiaduje(pierwszy) == true)
                        {
                            Console.WriteLine("Znaleziono cykl o długości większej od minimalnego stopnia grafu. Biegnie on następującymi wierzchołkami:");
                            string wynik = "";
                            foreach (int i in l.dajWierzcholki())
                            {
                                wynik += i;
                                wynik += ", ";
                            }
                            Console.WriteLine(wynik);
                            Console.ReadKey();
                            return;
                        }
                        else
                        {
                            l.skroc();
                        }
                    }
                    else
                    {
                        flaga = false;
                    }
                }
            }


            Console.ReadKey();
        }
예제 #15
0
        static void Main(string[] args)
        {
            List <List <int> > macierz = new List <List <int> >();

            var    s       = new FileInfo(Directory.GetCurrentDirectory());
            var    s2      = s.Directory.Parent.Parent;
            String sciezka = s2.ToString() + "\\dane.csv";

            using (var reader = new StreamReader(sciezka))
            {
                while (!reader.EndOfStream)
                {
                    var        line   = reader.ReadLine();
                    var        values = line.Split(',');
                    List <int> zad    = new List <int>();
                    for (int x = 0; x < values.Length; x++)
                    {
                        zad.Add(Convert.ToInt32(values[x]));
                    }
                    macierz.Add(zad);
                }
            }

            bool flaga = true;

            for (int x = 1; x <= macierz.Count; x++)
            {
                for (int y = x + 1; y <= macierz.Count; y++)
                {
                    int jeden = dajPole(macierz, x, y);
                    int dwa   = dajPole(macierz, y, x);
                    if (jeden != dwa)
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz nie jest grafem");
                Console.ReadKey();
                return;
            }

            flaga = true;
            foreach (List <int> zad in macierz)
            {
                foreach (int i in zad)
                {
                    if (i == 0 || i == 1)
                    {
                    }
                    else
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz reprezentuje graf, który nie jest grafem prostym");
                Console.ReadKey();
                return;
            }

            List <wierzcholek> wierzcholki = new List <wierzcholek>();

            for (int numer = 1; numer <= macierz.Count; numer++)
            {
                wierzcholek nowy = new wierzcholek(numer);
                List <int>  zad  = macierz.ElementAt((numer - 1));
                for (int i = 1; i <= zad.Count; i++)
                {
                    int a = i - 1;
                    if (zad.ElementAt(a) == 1)
                    {
                        nowy.dodajSasiada(i);
                    }
                }
                wierzcholki.Add(nowy);
            }
            foreach (wierzcholek w in wierzcholki)
            {
                w.napisz();
            }
            Console.WriteLine();

            foreach (wierzcholek w in wierzcholki)
            {
                if (w.dajKolor() == 0)
                {
                    List <int> kolejka = new List <int>();
                    kolejka.Add(w.dajNumer());
                    w.zaznacz();
                    w.koloruj(1);
                    while (kolejka.Count != 0)
                    {
                        wierzcholek robiony  = wybierzWierzcholek(wierzcholki, kolejka.ElementAt(0));
                        List <int>  sasiedzi = robiony.dajSasiadow();
                        int         obecny   = robiony.dajKolor();
                        int         nastepny;
                        if (obecny == 1)
                        {
                            nastepny = 2;
                        }
                        else
                        {
                            nastepny = 1;
                        }
                        foreach (int i in sasiedzi)
                        {
                            wierzcholek kolorowany = wybierzWierzcholek(wierzcholki, i);
                            if (kolorowany.koloruj(nastepny) == false)
                            {
                                Console.WriteLine("Graf nie jest dwudzielny");
                                Console.ReadKey();
                                return;
                            }
                            if (kolorowany.dajFlage() == false)
                            {
                                kolorowany.zaznacz();
                                kolejka.Add(i);
                            }
                        }
                        kolejka.Remove(kolejka.ElementAt(0));
                    }
                }
            }

            Console.WriteLine("Graf jest dwudzielny");
            foreach (wierzcholek w in wierzcholki)
            {
                w.napisz();
            }

            List <sciezka> siec = new List <sciezka>();
            sciezka        nowa;

            foreach (wierzcholek w in wierzcholki)
            {
                w.odznacz();
                if (w.dajKolor() == 1)
                {
                    foreach (int i in w.dajSasiadow())
                    {
                        nowa = new sciezka(w.dajNumer().ToString(), i.ToString(), 1);
                        siec.Add(nowa);
                    }
                    nowa = new sciezka("z", w.dajNumer().ToString(), 1);
                    siec.Add(nowa);
                }
                else
                {
                    nowa = new sciezka(w.dajNumer().ToString(), "u", 1);
                    siec.Add(nowa);
                }
            }
            Console.WriteLine();
            foreach (sciezka sc in siec)
            {
                sc.napisz();
            }
            Console.WriteLine();

            while (true)
            {
                List <sciezka> rezywualna           = zrobSiecRezywualna(siec);
                List <string>  sciezkaPowiekszajaca = BFS(rezywualna);
                if (sciezkaPowiekszajaca == null)
                {
                    break;
                }

                int  maksimum = 1;
                bool znalazl;
                for (int x = 0; x < (sciezkaPowiekszajaca.Count) - 1; x++)
                {
                    znalazl = false;
                    foreach (sciezka r in siec)
                    {
                        if (r.skad() == sciezkaPowiekszajaca.ElementAt(x) && r.dokad() == sciezkaPowiekszajaca.ElementAt(x + 1))
                        {
                            znalazl = true;
                            r.powiekszPrzeplyw(maksimum);
                        }
                    }
                    if (znalazl == false)
                    {
                        foreach (sciezka r in siec)
                        {
                            if (r.dokad() == sciezkaPowiekszajaca.ElementAt(x) && r.skad() == sciezkaPowiekszajaca.ElementAt(x + 1))
                            {
                                r.pomniejszPrzeplyw(maksimum);
                            }
                        }
                    }
                }
            }

            int licznik = 0;

            foreach (sciezka sc in siec)
            {
                if (sc.skad() != "z" && sc.dokad() != "u" && sc.dajPrzeplyw() == 1)
                {
                    Console.WriteLine("Krawędz skojarzenia łącząca wierzchołki " + sc.skad() + " i " + sc.dokad());
                    licznik++;
                }
            }
            Console.WriteLine("Maksymalne skojarzenie zawiera " + licznik + " krawędzi.");
            Console.ReadKey();
        }
예제 #16
0
파일: Program.cs 프로젝트: wardasz/sem3
        static void Main(string[] args)
        {
            List <List <int> > macierz = new List <List <int> >();

            var    s       = new FileInfo(Directory.GetCurrentDirectory());
            var    s2      = s.Directory.Parent.Parent;
            String sciezka = s2.ToString() + "\\dane.csv";

            using (var reader = new StreamReader(sciezka))
            {
                while (!reader.EndOfStream)
                {
                    var        line   = reader.ReadLine();
                    var        values = line.Split(',');
                    List <int> zad    = new List <int>();
                    for (int x = 0; x < values.Length; x++)
                    {
                        zad.Add(Convert.ToInt32(values[x]));
                    }
                    macierz.Add(zad);
                }
            }

            bool flaga = true;

            for (int x = 1; x <= macierz.Count; x++)
            {
                for (int y = x + 1; y <= macierz.Count; y++)
                {
                    int jeden = dajPole(macierz, x, y);
                    int dwa   = dajPole(macierz, y, x);
                    if (jeden != dwa)
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz nie jest grafem");
                Console.ReadKey();
                return;
            }

            flaga = true;
            foreach (List <int> zad in macierz)
            {
                foreach (int i in zad)
                {
                    if (i == 0 || i == 1)
                    {
                    }
                    else
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz reprezentuje graf, który nie jest grafem prostym");
                Console.ReadKey();
                return;
            }

            List <wierzcholek> wierzcholki = new List <wierzcholek>();

            for (int numer = 1; numer <= macierz.Count; numer++)
            {
                wierzcholek nowy = new wierzcholek(numer);
                List <int>  zad  = macierz.ElementAt((numer - 1));
                for (int i = 1; i <= zad.Count; i++)
                {
                    int a = i - 1;
                    if (zad.ElementAt(a) == 1)
                    {
                        nowy.dodajSasiada(i);
                    }
                }
                wierzcholki.Add(nowy);
            }

            int suma = 0;

            foreach (wierzcholek w in wierzcholki)
            {
                suma += w.dajStopien();
            }
            int krawendzie = suma / 2;
            int wenzly     = wierzcholki.Count;

            if (wenzly != (krawendzie + 1))
            {
                Console.WriteLine("Podana macierz reprezentuje graf, który nie jest acykliczny");
                Console.ReadKey();
                return;
            }

            while (wierzcholki.Count > 2)
            {
                foreach (wierzcholek w in wierzcholki)
                {
                    w.napisz();
                }
                Console.WriteLine();

                List <wierzcholek> usuwane = new List <wierzcholek>();
                foreach (wierzcholek w in wierzcholki)
                {
                    if (w.dajStopien() == 1)
                    {
                        usuwane.Add(w);
                    }
                }
                foreach (wierzcholek u in usuwane)
                {
                    wierzcholki.Remove(u);
                }
                foreach (wierzcholek u in usuwane)
                {
                    foreach (wierzcholek w in wierzcholki)
                    {
                        if (u.dajNumer() == w.dajNumer())
                        {
                            wierzcholki.Remove(w);
                        }
                        else
                        {
                            w.usunSasiada(u.dajNumer());
                        }
                    }
                }
            }

            if (wierzcholki.Count == 1)
            {
                Console.WriteLine("Centrum drzewa jest wierzchołek " + wierzcholki.ElementAt(0).dajNumer());
            }
            else
            {
                Console.WriteLine("Centrum drzewa są wierzchołki " + wierzcholki.ElementAt(0).dajNumer() + " i " + wierzcholki.ElementAt(1).dajNumer());
            }


            Console.ReadKey();
        }
예제 #17
0
파일: Program.cs 프로젝트: wardasz/sem3
        static void Main(string[] args)
        {
            List <List <int> > macierz = new List <List <int> >();

            var    s       = new FileInfo(Directory.GetCurrentDirectory());
            var    s2      = s.Directory.Parent.Parent;
            String sciezka = s2.ToString() + "\\dane.csv";

            using (var reader = new StreamReader(sciezka))
            {
                while (!reader.EndOfStream)
                {
                    var        line   = reader.ReadLine();
                    var        values = line.Split(',');
                    List <int> zad    = new List <int>();
                    for (int x = 0; x < values.Length; x++)
                    {
                        zad.Add(Convert.ToInt32(values[x]));
                    }
                    macierz.Add(zad);
                }
            }

            bool flaga = true;

            for (int x = 1; x <= macierz.Count; x++)
            {
                for (int y = x + 1; y <= macierz.Count; y++)
                {
                    int jeden = dajPole(macierz, x, y);
                    int dwa   = dajPole(macierz, y, x);
                    if (jeden != dwa)
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz nie jest grafem");
                Console.ReadKey();
                return;
            }

            List <wierzcholek> wierzcholki = new List <wierzcholek>();

            for (int numer = 1; numer <= macierz.Count; numer++)
            {
                wierzcholek nowy = new wierzcholek(numer);
                List <int>  zad  = macierz.ElementAt((numer - 1));
                for (int i = 1; i <= zad.Count; i++)
                {
                    int a = i - 1;
                    if (zad.ElementAt(a) == 1)
                    {
                        nowy.dodajSasiada(i);
                    }
                }
                wierzcholki.Add(nowy);
            }

            foreach (wierzcholek w in wierzcholki)
            {
                w.napisz();
            }

            Console.WriteLine();
            List <int> pierwsza = DFS(wierzcholki);

            if (pierwsza.Count == wierzcholki.Count)
            {
                Console.WriteLine("Graf jest spójny");
            }
            else
            {
                List <List <int> > skladowe = new List <List <int> >();
                skladowe.Add(pierwsza);
                foreach (int i in pierwsza)
                {
                    wierzcholek kasowany = wybierzWierzcholek(wierzcholki, i);
                    wierzcholki.Remove(kasowany);
                }
                while (wierzcholki.Count > 0)
                {
                    List <int> kolejna = DFS(wierzcholki);
                    skladowe.Add(kolejna);
                    foreach (int i in kolejna)
                    {
                        wierzcholek kasowany = wybierzWierzcholek(wierzcholki, i);
                        wierzcholki.Remove(kasowany);
                    }
                }

                Console.WriteLine("Graf nie jest spójny");
                int licznik = 1;
                foreach (List <int> skladowa in skladowe)
                {
                    string wynik = licznik + " składowa spójności: ";
                    foreach (int i in skladowa)
                    {
                        wynik += i;
                        wynik += ", ";
                    }
                    Console.WriteLine(wynik);
                    licznik++;
                }
            }



            Console.ReadKey();
        }
예제 #18
0
        static void Main(string[] args)
        {
            List <List <int> > macierz = new List <List <int> >();

            var    s       = new FileInfo(Directory.GetCurrentDirectory());
            var    s2      = s.Directory.Parent.Parent;
            String sciezka = s2.ToString() + "\\dane.csv";

            using (var reader = new StreamReader(sciezka))
            {
                while (!reader.EndOfStream)
                {
                    var        line   = reader.ReadLine();
                    var        values = line.Split(',');
                    List <int> zad    = new List <int>();
                    for (int x = 0; x < values.Length; x++)
                    {
                        zad.Add(Convert.ToInt32(values[x]));
                    }
                    macierz.Add(zad);
                }
            }

            bool flaga = true;

            for (int x = 1; x <= macierz.Count; x++)
            {
                for (int y = x + 1; y <= macierz.Count; y++)
                {
                    int jeden = dajPole(macierz, x, y);
                    int dwa   = dajPole(macierz, y, x);
                    if (jeden != dwa)
                    {
                        flaga = false;
                    }
                }
            }
            if (flaga == false)
            {
                Console.WriteLine("Podana macierz nie jest grafem");
                Console.ReadKey();
                return;
            }

            List <wierzcholek> wierzcholki = new List <wierzcholek>();

            for (int numer = 1; numer <= macierz.Count; numer++)
            {
                wierzcholek nowy = new wierzcholek(numer);
                List <int>  zad  = macierz.ElementAt((numer - 1));
                for (int i = 1; i <= zad.Count; i++)
                {
                    int a = i - 1;
                    if (zad.ElementAt(a) == 1)
                    {
                        nowy.dodajSasiada(i);
                    }
                }
                wierzcholki.Add(nowy);
            }

            foreach (wierzcholek w in wierzcholki)
            {
                w.napisz();
            }

            List <int>  stos   = new List <int>();
            wierzcholek obecny = wybierzWierzcholek(wierzcholki, 1);

            obecny.naDrzewo();
            List <sciezka> sciezki = new List <sciezka>();

            stos.Add(1);
            while (stos.Count > 0)
            {
                List <int> sasiedzi = obecny.dajSasiadow();
                bool       znalazl  = false;
                foreach (int i in sasiedzi)
                {
                    wierzcholek nowy = wybierzWierzcholek(wierzcholki, i);
                    if (nowy.czyNaDrzewie() == false)
                    {
                        znalazl = true;
                        nowy.naDrzewo();
                        stos.Add(nowy.dajNumer());
                        sciezki.Add(new sciezka(obecny.dajNumer(), nowy.dajNumer()));
                        obecny = nowy;
                        break;
                    }
                }
                if (znalazl == false)
                {
                    stos.Remove(stos.Last());
                    if (stos.Count > 0)
                    {
                        obecny = wybierzWierzcholek(wierzcholki, stos.Last());
                    }
                }
            }

            Console.WriteLine();
            flaga = true;
            foreach (wierzcholek w in wierzcholki)
            {
                if (w.czyNaDrzewie() == false)
                {
                    flaga = false;
                }
            }

            if (flaga == false)
            {
                Console.WriteLine("Podany graf nie jest spójny");
            }
            else
            {
                Console.WriteLine("Podany graf zawiera następujące drzewo spójności");
                string wynik = "";
                foreach (sciezka x in sciezki)
                {
                    wynik += x.opis();
                    wynik += ", ";
                }
                wynik.Remove(wynik.Last());
                wynik.Remove(wynik.Last());
                Console.WriteLine(wynik);
            }


            Console.ReadKey();
        }