コード例 #1
0
        public int fajlBeolvasas(Int32 sorszam)
        {
            if (!File.Exists(Environment.CurrentDirectory + "\\fajlok\\FOLT" + sorszam + ".BE.txt"))
            {
                return((int)hibaKod.NINCSFAJL);
            }

            fajl = System.IO.File.ReadAllLines(Environment.CurrentDirectory + "\\fajlok\\FOLT" + sorszam + ".BE.txt");

            if (fajl.Length == 0)
            {
                return((int)hibaKod.URESFAJL);
            }

            int valosN = fajl.Length - 1;
            int valosM = fajl[1].Length;

            //A bemeneti fajlban a 10-nel kisebb szamokat 05 formában kell megadni.
            dimenziok[0] = Int32.Parse(fajl[0][0].ToString() + fajl[0][1].ToString());
            dimenziok[1] = Int32.Parse(fajl[0][3].ToString() + fajl[0][4].ToString());

            // Ha a dimenzio jelzesek nem egyeznek meg a valossal vagy kisebb a tomb valamelyik dimenzioja vagy nagyobb mint 100
            if (dimenziok[0] != valosN || dimenziok[1] != valosM ||
                valosN < 1 || valosN > 100 || valosM < 1 || valosM > 100)
            {
                return((int)hibaKod.DIMENZIO);
            }

            matrix = new String[dimenziok[0]];

            matrixFeltoltes(fajl);

            //Mindenhova maximum ketszer juthat el a bejaras soran (a harmadik mar redundans -> kilep)
            leghosszabbFeketeUt = 2 * initFeketekSzama();

            // A leghosszabb ut egy n*m-es matrixban a megadott szabalyok szerint megalkotott labirintusban a kacskaringo
            // Ennek palyajat max ketszer jarhatjuk be a program soran.
            leghosszabbFeherUt += dimenziok[1] - 3;
            for (int k = 5; k < (dimenziok[0] < dimenziok[1] ? dimenziok[0] : dimenziok[1]); k += 2)
            {
                leghosszabbFeherUt += dimenziok[0] - k + dimenziok[1] - k;
            }
            leghosszabbFeherUt *= 2;

            voltMarFekete = BufferKezeles.initBuffer(leghosszabbFeketeUt);
            if (!konzisztensAFolt())
            {
                return((int)hibaKod.FOLTHIBA);
            }

            voltMarFeher = new List <int[, ]>();
            if (vanFeherFolt())
            {
                return((int)hibaKod.FEHERFOLT);
            }

            return((int)hibaKod.OK);
        }
コード例 #2
0
        private Boolean korbejaras(string[] tartomany, string szin, int iTol, int jTol, ref int[,] elozoHelyek)
        {
            int[] kovHely = new int[2] {
                iTol, jTol
            };
            int[,] visszafordulas = BufferKezeles.initBuffer(3);
            int elozoLepesIranya = 2;

            do
            {
                if (szin.Equals("fekete"))
                {
                    kovHely = feketeLepes(tartomany, kovHely, ref elozoLepesIranya, visszafordulas);
                }
                else
                {
                    kovHely = feherLepes(kovHely, ref elozoLepesIranya);
                    //Ha kiert a szelere
                    if (kovHely[0] == szelsoErtekek[0] || kovHely[0] == szelsoErtekek[1] ||
                        kovHely[1] == szelsoErtekek[2] || kovHely[1] == szelsoErtekek[3])
                    {
                        return(true);
                    }
                }

                if (BufferKezeles.ketszerTartalmazza(elozoHelyek, kovHely))
                {
                    return(false);
                }

                BufferKezeles.shiftBuffer(ref elozoHelyek, kovHely);
                BufferKezeles.shiftBuffer(ref visszafordulas, kovHely);
            } while (!(kovHely[0] == elsoFekete[0] && kovHely[1] == elsoFekete[1]));

            // Erdektelen
            return(false);
        }
コード例 #3
0
        private void kimenetAlkotas()
        {
            kimenet               = new string[dimenziok[0]];
            kimenet[0]            = (elsoFekete[0] + 1) + " " + (elsoFekete[1] + 1);
            int[,] korbejarasUtja = BufferKezeles.initBuffer(leghosszabbFeketeUt);
            korbejaras(matrix, "fekete", elsoFekete[0], elsoFekete[1], ref korbejarasUtja);

            string lanckod = "";
            int    i       = 0;

            while (i < leghosszabbFeketeUt - 1)
            {
                int elsoParam;
                int masodikParam;

                if (korbejarasUtja[i, 0] == -1 && korbejarasUtja[i + 1, 0] == -1)
                {
                    i++;
                    continue;
                }
                else if (korbejarasUtja[i, 0] == -1)
                {
                    elsoParam    = korbejarasUtja[i + 1, 0] - elsoFekete[0];
                    masodikParam = korbejarasUtja[i + 1, 1] - elsoFekete[1];
                }
                else
                {
                    elsoParam    = korbejarasUtja[i + 1, 0] - korbejarasUtja[i, 0];
                    masodikParam = korbejarasUtja[i + 1, 1] - korbejarasUtja[i, 1];
                }
                string irany = elsoParam + " - " + masodikParam;

                switch (irany)
                {
                case "-1 - 0":
                    lanckod += 1;
                    break;

                case "-1 - -1":
                    lanckod += 2;
                    break;

                case "0 - -1":
                    lanckod += 3;
                    break;

                case "1 - -1":
                    lanckod += 4;
                    break;

                case "1 - 0":
                    lanckod += 5;
                    break;

                case "1 - 1":
                    lanckod += 6;
                    break;

                case "0 - 1":
                    lanckod += 7;
                    break;

                case "-1 - 1":
                    lanckod += 8;
                    break;

                default:
                    break;
                }

                i++;
            }

            kimenet[1] = lanckod;
            Console.WriteLine("A mátrix lánckódja: " + lanckod);
        }
コード例 #4
0
        // Igaz, ha az allomanyban talal olyan elemet, ami korabban mar szerepelt, mert ekkor egy osszefuggo halmazrol beszelhetunk
        // Hamis, ha nem talal olyan elemet, amelyik korabban szerepelt, mert ekkor egy uj, diszjunkt halmazrol beszelunk
        private Boolean allomanyKonzisztensAdottPontbol(string[] tartomany, string szin, int iTol, int jTol, Boolean elso)
        {
            int[,] elozoHelyek;
            Boolean kiertem = false;

            if (szin.Equals("fekete"))
            {
                elozoHelyek = BufferKezeles.initBuffer(leghosszabbFeketeUt);
            }
            else
            {
                elozoHelyek = BufferKezeles.initBuffer((dimenziok[0] - 2) * (dimenziok[1] - 2));
            }

            kiertem = korbejaras(tartomany, szin, iTol, jTol, ref elozoHelyek);

            BufferKezeles.normalizal(ref elozoHelyek);

            // Elozoleg meglatogatott helyek hozzaadasa a kijelolt halmazhoz
            for (int i = 0; i < elozoHelyek.Length / 2; i++)
            {
                int[] lepes;
                if (elozoHelyek[i, 0] != -1 && elozoHelyek[i, 1] != -1)
                {
                    lepes = new int[2] {
                        elozoHelyek[i, 0], elozoHelyek[i, 1]
                    }
                }
                ;
                else
                {
                    continue;
                }

                if (szin.Equals("fekete"))
                {
                    if (elso || BufferKezeles.tartalmazza(voltMarFekete, lepes))
                    {
                        BufferKezeles.egyediElemekTombjeHozzaadas(ref voltMarFekete, elozoHelyek);
                        return(true);
                    }
                }
                else
                {
                    foreach (int[,] elem in voltMarFeher)
                    {
                        if (elso || BufferKezeles.tartalmazza(elem, lepes))
                        {
                            int index = voltMarFeher.IndexOf(elem);
                            int[,] halmaz = elem;
                            BufferKezeles.egyediElemekTombjeHozzaadas(ref halmaz, elozoHelyek);
                            if (kiertem)
                            {
                                halmaz[0, 0] = -2;
                                halmaz[0, 1] = -2;
                            }
                            voltMarFeher[index] = halmaz;
                            return(true);
                        }
                    }
                    int[,] ujHalmaz = BufferKezeles.initBuffer(elozoHelyek.Length / 2);
                    BufferKezeles.egyediElemekTombjeHozzaadas(ref ujHalmaz, elozoHelyek);
                    if (kiertem)
                    {
                        ujHalmaz[0, 0] = -2;
                        ujHalmaz[0, 1] = -2;
                    }
                    int[,] element;
                    try {
                        element = voltMarFeher.Last();
                        voltMarFeher.Insert(voltMarFeher.IndexOf(element) + 1, ujHalmaz);
                    }
                    catch (InvalidOperationException e)
                    {
                        voltMarFeher.Insert(0, ujHalmaz);
                    }

                    if (!kiertem)
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }