Beispiel #1
0
        // сделать ход, если этот приводит к решению, то вернуть true
        public bool Run(bool Optimize, bool Target)
        {
            TRuns Runs = Hanoi.GetMove(); // вернуть допустимые ходы

            // если задан режим отбора целевых ходов
            if (Target)
            {
                Select(Runs); // выбрать целевые ходы
            }

            // если задан режим оптимизации ходов
            if (Optimize)
            {
                THanoi Test; // создаем класс для пробного состояния

                for (int i = 0; i < Runs.Count; i++)
                {
                    Test = Hanoi.Copy();                   // создать копию

                    Test.Move((Runs[i])[0], (Runs[i])[1]); // делаем пробный ход

                    // если получаемое состояние не было ранее
                    if (!IsPrev(Test))
                    {
                        Hanoi = Test.Copy();    // сохраняем тестовое состояние
                        Hanoi.Draw();           // рисуем новые состояние

                        Prev.Add(Hanoi.Copy()); // сохраняем получаемое состояние

                        // проверяем нет ли выигрыша
                        if (Hanoi.IsWin())
                        {
                            return(true);
                        }
                        else
                        {
                            return(false);
                        }
                    }
                }
            }

            // если не было хода, то делаем случайный ход

            int k = rnd.Next(Runs.Count);           // выбираем случайный ход

            Hanoi.Move((Runs[k])[0], (Runs[k])[1]); // сделать ход
            Hanoi.Draw();                           // рисуем новую ситуацию

            // проверить нет ли выигрыша
            if (Hanoi.IsWin())
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Beispiel #2
0
        // выбрать целевые ходы
        void Select(TRuns Runs)
        {
            int NeedDisk = Hanoi.Stalk[2].ForNeed(); // проверить нет ли необходимого диска

            // если есть необходимый диск, то ищем его
            if (NeedDisk > -1)
            {
                int[] forrun = new int[2]; // создем новй ход
                forrun[0] = -1;            // показатель, что хода нет
                forrun[1] = 2;

                // проверяем нет ли необходимого диска на 0 штыре
                if (Hanoi.Stalk[0].GetTop() == NeedDisk)
                {
                    forrun[0] = 0;
                }

                // проверяем нет ли необходимого диска на 1 штыре
                if (Hanoi.Stalk[1].GetTop() == NeedDisk)
                {
                    forrun[0] = 1;
                }

                // если был найден нужный диск, то делаем ход
                if (forrun[0] != -1)
                {
                    Runs.arr.Clear(); // очищяем  возможные ходы
                    Runs.Add(forrun); // добавляем только один необходимый ход

                    return;
                }
            }

            // проверяем, нет ли среди возможных ходов, которые будут шагом назад
            for (int i = 0; i < Runs.Count; i++)
            {
                int[] run = (Runs[i]);
                if (run[0] == 2)
                {
                    if ((Hanoi.Stalk[2].Disks[0] == 3) && (Hanoi.Stalk[2].Disks[1] != 1))
                    {
                        Runs.arr.RemoveAt(i);
                        i--;
                    }
                }
            }
        }
Beispiel #3
0
        // найти допустимые ходы
        public TRuns GetMove()
        {
            TRuns Runs = new TRuns();

            int[] res = new int[2];

            ArrayList arr = new ArrayList();
            Random    rnd = new Random();

            res = new int[2]; res[0] = 0; res[1] = 1; if (Can(res[0], res[1]))
            {
                arr.Add(res);
            }
            res = new int[2]; res[0] = 0; res[1] = 2; if (Can(res[0], res[1]))
            {
                arr.Add(res);
            }
            res = new int[2]; res[0] = 1; res[1] = 0; if (Can(res[0], res[1]))
            {
                arr.Add(res);
            }
            res = new int[2]; res[0] = 1; res[1] = 2; if (Can(res[0], res[1]))
            {
                arr.Add(res);
            }
            res = new int[2]; res[0] = 2; res[1] = 0; if (Can(res[0], res[1]))
            {
                arr.Add(res);
            }
            res = new int[2]; res[0] = 2; res[1] = 1; if (Can(res[0], res[1]))
            {
                arr.Add(res);
            }

            while (arr.Count > 0)
            {
                int k = rnd.Next(arr.Count);
                Runs.Add((int[])arr[k]);

                arr.RemoveAt(k);
            }



            return(Runs);
        }