Поиск пути в лабиринте
Содержание
1. Техническое задание
1.1 Основания для разработки
1.2 Назначение разработки
1.3 Требования к программной документации
1.4 Порядок приемки и контроля
1.5 Тесты
2. Технический проект
2.1 Диаграмма классов
3. Рабочий проект
3.1 Общее описание программы
3.2 Описание подпрограмм класса leaf
3.3 Описание подпрограмм класса TForm1
3.4 Описание подпрограмм класса TForm2
Список использованных источников
Приложение
1. Техническое задание
1.1 Основания
для разработки
Основанием для разработки программного продукта служит
задание по курсовой работе по дисциплине "Структуры и алгоритмы обработки
данных".
1.2
Назначение разработки
Задан лабиринт, составленный из комнат. В каждой из комнат
имеется не менее одной и не более четырех дверей, соединяющих между собой
соседние комнаты. Одна из дверей называется входом в лабиринт, другая - выходом
из лабиринта. В каждой комнате хранятся сокровища: от одной до ста золотых
монет. Найти путь от входа лабиринта к его выходу, не проходящий одну и ту же
комнату два раза и позволяющий унести как можно больше сокровищ. Отобразить
решение графически, выделив цветом найденный результат.
Рассмотренные альтернативы
При постановке задачи на разработку данного программного
изделия была выбрана среда разработки Borland C++Builder 6 в силу легкости проектирования
пользовательского интерфейса.
Стандарты
Разработка программной документации и программного изделия
должна производиться согласно ГОСТ 19.701-90, ГОСТ 2.304-88. Единая система
программной документации.
Требования пользователя к программному изделию
Функциональные требования
· Система должна представлять собой одну
программу.
· Программный продукт должен генерировать
лабиринт, пригодный для условий задания.
· В каждой комнате лабиринта должно
храниться количество монет, от одной до ста.
· Программный продукт должен находить путь
от входной двери к выходной двери, позволяющий унести как можно больше
сокровищ, и выделять его графически.
Программные ограничения, совместимость
Программное изделие должно работать в операционных системах Windows. Для переноса программы
не должны требоваться специальные программные и аппаратные средства.
Носители информации
Программное изделие будет размещено в виде исполняемого файла
на диске CD-R,
либо на жестком диске, либо на flash-носителе.
Входные данные
Входными данными для программного продукта будут являться
размер графического буфера и нажатие клавиш.
Выходные данные
Выходными данными для программного продукта будет являться
графическое отображение лабиринта с найденным путем, количество монет,
собранных на этом пути, и число комнат в пути.
Процессы обработки
В процессе работы программа создает массив структур komnat. Каждая структура может
быть либо комнатой, либо стеной. С помощью алгоритма генерации создается
соответствующий условиям лабиринт и случайным образом выбираются комнаты, в
которых находится входная дверь и выходная дверь. Алгоритм поиска пути
формирует дерево, корень которого соответствует входной комнате, а ветви -
соседних комнатам, к которым есть доступ. Если в процессе поиска ветка достигла
выходной комнаты, то путь размечается, а собранные сокровища суммируются и
выводятся. Алгоритм поиска завершается, когда обработаны все ветви, в связи с
чем время поиска увеличивается пропорционально количеству дверей между
комнатами.
Рестарт
В случаях рестарта необходимо запустить на выполнение
программу. Данные при рестарте не сохраняются
Требования к составу и параметрам технических средств
Для работы программного модуля необходимо дисковое
пространство в размере не менее 300 Кб, свободная оперативная память в размере
не менее 12 Мб, разрешение экрана не менее 1024х768, также микропроцессор 80486
или выше.
Результирующие компоненты изделия
Файл программы LABIRINT. exe.
1.3
Требования к программной документации
Программная документация должна включать следующие документы:
1) техническое задание;
2) рабочий проект;
3) приложение (листинг исходных текстов
программного изделия).
1.4 Порядок
приемки и контроля
Приемка программного изделия осуществляется при сдаче
документально оформленных этапов разработки и проведении испытаний на основе
установленных тестов. Тесты должны быть разработаны на этапе рабочего
проектирования программного изделия.
программный пользователь borland builder
1.5 Тесты
Тест №1
Действия: запуск программы.
Реакция программы: появляется главное окно приветствия (см.
рисунок 1.1).
Рисунок 1.1 Тест №1
Тест № 2
Действия: клик мышью в окне приветствия.
Реакция программы: появляется главное окно со сгенерированным
лабиринтом и начинается процесс поиска пути (см. рисунок 1.2).
Тест № 3
Действия: клик мышью по лабиринту с найденным путем.
Реакция программы: генерируется новый лабиринт и начинается
процесс поиска пути (см. рисунок 1.2), во время которого лабиринт по
необходимости перерисовывается. При окончании процесса поиска выводятся
сообщения: в случае неудачного поиска о необходимости перестроить лабиринт (см.
рисунок 1.3), а в случае успешного поиска с информацией о найденном пути (см.
рисунок 1.4, 1.5).
Рисунок 1.2 Тест №2,3
Рисунок 1.3 Тест №3
Рисунок 1.4 Тест №3
Тест №4
Действия: нажатие кнопки "Пробел"
Реакция программы: с каждым нажатием кнопки изменяется режим
отображения информации в заголовке программы и режим отрисовки лабиринта (см.
рисунок 1.2, 1.6, 1.7).
Рисунок 1.4 Тест №6
Рисунок 1.4 Тест №7
Тест №5
Действия: нажатие кнопки Escape во время поиска пути.
Реакция программы: процесс поиска пути досрочно завершается и
выводится информация (см. рисунок 1.3, 1.4, 1.5).
2.
Технический проект
2.1 Диаграмма
классов
3. Рабочий
проект
3.1 Общее
описание программы
Данное программное изделие состоит из 2 модулей. В
программном изделии используются методы работы с графическим объектом TCanvas. Информация поступает с
клавиатуры и мыши.
3.2 Описание
подпрограмм класса leaf
Конструктор leaf:: leaf ()
Входные данные: нет.
Выходные данные: нет.
Процессы обработки: выделяется память для ветвей текущего
узла дерева поиска пути.
Используемые внешние переменные: kids.
Подпрограмма bool leaf:: IsVisited (int x, int y, leaf* obj)
Входные данные: int x, int y - координаты проверяемой
комнаты, leaf* obj - указатель на проверяемый узел дерева.
Выходные данные: булева переменная.
Процессы обработки: рекурсивно проверяются все комнаты,
начиная с текущей и заканчивая входной комнатой, с помощью указателя obj->parent. Если в цепочке
предыдущих комнат нашлась комната с координатами x и у, то возвращаем true, иначе возвращаем false.
Используемые внешние переменные: нет.
Подпрограмма void leaf:: SetNewLeaf (leaf *obj, int n)
Входные данные: указатель на узел дерева leaf* obj, номер узла int n.
Выходные данные: нет.
Процессы обработки: выделяется память для нового узла дерева.
Используемые внешние переменные: нет.
Подпрограмма void leaf:: Tracing (leaf* obj, int n)
Входные данные: указатель на узел последней комнаты leaf* obj, номер комнаты int n.
Выходные данные: нет.
Процессы обработки: комната в массиве лабиринта с
координатами из узла дерева поиска obj отмечается номером n и рекурсивно отмечается
предыдущий узел в дереве.
Используемые внешние переменные: массив комнат лабиринта a.
Подпрограмма void leaf:: GrowTree (TPoint p, leaf* obj)
Входные данные: указатель на узел дерева leaf* obj, координаты комнаты TPoint p.
Выходные данные: нет.
Процессы обработки: выполняется проверка текущей комнаты на
соответствие с выходной комнатой. При совпадении запоминается количество
собранных монет и путь отмечается номерами, иначе процедура рекурсивно
вызывается для соседних комнат.
Используемые внешние переменные: массив комнат лабиринта a.
3.3 Описание
подпрограмм класса TForm1
Подпрограмма void __fastcall TForm1:: Image1Click (TObject
*Sender)
Входные данные: указатель на вызывающий объект.
Выходные данные: нет.
Процессы обработки: окно приветствия скрывается и появляется
главное окно.
Используемые внешние переменные: нет.
3.4 Описание
подпрограмм класса TForm2
Подпрограмма void CreateLabirint ()
Входные данные: нет.
Выходные данные: нет.
Процессы обработки: инициализируется массив комнат, затем
циклом выбирается случайная комната и от нее формируется путь случайной длины.
После создания лабиринта случайным образом выбираются комнаты, в которых будут
находиться входная и выходная дверь.
Используемые внешние переменные: массив комнат лабиринта a, координаты входной и
выходной комнат A и B.
Подпрограмма void Draw ()
Входные данные: нет.
Выходные данные: нет.
Процессы обработки: на графический буфер выводятся комнаты
лабиринта и числа (номера комнат, количество монет, в зависимости от режима
отображения), затем из графического буфера изображение выводится в окно
программы.
Используемые внешние переменные: графический буфер buffer, режим отображения int info, массив комнат лабиринта
a.
Подпрограмма void InNul ()
Входные данные: нет.
Выходные данные: нет.
Процессы обработки: номера всех комнат лабиринта обнуляются.
Используемые внешние переменные: массив комнат лабиринта a.
Подпрограмма void __fastcall TForm2:: FormKeyPress (TObject
*Sender, char &Key)
Входные данные: ссылка на нажатую клавишу &Key, указатель на вызывающий
объект *Sender.
Выходные данные: нет.
Процессы обработки: обрабатывается нажатая клавиша. При
клавише "Пробел" режим отображения циклически меняется, при клавише
"Escape" процесс поиска пути прерывается. После нажатия лабиринт
перерисовывается.
Используемые внешние переменные: режим отображения int info, булева переменная -
запущен ли процесс поиска пути - bool process.
Подпрограмма void __fastcall TForm2:: FormCloseQuery (TObject
*Sender, bool &CanClose)
Входные данные: ссылка на булеву переменную - возможность
закрытия окна программы - &CanClose, указатель на вызывающий объект *Sender.
Выходные данные: нет.
Процессы обработки: если производится поиск пути, то окно
программы лишается возможности закрыться.
Используемые внешние переменные: булева переменная - запущен
ли процесс поиска пути - bool process.
Подпрограмма void __fastcall TForm2:: FormClose (TObject
*Sender, TCloseAction &Action)
Входные данные: ссылка на выполняемое действие &Action, указатель на вызывающий
объект *Sender.
Выходные данные: нет.
Используемые внешние переменные: нет.
Подпрограмма void __fastcall TForm2:: FormClick (TObject
*Sender)
Входные данные: указатель на вызывающий объект *Sender.
Выходные данные: нет.
Процессы обработки: запускается процесс поиска пути, после
которого выводятся сообщения об удачном или неудачном результате поиска.
Используемые внешние переменные: корень поискового дерева root, булевы переменные -
флаг запуска процесса поиска process, флаг прерывания процесса поиска newprocess, количество максимально
собранных сокровищ - int max, массив комнат лабиринта a.
Подпрограмма void __fastcall TForm2:: FormCreate (TObject
*Sender)
Входные данные: указатель на вызывающий объект *Sender.
Выходные данные: нет.
Процессы обработки: изменяется размеры графического буфера и
перерисовывается лабиринт.
Используемые внешние переменные: графический буфер buffer.
Список
использованных источников
1 Мозговой
М.В. Занимательное программирование. Самоучитель. 1-е изд. [Текст] - СПб.:
Питер, 2004. - 208 с.
2 Культин
Н.Б. C/C++ и в задачах и примерах. 2-е издание. [Текст] - СПб.: БХВ -
Петербург, 2011. - 368 с.
Архагельский
А.Я. Программирование в С++ Builder 6. [Текст] - М.: Бином, 2008. - 1152 с.: ил.
Ахо
А.В., Хопкрофт Д.Э., Ульман Д.Д. Структуры данных и алгоритмы. [Текст] - СПб.:
Вильямс, 2000. - 382 с.: ил.
Приложение
Листинг файла Unit1. cpp
//
---------------------------------------------------------------------------
#include <vcl. h>
#pragma hdrstop
#include "Unit1. h"
#include "Unit2. h"
//
---------------------------------------------------------------------------
#pragma package (smart_init)
#pragma resource "*. dfm"*Form1;
//
---------------------------------------------------------------------------
__fastcall TForm1:: TForm1 (TComponent* Owner)
: TForm (Owner)
{
}
//
---------------------------------------------------------------------------__fastcall
TForm1:: Image1Click (TObject *Sender)
{->Visible = false;->Visible =
true;->Show ();->SetFocus ();->FormClick (Form2);
}
//
---------------------------------------------------------------------------
Листинг файла Unit2. cpp
//
---------------------------------------------------------------------------
#include <vcl. h>
#pragma hdrstop
#include "Unit1. h"
#include "Unit2. h"
//
---------------------------------------------------------------------------
#pragma package (smart_init)
#pragma resource "*. dfm"
TForm2 *Form2;
// структура одной комнатыkomnata{
// является ли комната проходной или нетstena;
// сокровищаsokrovihe;
// номер комнаты в находимом путиnumber;
};
// структура узла дерева (комнаты), строящегося для
нахождения путиleaf{
// точка, ее координаты - это номер комнаты
// по горизонтали и вертикалиid;
// сколько денег накапливается до этой комнатыmone;
// указатель на предыдущую комнату* parent;
// указатели на соседние комнаты** kids;
// конструктор узла() {
// выделяется память для соседних комнат= new leaf* [4];
for (int i=0; i<4; i++)[i] =NULL;
}IsVisited (int x, int y, leaf* obj);SetNewLeaf
(leaf *obj, int n);Tracing (leaf* obj, int n);GrowTree (TPoint p, leaf* obj);
};
// размерность лабиринтаint N = 15;
// массив из комнатa [N] [N];
// максимальное значение накопленных сокровищmax = 0;
// режим отображения информацииinfo = 0;
// указатель на корень поискового дерева* root = NULL;
// точки - координаты комнат входа и выходаA,B;
// был ли запущен процесс поиска путиprocess = false;
// был ли прерван процесс поиска путиnewprocess = false;
// графический буфер для отрисовки лабиринта
Graphics:: TBitmap *buffer = new (Graphics::
TBitmap);
__fastcall TForm2:: TForm2 (TComponent* Owner)
: TForm (Owner)
{
}
// ---------------------------------------------------------------------------
// функция создания лабиринтаCreateLabirint ()
{
// создаем везде стены(int i=0;
i<=N; i++)(int j=0; j<=N; j++) {[i] [j]. stena = true;[i] [j].
sokrovihe=random (99) +1;[i] [j]. number=0; }
// текущая комната и направление движенияx,y,c;
// делаем N/2 циклов создания коридоров(int i=0; i<=N/2;
i++) {
// выбираем случайную комнату внутри лабиринта= random (N-2)
+1;= random (N-2) +1;
// выбираем случайное направление движения= random (4);
// выбираем случайное количество поворотов коридора
for (int d = random (3) +2; d>=0; d--) {
// выбираем случайное количество комнат до поворота
for (int k = random (3) +2; k>=0; k--) {(c) {
// переходим в одну из четырех сторон
case 0: x++; break;1: y++; break;2: x--; break;3:
y--; break; }
// самые крайние комнатамы не
делаем(x<=0||y<=0||x>=N-2||y>=N-2) break;
a [x] [y]. stena = false; }
// переходим на другое направление= (c+1) %4; }}
// случайно выбираем комнату, от которой будем строить путь
A. x=0; A. y=0;(A. x==0&&A. y==0)(a
[x=random (N)] [y=random (N)]. stena==false)
{A. x=x; A. y=y; };
// случайно выбираем комнату, до которой будем строить путь
B. x=0; B. y=0;(B. x==0&&B. y==0)(a
[x=random (N)] [y=random (N)]. stena==false)
{B. x=x; B. y=y; };
}
// функция отрисовки лабиринтаDraw ()
{
// размеры сетки лабиринта по горизонтали и вертикали
int n=buffer->Height/N;m=buffer->Width/N;
// закрашиваем нарисованное до
этого>Canvas->Brush->Color = clWhite;
buffer->Canvas->Pen->Color =
clWhite;>Canvas->Rectangle (0,0,buffer->Width, buffer->Height);
// проходим двойным циклом по массиву комнат
for (int i=0; i<N; i++)
for (int j=0; j<N; j++)
// если это стена, то закрашиваем ее черным прямоугольником
if (a [i] [j]. stena)
{>Canvas->Pen->Color = clBlack;>Canvas->Brush->Color =
clBlack;
buffer->Canvas->Rectangle (i*m,j*n,
i*m+m,j*n+n);
}else{
// если это комната, то в зависимости от режима отображения
рисуем по-разному(int inf=info) {
// выводим полную информацию:
case (0): {>Canvas->Brush->Color =
clWhite;>Canvas->Font->Color = clRed;
// если это комната входа, то закрашиваем ее желтым
if (i==A. x&&j==A. y)
{>Canvas->Brush->Color = clYellow;>Canvas->Pen->Color =
clYellow;>Canvas->Font->Color = clBlack;
buffer->Canvas->Rectangle (i*m,j*n,
i*m+m,j*n+n); }
// если это комната выхода, то закрашиваем ее голубым
if (i==B. x&&j==B. y)
{>Canvas->Brush->Color = clSkyBlue;>Canvas->Pen->Color =
clSkyBlue;>Canvas->Font->Color = clBlack;
buffer->Canvas->Rectangle (i*m,j*n,
i*m+m,j*n+n); }
// выводим в верхнем левом углу количество монет, которое
можно забрать в этой комнате
buffer->Canvas->TextOutA (i*m+1,j*n+1,
IntToStr (a [i] [j]. sokrovihe));
// если через эту комнату не ведет путь, то уходим
if (a [i] [j]. number==0) continue;
// иначе запоминаем номер комнаты в пути
String s=IntToStr (a [i] [j]. number);
// запоминаем его размеры при
отрисовкеI=i*m+m-buffer->Canvas->TextWidth (s);
int J=j*n+n-buffer->Canvas->TextHeight
(s);>Canvas->Brush->Color = clLime;>Canvas->Font->Color =
clBlack;
// и выводим его на зелёном фоне
buffer->Canvas->TextOutA (I,J,s);; }
// режим отображения найденного пути1: {
buffer->Canvas->Brush->Color =
clLime;>Canvas->Pen->Color = clBlack;>Canvas->Font->Color =
clBlack;
// увеличиваем размер шрифта>Canvas->Font->Size+=3;
// запоминаем размеры надписиs=IntToStr (a
[i] [j]. number);I=buffer->Canvas->TextWidth
(s);J=buffer->Canvas->TextHeight (s);
// рассчитываем ее координаты, чтобы вывести посередине
int x=i*m+ (m-I) /2;y=j*n+ (n-J) /2;
// если эта комната не включена в путь то закрашиваем ее
if (a [i] [j]. number==0)>Canvas->Brush->Color
= clWhite;
buffer->Canvas->Rectangle (i*m,j*n,
i*m+m,j*n+n);
// иначе выводим ее номер от входной по порядку
break; }
// вывод информации о сокровищах2: {
buffer->Canvas->Font->Color =
clBlack;>Canvas->Brush->Color = clYellow;>Canvas->Pen->Color
= clBlack;
buffer->Canvas->Font->Size+=3;
// запоминаем размеры выводимой надписи
String s=IntToStr (a [i] [j].
sokrovihe);I=buffer->Canvas->TextWidth (s);J=buffer->Canvas->TextHeight
(s);
int x=i*m+ (m-I) /2;y=j*n+ (n-J) /2;
// если комната не включена в путь, то фон делаем белым
if (a [i] [j].
number==0)>Canvas->Brush->Color = clWhite;
buffer->Canvas->Rectangle (i*m,j*n,
i*m+m,j*n+n);
buffer->Canvas->TextOutA
(x,y,s);>Canvas->Font->Size-=3; }
}}
// копируем все нарисованное из буфера в окно программы
Form2->Canvas->CopyRect (TRect
(0,0,Form2->Width,Form2->Height),>Canvas,TRect
(0,0,Form2->Width,Form2->Height));
}
// рекурсивная функция проверки посещения комнатыleaf::
IsVisited (int x, int y, leaf* obj)
{
// если координаты этой комнаты не совпадают с координатами
искомой(obj! =NULL)
// и не совпадают с координатами предыдущей комнаты, то
возвращаем ложь
return (obj->id. x==x&&obj->id.
y==y) ||IsVisited (x,y,obj->parent);return false;
}
// функция установки нового листаleaf::
SetNewLeaf (leaf *obj, int n)
{
// выделяем память>kids [n] =new leaf;
// назначаем предыдущую комнату в дереве посещений
obj->kids [n] - >parent = obj;
}
// реверсивная функция разметки путиleaf:: Tracing (leaf*
obj, int n)
{(obj! =NULL) {
// отмечаем комнату номером n[obj->id. x] [obj->id. y].
number=n;
// и предыдущую комнату номером n-1(obj->parent,n+1); }
}
// функция установки номеров всех комнат в 0
void InNul ()
{(int i=0; i<N; i++)(int j=0; j<N; j++)[i]
[j]. number=0;
}
// функция поиска пути в лабиринте
// в процессе создается дерево из комнат
void leaf:: GrowTree (TPoint p, leaf* obj)
{
// обрабатываем системные сообщения приложения: нажатия мыши,
клавиш>ProcessMessages ();
// если был переключен режим
// то меняем
заголовок(info==1)->Caption="Обрабатывается комната с координатами
"+IntToStr (p. x) +","+IntToStr (p. y) +".
";(info==2)(max! =0)->Caption="Текущий путь забирает монет:
"+IntToStr (max)
+"; через "+IntToStr (a [A. x] [A. y]. number)
+" комнат";->Caption="Путь еще не найден";
// записываем суммарное количество забранных
монет(obj->parent == NULL)
obj->mone=a [p. x] [p. y].
sokrovihe;>mone=obj->parent->mone+a [p. x] [p. y]. sokrovihe;
// записываем координаты текущей комнаты
obj->id = p;
// если текущая - это та, которую нам надо было найти
if (p. x==B. x&&p. y==B. y) {
// если мы еще не записывали максимальное количество монет
// или нашли новый максимальный
путь(max==0||obj->mone>max) {
// записываем количество монет=obj->mone;
// обнуляем все комнаты();
// записываем путь(obj,1);
// отрисовываем();
}
// удаляем выделенную память[] obj->kids;obj;
// выходим;
}
// если мы не отменяли процесс поиска клавишей Escape
// то добавляем ссылки на соседние комнаты
if (! newprocess) {(! a [p. x-1] [p. y].
stena&&! IsVisited (p. x-1,p. y,obj))(obj,0);(! a [p. x+1] [p. y].
stena&&! IsVisited (p. x+1,p. y,obj))(obj,1);(! a [p. x] [p. y-1].
stena&&! IsVisited (p. x,p. y-1,obj))(obj,2);(! a [p. x] [p. y+1].
stena&&! IsVisited (p. x,p. y+1,obj))(obj,3);
// и рекурсивно обрабатываем соседние комнаты(obj->kids
[0]! =NULL)(TPoint (p. x-1,p. y),obj->kids [0]);(obj->kids [1]!
=NULL)(TPoint (p. x+1,p. y),obj->kids [1]);(obj->kids [2]! =NULL)(TPoint
(p. x,p. y-1),obj->kids [2]);(obj->kids [3]! =NULL)(TPoint (p. x,p.
y+1),obj->kids [3]);
}
// удаляем выделенную память[] obj->kids;obj;
}
//
---------------------------------------------------------------------------
// при нажатии клавиши__fastcall TForm2:: FormKeyPress
(TObject *Sender, char &Key)
{
if (Key==VK_SPACE)= (info+1) %3;
// если Escape, то устанавливаем переменную, которая досрочно
завершит работу
// функции поиска(Key==VK_ESCAPE)= true;
// при начальном режиме вывода
информации(info==0)(process)="Производится поиск пути. (вкл/откл
информацию - Пробел)";="Путь найден (для смены вида - Пробел)";
if (! info&&! process)="Текущий путь забирает монет:
"+IntToStr (max)
+"; через "+IntToStr (a [A. x] [A. y]. number)
+" комнат";
Draw ();
}
// если идет процесс поиска, то нельзя выходить
//
---------------------------------------------------------------------------__fastcall
TForm2:: FormCloseQuery (TObject *Sender, bool &CanClose)
{(process) CanClose=false;
}
// ---------------------------------------------------------------------------
// выход из программы__fastcall
TForm2:: FormClose (TObject *Sender, TCloseAction &Action)
{>Terminate ();
}
//
---------------------------------------------------------------------------
// нажатие кнопки мыши__fastcall
TForm2:: FormClick (TObject *Sender)
{
// если процесс поиска уже запущен, то уведовляем и уходим
if (process) {="Идет поиск. Для остановки нажмите
Escape";; }
// заново создаем лабиринт= false;
CreateLabirint ();
// создаем корень дерева= new
leaf;>parent = NULL;= 0;= 0;
// отрисовываем пусто лабиринт
Draw ();="Производится поиск пути. (вкл/откл информацию
- Пробел)";= true;
// ищем путь.>GrowTree (A,root);
// отрисовываем();
// если так и не нвшли(max==0) {="Путь невозможно найти!
Лабиринт следует перестроить!";("Путь невозможно найти! Лабиринт
следует перестроить!");
} else {
// если нашли, то выводим сообщения= "Путь
найден!";("Найден путь, проходящий через "+IntToStr (a [A. x]
[A. y]. number) +" комнат");("Собрано монет: "+IntToStr
(max)); }= false;
}
//
---------------------------------------------------------------------------
// устанавливаем размеры графического буфера
void __fastcall TForm2:: FormCreate (TObject
*Sender)
{>Width=Form2->Width;>Height=Form2->Height;
Draw ();
}
//
---------------------------------------------------------------------------