Задача о переливаниях

USES Crt{clrScr,readKey};
{Описание операции по переливанию воды.}
TYPE
  Deistvie=RECORD
    otkuda,kuda:Byte;
  END;
  UkazDeistvo=^Deistvie;
{Процедура вывода номера операции по переливанию воды
вместе с кратким описанием самой операции (формат otkuda -> kuda).
nomer - номер операции,
operacia - указатель на структуру, описывающую действие.}
PROCEDURE vyvodOperacii(nomer:Word;operacia:UkazDeistvo);
BEGIN
  write(nomer:4,') ',operacia^.otkuda+1,' -> ',operacia^.kuda+1,':');
END;
{Процедура для обработки ошибки с выводом
соответствующего сообщения, ожиданием
нажатия клавиши и возвратом кода ошибки.
priznak_oshibki - условие, по которому проверяется наличие ошибки,
kod_oshibki - код ошибки,
soobshchenie - строка с сообщением, которое выводится при ошибке.}
PROCEDURE obrabotkaOshibok(
  priznak_oshibki:Boolean;
  kod_oshibki:Word;
  CONST soobshchenie:String);
BEGIN
  IF NOT priznak_oshibki THEN EXIT;
  writeLn(soobshchenie);
  IF readKey=#0 THEN readKey;
  halt(kod_oshibki);
END;
{Стек операций по переливанию воды.}
CONST
  {Базовая емкость стека.}
  bazovaya_emkost=8;
  {Максимальная емкость стека.}
  maksimalnaya_emkost=1024;
TYPE
  UkazStek=^Stek;
  Stek=OBJECT
    PRIVATE
      {Количество памяти, занятой стеком.}
      zanyato_pamyati:Word;
      {Емкость (максимальное количество элементов) стека.}
      emkost:Word;
      {Указатель на начало памяти, выделенной
      под массив элементов стека.}
      nachalo:UkazDeistvo;
      {Указатель на вершину стека.}
      vershina:UkazDeistvo;
      {Указатель на конец памяти, выделенной под массив
      элементов стека - на место сразу за последней
      доступной ячейкой памяти.}
      konec:UkazDeistvo;
    PUBLIC
      CONSTRUCTOR sozdanie;
      DESTRUCTOR unichtozhenie;
      PROCEDURE dobavlenie(element:UkazDeistvo);
      PROCEDURE sozKopii(kopiya:UkazStek);
      FUNCTION poluchenieNachala:UkazDeistvo;
      FUNCTION poluchenieVershiny:UkazDeistvo;
  END;
{Создание стека.}
CONSTRUCTOR Stek.sozdanie;
BEGIN
  emkost:=bazovaya_emkost;
  zanyato_pamyati:=emkost*sizeOf(Deistvie);
  obrabotkaOshibok(maxAvail<zanyato_pamyati,1,'Память исчерпана.');
  getMem(nachalo,zanyato_pamyati);
  vershina:=nachalo;
  konec:=nachalo;
  inc(konec,emkost);
END;
{Уничтожение стека.}
DESTRUCTOR Stek.unichtozhenie;
BEGIN
  konec:=NIL;
  vershina:=NIL;
  freeMem(nachalo,zanyato_pamyati);
  nachalo:=NIL;
END;
{Добавление нового действия в стек операций.
element - указатель на добавляемый элемент.}
PROCEDURE Stek.dobavlenie(element:UkazDeistvo);
VAR novyi_mas,kursor:UkazDeistvo;
BEGIN
  IF vershina=konec THEN BEGIN
    {В стеке больше нет места, можно ли увеличить его размер?}
    obrabotkaOshibok(emkost=maksimalnaya_emkost,2,
    'Стек переполнен.');
    obrabotkaOshibok(maxAvail<zanyato_pamyati SHL 1,1,
    'Память исчерпана.');
    {Если дошли до этого места - можем считать, что получили
    добро на увеличение размера массива элементов стека.}
    getMem(novyi_mas,zanyato_pamyati SHL 1);
    kursor:=novyi_mas;
    vershina:=nachalo;
    {Перенос информации в новый массив.}
    WHILE vershina<>konec DO BEGIN
      kursor^:=vershina^;
      inc(kursor);
      inc(vershina);
    END;
    {Освобождение старого массива и корректировка ссылок.}
    freeMem(nachalo,zanyato_pamyati);
    nachalo:=novyi_mas;
    vershina:=kursor;
    emkost:=emkost SHL 1;
    zanyato_pamyati:=zanyato_pamyati SHL 1;
    konec:=nachalo;
    inc(konec,emkost);
  END;
  vershina^:=element^;
  inc(vershina);
END;
{Копирование данных из текущего стека в новый.
kopiya - указатель на стек, куда копируются данные.}
PROCEDURE Stek.sozKopii(kopiya:UkazStek);
VAR kursor:UkazDeistvo;
BEGIN
  kursor:=nachalo;
  kopiya^.vershina:=kopiya^.nachalo;
  WHILE kursor<>vershina DO BEGIN
    kopiya^.dobavlenie(kursor);
    inc(kursor);
  END;
END;
{Получение указателя на начало стека.}
FUNCTION Stek.poluchenieNachala:UkazDeistvo;
BEGIN
  poluchenieNachala:=nachalo;
END;
{Получение указателя на вершину стека.}
FUNCTION Stek.poluchenieVershiny:UkazDeistvo;
BEGIN
  poluchenieVershiny:=vershina;
END;
{Ведро с водой.}
TYPE
  UkazVedro=^Vedro;
  Vedro=OBJECT
    PRIVATE
      {Количество воды в ведре.}
      voda:Word;
      {Количество воздуха в ведре,
      иначе говоря, объем ведра, не занятый водой.}
      vozdukh:Word;
      PROCEDURE otlivanie(kol_vo:Word);
      PROCEDURE dolivanie(kol_vo:Word);
    PUBLIC
      CONSTRUCTOR sozdanie(objem:Word);
      PROCEDURE napolnenie;
      PROCEDURE opustoshenie;
      FUNCTION perelivanie(kuda:UkazVedro):Boolean;
      PROCEDURE sozKopii(kopiya:UkazVedro);
      FUNCTION kolichestvoVody:Word;
  END;
{Создание ведра указанного объема.
objem - объем ведра, которое необходимо создать.}
CONSTRUCTOR Vedro.sozdanie(objem:Word);
BEGIN
  voda:=0;
  vozdukh:=objem;
END;
{Наполнение ведра водой до краев.}
PROCEDURE Vedro.napolnenie;
BEGIN
  inc(voda,vozdukh);
  vozdukh:=0;
END;
{Опустошение ведра.}
PROCEDURE Vedro.opustoshenie;
BEGIN
  inc(vozdukh,voda);
  voda:=0;
END;
{Отливание указанного объема воды из ведра.
kol_vo - количество воды, которое необходимо отлить.}
PROCEDURE Vedro.otlivanie(kol_vo:Word);
BEGIN
  inc(vozdukh,kol_vo);
  dec(voda,kol_vo);
END;
{Доливание указанного объема воды в ведро.
kol_vo - количество воды, которое необходимо долить.}
PROCEDURE Vedro.dolivanie(kol_vo:Word);
BEGIN
  inc(voda,kol_vo);
  dec(vozdukh,kol_vo);
END;
{Переливание воды в указанное ведро. Функция возвращает истину,
если удалось перелить хотя бы каплю воды.
kuda - указатель на ведро, куда мы переливаем воду.}
FUNCTION Vedro.perelivanie(kuda:UkazVedro):Boolean;
BEGIN
  perelivanie:=FALSE;
  IF voda=0 THEN EXIT;
  IF kuda^.vozdukh=0 THEN EXIT;
  IF kuda^.vozdukh<voda THEN BEGIN
    otlivanie(kuda^.vozdukh);
    kuda^.napolnenie;
  END ELSE BEGIN
    kuda^.dolivanie(voda);
    opustoshenie;
  END;
  perelivanie:=TRUE;
END;
{Копирование состояния ведра.
kopiya - указатель на ведро, которое
необходимо сделать копией текущего ведра.}
PROCEDURE Vedro.sozKopii(kopiya:UkazVedro);
BEGIN
  kopiya^.voda:=voda;
  kopiya^.vozdukh:=vozdukh;
END;
{Получение информации о количестве воды в ведре.}
FUNCTION Vedro.kolichestvoVody:Word;
BEGIN
  kolichestvoVody:=voda;
END;
VAR
  {Количество имеющихся в наличии емкостей.}
  kol_vo_veder:Byte;
  {Цель по объему воды в ведре.}
  tsel_po_objemy:Word;
{Описание состояния воды в ведрах.}
TYPE
  UkazSostoyanie=^Sostoyanie;
  Sostoyanie=OBJECT
    PRIVATE
      {Количество памяти, занятой массивом ведер.}
      zanyato_pamyati:Word;
      {Указатель на массив из kol_vo_veder ведер.}
      vedra:UkazVedro;
      {Указатель на стек с описанием действий,
      которые было произведены над ведрами.}
      deistviya:UkazStek;
    PUBLIC
      CONSTRUCTOR sozdanie;
      DESTRUCTOR unichtozhenie;
      PROCEDURE vvod;
      PROCEDURE vyvod;
      FUNCTION perelivanie(otkuda:Word;kuda:Word):Boolean;
      FUNCTION tselDostignuta:Boolean;
      PROCEDURE sozKopii(kopiya:UkazSostoyanie);
  END;
{Создание нового объекта с описанием состояния воды.}
CONSTRUCTOR Sostoyanie.sozdanie;
BEGIN
  zanyato_pamyati:=kol_vo_veder*sizeOf(Vedro);
  obrabotkaOshibok(maxAvail<zanyato_pamyati,1,'Память исчерпана.');
  getMem(vedra,zanyato_pamyati);
  new(deistviya,sozdanie);
END;
{Уничтожение объекта с описанием состояния воды.}
DESTRUCTOR Sostoyanie.unichtozhenie;
BEGIN
  dispose(deistviya,unichtozhenie);
  freeMem(vedra,zanyato_pamyati);
END;
{Запрос на ввод параметров емкостей.}
PROCEDURE Sostoyanie.vvod;
VAR
  kursor:UkazVedro;
  i,objem:Word;
BEGIN
  kursor:=vedra;
  FOR i:=1 TO kol_vo_veder DO BEGIN
    write('Введите объем ведра №',i,': ');
    readLn(objem);
    kursor^.sozdanie(objem);
    inc(kursor);
  END;
  vedra^.napolnenie;{Наполняем первое ведро водой.}
END;
{Вывод текущего состояния воды.}
PROCEDURE Sostoyanie.vyvod;
VAR
  vershina,predel:UkazDeistvo;
  kursor:UkazVedro;
  i,nomer:Word;
BEGIN
  vershina:=deistviya^.poluchenieNachala;
  predel:=deistviya^.poluchenieVershiny;
  nomer:=0;
  WHILE vershina<>predel DO BEGIN
    inc(vershina);
    inc(nomer);
  END;
  IF nomer<>0 THEN BEGIN
    dec(vershina);
    vyvodOperacii(nomer,vershina);
  END ELSE write('      Начало:');
  kursor:=vedra;
  FOR i:=1 TO kol_vo_veder DO BEGIN
    write(' ',kursor^.kolichestvoVody:5);
    inc(kursor);
  END;
  writeLn;
END;
{Переливание воды из одного ведра в другое. Функция
возвращает истину, если удалось перелить хотя бы каплю воды.
otkuda - номер ведра, откуда мы берем воду,
kuda - номер ведра, куда мы переливаем воду.}
FUNCTION Sostoyanie.perelivanie(otkuda:Word;kuda:Word):Boolean;
VAR
  uotkuda,ukuda:UkazVedro;
  uspeshno:Boolean;
  operacia:Deistvie;
BEGIN
  uotkuda:=vedra;
  ukuda:=vedra;
  inc(uotkuda,otkuda);
  inc(ukuda,kuda);
  uspeshno:=uotkuda^.perelivanie(ukuda);
  IF uspeshno THEN BEGIN
    operacia.otkuda:=otkuda;
    operacia.kuda:=kuda;
    deistviya^.dobavlenie(@operacia);
  END;
  perelivanie:=uspeshno;
END;
{Проверка на достижение цели по объему воды.}
FUNCTION Sostoyanie.tselDostignuta:Boolean;
VAR
  kursor:UkazVedro;
  i:Word;
BEGIN
  tselDostignuta:=FALSE;
  kursor:=vedra;
  FOR i:=1 TO kol_vo_veder DO BEGIN
    IF kursor^.kolichestvoVody=tsel_po_objemy THEN BEGIN
      tselDostignuta:=TRUE;
      EXIT;
    END;
    inc(kursor);
  END;
END;
{Создание копии состояния воды.
kopiya - указатель на объект, куда копируются данные.}
PROCEDURE Sostoyanie.sozKopii(kopiya:UkazSostoyanie);
VAR
  kursor,novye_vedra:UkazVedro;
  i:Word;
BEGIN
  novye_vedra:=kopiya^.vedra;
  kursor:=vedra;
  FOR i:=1 TO kol_vo_veder DO BEGIN
    kursor^.sozKopii(novye_vedra);
    inc(novye_vedra);
    inc(kursor);
  END;
  deistviya^.sozKopii(kopiya^.deistviya);
END;
{Очередь состояний воды в ведрах.}
TYPE
  Ochered=OBJECT
    PRIVATE
      {Количество памяти, занятой очередью.}
      zanyato_pamyati:Word;
      {Указатель на начало памяти, выделенной
      под массив элементов очереди.}
      nachalo:UkazSostoyanie;
      {Указатель на голову очереди - первого
      кандидата на извлечение из очереди.}
      golova:UkazSostoyanie;
      {Указатель на хвост очереди - свободное место
      сразу за последним добавленным в очередь элементом.}
      khvost:UkazSostoyanie;
      {Указатель на конец памяти, выделенной под массив
      элементов очереди - на место сразу за последней
      доступной ячейкой памяти.}
      konec:UkazSostoyanie;
    PUBLIC
      CONSTRUCTOR sozdanie(emkost:Word);
      DESTRUCTOR unichtozhenie;
      PROCEDURE dobavlenie(element:UkazSostoyanie);
      PROCEDURE izvlechenie(kopiya:UkazSostoyanie);
      FUNCTION nepusta:Boolean;
  END;
{Создание очереди заданной емкости.
emkost - емкость (максимальное количество элементов) новой очереди.}
CONSTRUCTOR Ochered.sozdanie(emkost:Word);
VAR kursor:UkazSostoyanie;
BEGIN
  zanyato_pamyati:=emkost*sizeOf(Sostoyanie);
  obrabotkaOshibok(maxAvail<zanyato_pamyati,1,'Память исчерпана.');
  getMem(nachalo,zanyato_pamyati);
  golova:=nachalo;
  khvost:=nachalo;
  konec:=nachalo;
  inc(konec,emkost);
  {Инициализация внутреннего массива очереди.}
  kursor:=nachalo;
  WHILE kursor<>konec DO BEGIN
    kursor^.sozdanie;
    inc(kursor);
  END;
END;
{Уничтожение очереди.}
DESTRUCTOR Ochered.unichtozhenie;
VAR kursor:UkazSostoyanie;
BEGIN
  kursor:=nachalo;
  WHILE kursor<>konec DO BEGIN
    kursor^.unichtozhenie;
    inc(kursor);
  END;
  konec:=NIL;
  golova:=NIL;
  khvost:=NIL;
  freeMem(nachalo,zanyato_pamyati);
  nachalo:=NIL;
END;
{Добавление состояния емкостей в очередь.
element - добавляемый в очередь элемент (состояние емкостей).}
PROCEDURE Ochered.dobavlenie(element:UkazSostoyanie);
VAR sleduyushchiy:UkazSostoyanie;
BEGIN
  sleduyushchiy:=khvost;
  inc(sleduyushchiy);
  IF sleduyushchiy=konec THEN sleduyushchiy:=nachalo;
  obrabotkaOshibok(sleduyushchiy=golova,3,'Очередь переполнена.');
  element^.sozKopii(khvost);
  khvost:=sleduyushchiy;
END;
{Извлечение состояния емкостей из очереди.
kopiya - указатель на переменную, куда копируется состояние.}
PROCEDURE Ochered.izvlechenie(kopiya:UkazSostoyanie);
BEGIN
  obrabotkaOshibok(golova=khvost,4,
  'Попытка извлечения элемента из пустой очереди.');
  golova^.sozKopii(kopiya);
  inc(golova);
  IF golova=konec THEN golova:=nachalo;
END;
{Проверка очереди на непустоту. Возвращает истину,
если очередь не пуста, или ложь в противном случае.}
FUNCTION Ochered.nepusta:Boolean;
BEGIN
  nepusta:=golova<>khvost;
END;
{Узел дерева.}
TYPE
  UkazUzel=^Uzel;
  Uzel=OBJECT
    PRIVATE
      {Ключ узла.}
      kluch:Word;
      {Указатель на узел, являющийся потомком данного узла.}
      potomok:UkazUzel;
      {Указатель на узел, являющийся младшим братом данного узла.}
      brat:UkazUzel;
    PUBLIC
      CONSTRUCTOR sozdanie(novyi_kluch:Word);
      DESTRUCTOR unichtozhenie;
      FUNCTION poisk(kluch_poiska:Word):UkazUzel;
      FUNCTION mladshii:UkazUzel;
      FUNCTION dobavlenie(novyi_kluch:Word;
      VAR schetchik_izmeneniy:Word):UkazUzel;
  END;
{Создание нового узла с заданным ключом.
novyi_kluch - значение ключа для нового узла.}
CONSTRUCTOR Uzel.sozdanie(novyi_kluch:Word);
BEGIN
  kluch:=novyi_kluch;
  potomok:=NIL;
  brat:=NIL;
END;
{Уничтожение узла и всех связанных с ним узлов.}
DESTRUCTOR Uzel.unichtozhenie;
BEGIN
  IF potomok<>NIL THEN BEGIN
    dispose(potomok,unichtozhenie);
    potomok:=NIL;
  END;
  IF brat<>NIL THEN BEGIN
    dispose(brat,unichtozhenie);
    brat:=NIL;
  END;
END;
{Поиск узла с заданным ключом среди детей данного узла.
Если узел с заданным ключом найден, возвращается указатель
на найденный узел, иначе возвращается нулевой указатель.
kluch_poiska - ключ, по которому осуществляется поиск.}
FUNCTION Uzel.poisk(kluch_poiska:Word):UkazUzel;
VAR kursor:UkazUzel;
BEGIN
  kursor:=potomok;
  WHILE kursor<>NIL DO BEGIN
    IF kursor^.kluch=kluch_poiska THEN break;
    kursor:=kursor^.brat;
  END;
  poisk:=kursor;
END;
{Получение указателя на самого младшего брата данного узла.}
FUNCTION Uzel.mladshii:UkazUzel;
VAR kursor:UkazUzel;
BEGIN
  kursor:=potomok;
  WHILE kursor^.brat<>NIL DO BEGIN
    kursor:=kursor^.brat;
  END;
  mladshii:=kursor;
END;
{Добавление узла с заданным ключом в список детей данного
узла. Функция возвращает указатель на ребенка узла,
имеющего заданный ключ, и увеличивает счетчик изменений
на единицу, если узел был добавлен. Если узел с таким
ключом уже есть, то счетчик изменений не меняется.
novyi_kluch - значение ключа для добавляемого узла,
schetchik_izmeneniy - счетчик изменений в узлах.}
FUNCTION Uzel.dobavlenie(novyi_kluch:Word;
VAR schetchik_izmeneniy:Word):UkazUzel;
VAR kursor,novyi_uzel:UkazUzel;
BEGIN
  kursor:=poisk(novyi_kluch);
  IF kursor<>NIL THEN dobavlenie:=kursor ELSE BEGIN
    inc(schetchik_izmeneniy);
    new(novyi_uzel,sozdanie(novyi_kluch));
    IF potomok<>NIL THEN mladshii^.brat:=novyi_uzel
    ELSE potomok:=novyi_uzel;
    dobavlenie:=novyi_uzel;
  END;
END;
{Дерево.}
TYPE
  Derevo=OBJECT
    PRIVATE
      {Корень дерева.}
      koren:UkazUzel;
    PUBLIC
      CONSTRUCTOR sozdanie;
      DESTRUCTOR unichtozhenie;
      FUNCTION dobavlenie(sos_ye:UkazSostoyanie):Boolean;
  END;
{Создание дерева.}
CONSTRUCTOR Derevo.sozdanie;
BEGIN
  new(koren,sozdanie(0));
END;
{Уничтожение дерева.}
DESTRUCTOR Derevo.unichtozhenie;
BEGIN
  dispose(koren,unichtozhenie);
END;
{Добавление в дерево ключа, соответствующего заданному состоянию.
Функция возвращает истину, если ключ был добавлен, или ложь,
если ключ, соответствующий заданному состоянию, уже есть в дереве.
sos_ye - указатель на анализируемое состояние.} 
FUNCTION Derevo.dobavlenie(sos_ye:UkazSostoyanie):Boolean;
VAR
  i,schetchik_izmeneniy:Word;
  kursor:UkazUzel;
  vedra:UkazVedro;
BEGIN
  schetchik_izmeneniy:=0;
  kursor:=koren;
  vedra:=sos_ye^.vedra;
  FOR i:=1 TO kol_vo_veder DO BEGIN
    kursor:=kursor^.dobavlenie(
    vedra^.kolichestvoVody,schetchik_izmeneniy);
    inc(vedra);
  END;
  dobavlenie:=schetchik_izmeneniy<>0;
END;
{Функция нахождения решения. Возвращает указатель на стек со списком
требуемых для решения операций, либо нулевой указатель, если решение
не найдено.
nach_sos_ye - указатель на состояние ведер,
начиная с которого производится поиск решения.}
FUNCTION nakhozhdenieResheniya(nach_sos_ye:UkazSostoyanie):UkazStek;
VAR
  och_resheniya:Ochered;
  tek_sostoyanie,kopiya:UkazSostoyanie;
  der_sostoyaniyi:Derevo;
  reshenie:UkazStek;
  otkuda,kuda:Word;
BEGIN
  {Выделение памяти под текущее состояние, очередь
  вариантов решения и дерево состояний.}
  och_resheniya.sozdanie(512);
  new(tek_sostoyanie,sozdanie);
  new(kopiya,sozdanie);
  der_sostoyaniyi.sozdanie;
  {Поиск решения с помощью обхода в ширину
  графа возможных переливаний воды.}
  reshenie:=NIL;
  och_resheniya.dobavlenie(nach_sos_ye);
  WHILE och_resheniya.nepusta DO BEGIN
    och_resheniya.izvlechenie(tek_sostoyanie);
    IF tek_sostoyanie^.tselDostignuta THEN BEGIN
      new(reshenie,sozdanie);
      tek_sostoyanie^.deistviya^.sozKopii(reshenie);
      break;
    END;
    {Перебор всех вариантов переливаний со следующими
    проверками:
    1) Проверяется, что исследуемое переливание действительно
    меняет состояние воды в ведрах.
    2) Проверяется, что новое состояние, полученное в ходе
    переливания, не совпадает с одним из ранее полученных состояний.
    В случае успешного прохождения всех проверок новое состояние
    добавляется в очередь для дальнейшего исследования.}
    FOR otkuda:=0 TO kol_vo_veder-2 DO
      FOR kuda:=otkuda+1 TO kol_vo_veder-1 DO BEGIN
        tek_sostoyanie^.sozKopii(kopiya);
        IF kopiya^.perelivanie(otkuda,kuda) THEN
          IF der_sostoyaniyi.dobavlenie(kopiya) THEN
            och_resheniya.dobavlenie(kopiya);
        tek_sostoyanie^.sozKopii(kopiya);
        IF kopiya^.perelivanie(kuda,otkuda) THEN
          IF der_sostoyaniyi.dobavlenie(kopiya) THEN
            och_resheniya.dobavlenie(kopiya);
      END;
  END;
  {Освобождение занятой в процессе переливания памяти.}
  der_sostoyaniyi.unichtozhenie;
  dispose(kopiya,unichtozhenie);
  dispose(tek_sostoyanie,unichtozhenie);
  och_resheniya.unichtozhenie;
  nakhozhdenieResheniya:=reshenie;
END;
{Основная программа.}
CONST
  strok_na_stranice=20;
VAR
  nach_sos_ye:UkazSostoyanie;
  reshenie:UkazStek;
  tek_deistvie,okonchanie:UkazDeistvo;
  strok_resheinya:Word;
BEGIN
  clrScr;
  strok_resheinya:=0;
  {Ввод исходных данных.}
  write('Введите количество ведер: ');
  readLn(kol_vo_veder);
  inc(strok_resheinya);
  WHILE NOT (kol_vo_veder IN [2..9]) DO BEGIN
    writeLn('Количество ведер должно быть в промежутке от 2 до 9.');
    write('Повторите попытку: ');
    readLn(kol_vo_veder);
    inc(strok_resheinya,2);
  END;
  write('Введите цель по объему воды: ');
  readLn(tsel_po_objemy);
  inc(strok_resheinya);
  new(nach_sos_ye,sozdanie);
  nach_sos_ye^.vvod;
  inc(strok_resheinya,kol_vo_veder);
  {Поиск решения задачи.}
  reshenie:=nakhozhdenieResheniya(nach_sos_ye);
  {Анализ результатов решения.}
  IF reshenie<>NIL THEN writeLn('Есть решение.')
  ELSE writeLn('Решения нет.');
  IF reshenie<>NIL THEN BEGIN
    nach_sos_ye^.vyvod;
    inc(strok_resheinya);
    tek_deistvie:=reshenie^.poluchenieNachala;
    okonchanie:=reshenie^.poluchenieVershiny;
    WHILE tek_deistvie<>okonchanie DO BEGIN
      nach_sos_ye^.perelivanie(tek_deistvie^
      .otkuda,tek_deistvie^.kuda);
      nach_sos_ye^.vyvod;
      inc(strok_resheinya);
      inc(tek_deistvie);
      {Каждые strok_na_stranice строк ставим вывод результатов
      на паузу, чтобы резульаты не убежали за верхний край экрана.}
      IF(tek_deistvie<>okonchanie)
      AND(strok_resheinya MOD strok_na_stranice=0) THEN BEGIN
        writeLn('Нажмите клавишу для продолжения...');
        readKey;
        clrScr;
      END;
    END;
    dispose(reshenie,unichtozhenie);
  END;
  dispose(nach_sos_ye,unichtozhenie);
  readKey;
END.