Жанр: Учеба
Программирование в теоремах и задачах
... | у подхвоста влево ("впуклость") do begin
| выкинуть подхвост из дека
end
Таким же способом устраняется впуклость у головы дека.
Замечание. Действия с подхвостом и подподхвостом не входят в
определение дека, однако сводятся к небольшому числу манипуляций
с деком (надо забрать три элемента с хвоста, сделать что надо и
вернуть).
Ещё одно замечание. Есть два вырожденных случая: если мы вообще
не поворачиваем у похвоста (т.е. три соседние вершины лежат
на одной прямой) и если мы поворачиваем на 180 градусов (так бывает,
если наш многоугольник есть двуугольник). В первом случае
подхвост стоит удалить (чтобы в выпуклой оболочке не было лишних
вершин), а во втором случае - обязательно оставить.
6.3. Множества.
Пусть Т - некоторый тип. Существует много способов хранить
(конечные) множества элементов типа Т; выбор между ними определяется
типом T и набором требуемых операций.
Подмножества множества {1..n}.
6.3.1. Используя память, пропорциональную n, хранить
подмножества множества {1..n}.
Операции Число действий
Сделать пустым C*n
Проверить принадлежность C
Добавить C
Удалить С
Минимальный элемент C*n
Проверка пустоты C*n
Решение. Храним множество как array [1..n] of boolean.
6.3.2. То же, но проверка пустоты должна выполняться за
время C.
Решение. Храним дополнительно количество элементов.
6.3.3. То же при следующих ограничениях на число действий:
Операции Число действий
Сделать пустым C*n
Проверить принадлежность C
Добавить C
Удалить C*n
Минимальный элемент C
Проверка пустоты C
Решение. Дополнительно храним минимальный элемент множества.
6.3.4 То же при следующих ограничениях на число действий:
Операции Число действий
Сделать пустым С*n
Проверить принадлежность С
Добавить С*n
Удалить С
Минимальный элемент С
Проверка пустоты C
Решение. Храним минимальный, а для каждого - следующий и
предыдущий по величине.
Множества целых чисел.
В следующих задачах величина элементов множества не ограничена,
но их количество не превосходит n.
6.3.5. Память C*n.
Операции Число действий
Сделать пустым C
Число элементов C
Проверить принадлежность C*n
Добавить новый
(заведомо отсутствующий) C
Удалить C*n
Минимальный элемент C*n
Взять какой-то элемент C
Решение. Множество представляем с помощью переменных
a:array [1..n] of integer, k: 0..n; множество содержит k элементов
a[1],...,a[k]; все они различны. По существу мы храним элементы
множества в стеке (без повторений).
6.3.6. Память C*n.
Операции Число действий
Сделать пустым C
Проверить пустоту C
Проверить принадлежность C*(log n)
Добавить С*n
Удалить C*n
Минимальный элемент С
Решение. См. решение предыдущей задачи с дополнительным условием
a[1] " ... " a[k]. При проверке принадлежности используем
двоичный поиск.
В следующей задаче полезно комбинировать разные способы.
6.3.7. Используя описанное в предыдущей задаче представление
множеств, найти все вершины ориентированного графа, доступные
из данной по ребрам. (Вершины считаем числами 1..n.) Время
не больше C * (общее число ребер, выходящих из доступных вершин).
Решение. (Другое решение смотри в главе о рекурсии.) Пусть
num[i] - число ребер, выходящих из i, out[i][1], ...,
out[i][num[i]] - вершины, куда ведут ребра.
procedure Доступные (i: integer);
| {напечатать все вершины, доступные из i, включая i}
| var X: подмножество 1..n;
| P: подмножество 1..n;
| q, v, w: 1..n;
| k: integer;
begin
| ...сделать X, P пустыми;
| writeln (i);
| ...добавить i к X, P;
| {(1) P = множество напечатанных вершин; P содержит i;
| (2) напечатаны только доступные из i вершины;
| (3) X - подмножество P;
| (4) все напечатанные вершины, из которых выходит
| ребро в ненапечатанную вершину, принадлежат X}
| while X непусто do begin
| | ...взять какой-нибудь элемент X в v;
| | for k := 1 to num [v] do begin
| | | w := out [v][k];
| | | if w не принадлежит P then begin
| | | | writeln (w);
| | | | добавить w в P;
| | | | добавить w в X
| | | end;
| | end;
| end;
end;
Свойство (1) не нарушается, так как печать происходит одновременно
с добавлением в P. Свойства (2): раз v было в X, то v
доступно, поэтому w доступно. Свойство (3) очевидно. Свойство
(4): мы удалили из X элемент v, но все вершины, куда из v идут
ребра, перед этим напечатаны.
Оценка времени работы. Заметим, что изъятые из X элементы
больше туда не добавляются, так как они в момент изъятия (и,
следовательно, всегда позже) принадлежат P, а добавляются только
элементы не из P. Поэтому цикл while выполняется не более, чем
по разу, для всех доступных вершин, а цикл for выполняется
столько раз, сколько из вершины выходит ребер.
Для X надо использовать представление со стеком или очередью
(см. выше), для P - булевский массив.
6.3.8. Решить предыдущую задачу, если требуется, чтобы доступные
вершины печатались в таком порядке: сначала заданная вершина,
потом ее соседи, потом соседи соседей (еще не напечатанные)
и т.д.
Указание. Так получится, если использовать очередь в приведенном
выше решении: докажите индукцией по k, что существует момент,
в который напечатаны все вершины на расстоянии не больше
k, а в очереди находятся все вершины, удаленные ровно на k.
Более сложные способы представления множеств будут разобраны в
главах 11 (Хеширование) и 12 (Деревья).
6.4. Разные задачи.
6.4.1. Реализовать структуру данных, которая имеет все те
же операции, что массив длины n, а именно
начать работу
положить в i-ю ячейку число n
узнать, что лежит в i-ой ячейке
а также операцию "указать номер минимального элемента" (или одного
из минимальных элементов). Количество действий для всех
операций должно быть не более C*log n, не считая операции "начать
работу" (которая требует не более C*n действий).
Решение. Используется прием, изложенный в разделе о сортировке
деревом. Именно, надстроим над элементами массива как над
листьями двоичное дерево, в каждой вершине которого храним минимум
элементов соответствующего поддерева. Корректировка этой информации,
а также прослеживание пути из корня к минимальному
элементу требуют логарифмического числа действий.
6.4.2. Приоритетная очередь - это очередь, в которой важно
не то, кто встал последним (порядок помещения в нее не играет
роли), а кто главнее. Более точно, при помещении в очередь указывается
приоритет помещаемого объекта (будем считать приоритеты
целыми числами), а при взятии из очереди выбирается элемент с
наибольшим приоритетом (или один из таких элементов). Реализовать
приоритетную очередь так, чтобы помещение и взятие элемента
требовали логарифмического числа действий (от размера очереди).
Решение. Следуя алгоритму сортировки деревом (в его окончательном
варианте), будем размещать элементы очереди в массиве
x[1]..x[k], поддерживая такое свойство: x[i] старше (имеет
больший приоритет) своих сыновей x[2i] и x[2i+1], если таковые
существуют - и, следовательно, всякий элемент старше своих потомков.
(Сведения о приоритета также хранятся в массиве, так что
мы имеем дело с массивом пар (элемент, приоритет).) Удаление
элемента с сохранением этого свойства описано в алгоритме сортировки.
Надо еще уметь восстанавливать свойство после добавления
элемента в конец. Это делается так:
t:= номер добавленного элемента
{инвариант: в дереве любой предок приоритетнее потомка,
если этот потомок - не t}
while t - не корень и t старше своего отца do begin
| поменять t с его отцом
end;
Если очередь образуют граждане, стоящие в вершинах дерева, т.е.
за каждым стоит двое, а перед каждым (кроме первого) - один, то
смысл этого алгоритма ясен: встав в конец, приоритетный гражданин
начинает пробираться к началу, вытесняя впереди стоящих -
пока не встретит более приоритетного.
Замечание. Приоритетную очередь естественно использовать
при моделировании протекающих во времени процессов. При этом
элементы очереди - это ожидаемые события, а их приоритет определяется
временем, когда они произойдут.
7.1. Примеры рекурсивных программ.
При анализе рекурсивной программы возникает, как обычно, два
вопроса:
(а) почему программа заканчивает работу?
(б) почему она работает правильно, если заканчивает
работу?
Для (б) достаточно проверить, что (содержащая рекурсивный
вызов) программа работает правильно, предположив, что вызываемая
ею одноименная программа работает правильно. В самом деле, в
этом случае в цепочке рекурсивно вызываемых программ все программы
работают правильно (убеждаемся в этом, идя от конца цепочки
к началу).
Чтобы доказать (а), обычно проверяют, что с каждым рекурсивным
вызовом значение какого-то параметра уменьшается, и это
не может продолжаться бесконечно.
7.1.1. Написать рекурсивную процедуру вычисления факториала
целого положительного числа n (т.е. произведения чисел 1..n,
обозначаемого n!).
Решение. Используем равенства 1!=1, n!= (n-1)!*n.
procedure factorial (n: integer; var fact: integer);
| {положить fact равным факториалу числа y}
begin
| if n=1 then begin
| | fact:=1;
| end else begin {n"1}
| | factorial (n-1, fact);
| | fact:= fact*n;
| end;
end;
С использованием процедур-функций можно написать так:
function factorial (n: integer): integer;
begin
| if n=1 then begin
| | factorial:=1;
| end else begin {n"1}
| | factorial:= factorial (n-1)*n;
| end;
end;
Обратите внимание на некоторую двойственность использования имени
factorial внутри описания функции: оно обозначает как переменную,
так и вызываемую рекурсивно функцию. К счастью, в нашем
случае они различаются по скобкам после имени, но если бы
функция была без параметров, то дело было бы плохо. (Стандартная,
но трудно находимая ошибка возникает, если автор полагает,
что он использует значение переменной, а компилятор в этом
месте видит рекурсивный вызов.)
7.1.2. Обычно факториал определяют и для нуля, считая, что
0!=1. Измените программы соответственно.
7.1.3. Напишите рекурсивную программу возведения в целую неотрицательную
степень.
7.1.4. То же, если требуется, чтобы глубина рекурсии не превосходила
C*log n, где n - степень.
Решение.
function power (a,n: integer): integer;
begin
| if n = 0 then begin
| | power:= 1;
| end else if n mod 2 = 0 then begin
| | power:= power(a*2, n div 2);
| end else begin
| | power:= power(a, n-1)*a;
| end;
end;
7.1.5. Что будет, если изменить программу, приведенную в
решении предыдущей задачи, заменив строку
power:= power(a*2, n div 2)
на
power:= power(a, n div 2)* power(a, n div 2)?
Решение. Программа останется правильной. Однако она станет
работать медленнее. Дело в том, что теперь вызов может породить
два вызова (хотя и одинаковых) вместо одного - и число вызовов
быстро растет с глубиной рекурсии. Программа по-прежнему имеет
логарифмическую глубину рекурсии, но число шагов работы становится
линейным вместо логарифмического.
Этот недостаток можно устранить, написав
t:= power(a, n div 2);
power:= t*t;
или воспользовавшись функцией возведения в квадрат (sqr).
7.1.6. Используя лишь команды write(x) при x=0..9, написать
рекурсивную программу печати десятичной записи целого положительного
числа n.
Решение. Здесь использование рекурсии облегчает жизнь
(проблема была в том, что цифры легче получать с конца, а печатать
надо с начала).
procedure print (n:integer); {n"0}
begin
| if n"10 then begin
| | write (n);
| end else begin
| | print (n div 10);
| | write (n mod 10);
| end;
end;
7.1.7. Игра "Ханойские башни" состоит в следующем. Есть три
стержня. На первый из них надета пирамидка из n колец (большие
кольца снизу, меньшие сверху). Требуется переместить кольца на
другой стержень. Разрешается перекладывать кольца со стержня на
стержень, но класть большее кольцо поверх меньшего нельзя. Составить
программу, указывающую требуемые действия.
Решение. Напишем рекурсивную процедуру перемещения i
верхних колец с m-го стержня на n-ый (предполагается, что остальные
кольца больше по размеру и лежат на стержнях без движения).
procedure move(i,m,n: integer);
| var s: integer;
begin
| if i = 1 then begin
| | writeln ('сделать ход', m, '-"', n);
| end else begin
| | s:=6-m-n; {s - третий стержень: сумма номеров равна 6}
| | move (i-1, m, s);
| | writeln ('сделать ход', m, '-"', n);
| | move (i-1, s, n);
| end;
end;
(Сначала переносится пирамидка из i-1 колец на третью палочку.
После этого i-ое кольцо освобождается, и его можно перенести куда
следует. Остается положить на него пирамидку.)
7.2. Рекурсивная обработка деревьев
Двоичным деревом называется картинка вроде
o
\
o o
\ /
o o
\ /
o
Нижняя вершина называется корнем. Из каждой вершины могут идти
две линии: влево вверх и вправо вверх. Вершины, куда они ведут,
называются левым и правым сыновьями исходной вершины. Вершина
может иметь двух сыновей, а может иметь только одного сына (левого
или правого). Она может и вовсе не иметь сыновей, и в этом
случае называется листом.
Пусть x - какая-то вершина двоичного дерева. Она сама вместе
с сыновьями, внуками, правнуками и т.д. образует поддерево с
корнем в x - "поддерево потомков x".
В следующих задачах мы предполагаем, что вершины дерева
пронумерованы целыми положительными числами, причем номера всех
вершин различны. Мы считаем, что номер корня хранится в переменной
root. Мы считаем, что имеются два массива
l,r: array [1..N] of integer
и левый и правый сын вершины с номером i имеют соответственно
номера l[i] и r[i]. Если вершина с номером i не имеет левого
(или правого) сына, то l[i] (соответственно r[i]) равно 0. (По
традиции при записи программ мы используем вместо нуля константу
nil, равную нулю.)
Здесь N - достаточно большое натуральное число (номера всех
вершин не превосходят N). Отметим, что номер вершины никак не
связан с ее положением в дереве и что не все числа от 1 до N
обязаны быть номерами вершин (и, следовательно, часть данных в
массивах l и r - это мусор).
7.2.1. Пусть N=7, root=3, массивы l и r таковы:
i | 1 2 3 4 5 6 7
l[i] | 0 0 1 0 6 0 7
r[i] | 0 0 5 3 2 0 7
Нарисовать соответствующее дерево.
Ответ: 6 2
\ /
1 5
\ /
7.2.2. Написать программу подсчета числа вершин в дереве.
Решение. Рассмотрим функцию n(x), равную числу вершин в
поддереве с корнем в вершине номер x. Считаем, что n(nil)=0 (полагая
соответствующее поддерево пустым), и не заботимся о значениях
nil(s) для чисел s, не являющихся номерами вершин. Рекурсивная
программа для s такова:
function n (x:integer):integer;
begin
| if x = nil then begin
| | n:= 0;
| end else begin
| | n:= n(l[x]) + n(r[x]) + 1;
| end;
end;
(Число вершин в поддереве над вершиной x равно сумме чисел вершин
над ее сыновьями плюс она сама.) Глубина рекурсии конечна,
так как с каждым шагом высота соответствующего поддерева
уменьшается.
7.2.3. Написать программу подсчета числа листьев в дереве.
Ответ.
function n (x:integer):integer;
begin
| if x = nil then begin
| | n:= 0;
| end else if (l[x]=nil) and (r[x]=nil) then begin {лист}
| | n:= 1;
| end;
| end else begin
| | n:= n(l[x]) + n(r[x]);
| end;
end;
7.2.4. Написать программу подсчета высоты дерева (корень
имеет высоту 0, его сыновья - высоту 1, внуки - 2 и т.п.; высота
дерева - это максимум высот его вершин).
Указание. Рекурсивно определяется функция f(x) = высота
поддерева с корнем в x.
7.2.5. Написать программу, которая по заданному n считает
число всех вершин высоты n (в заданном дереве).
Вместо подсчета количества вершин того или иного рода можно
просить напечатать список этих вершин (в том или ином порядке).
7.2.6. Написать программу, которая печатает (по одному разу)
все вершины дерева.
Решение. Процедура print_subtree(x) печатает все вершины
поддерева с корнем в x по одному разу; главная программа содержит
вызов print_subtree(root).
procedure print_subtree (x:integer);
begin
| if x = nil then begin
| | {ничего не делать}
| end else begin
| | writeln (x);
| | print_subtree (l[x]);
| | print_subtree (r[x]);
| end;
end;
Данная программа печатает сначала корень поддерева, затем поддерево
над левым сыном, а затем над правым. Три строки в else-части
могут быть переставлены 6 способами, и каждый из этих способов
дает свой порядок печати вершин.
7.3. Порождение комбинаторных объектов, перебор
Рекурсивные программы являются удобным способом порождения
комбинаторных объектов заданного вида. Мы решим заново несколько
задач соотвтетсвующей главы.
7.3.1. Написать программу, которая печатает по одному разу
все последовательности длины n, составленные из чисел 1..k (их
количество равно k в степени n).
Решение. Программа будет оперировать с массивом a[1]..a[n]
и числом t. Рекурсивная процедура generate печатает все последовательности,
начинающиеся на a[1]..a[t]; после ее окончания t
имеет то же значение, что и в начале:
procedure generate;
| var i,j : integer;
begin
| if t = n then begin
| | for i:=1 to n do begin
| | | write(a[i]);
| | end;
| | writeln;
| end else begin {t " n}
| | for j:=1 to k do begin
| | | t:=t+1;
| | | a[t]:=j;
| | | generate;
| | | t:=t-1;
| | end;
| end;
end;
Основная программа теперь состоит из двух операторов:
t:=0; generate;
7.3.2. Написать программу, которая печатала бы все перестановки
чисел 1..n по одному разу.
Решение. Программа оперирует с массивом a[1]..a[n], в котором
хранится перестановка чисел 1..n. Рекурсивная процедура
generate в такой ситуации печатает все перестановки, которые на
первых t позициях совпадают с перестановкой a; по выходе из нее
переменные t и a имеют те же значения, что и до входа. Основная
программа такова:
for i:=1 to n do begin a[i]:=i; end;
t:=0;
generate;
вот описание процедуры:
procedure generate;
| var i,j : integer;
begin
| if t = n then begin
| | for i:=1 to n do begin
| | | write(a[i]);
| | end;
| | writeln;
| end else begin {t " n}
| | for j:=t+1 to n do begin
| | | поменять местами a[t+1] и a[j]
| | | t:=t+1;
| | | generate;
| | | t:=t-1;
| | | поменять местами a[t+1] и a[j]
| | end;
| end;
end;
7.3.3. Напечатать все возрастающие последовательности длины
k, элементами которых являются натуральные числа от 1 до n.
(Предполагается, что k не превосходит n - иначе таких последовательностей
не существует.)
Решение. Программа оперирует с массивом a[1]..a[k] и целой
переменной t. Предполагая, что a[1]..a[t] - возрастающая последовательность
чисел натуральных чисел из отрезка 1..n, рекурсивно
определенная процедура generate печатает все ее возрастающие
продолжения длины k.
procedure generate;
| var i: integer;
begin
| if t = k then begin
| | печатать a[1]..a[k]
| end else begin
| | t:=t+1;
| | for i:=a[t-1]+1 to t-k+n do begin
| | | a[t]:=i;
| | | generate;
| | end;
| | t:=t-1;
| end;
end;
Замечание. Цикл for мог бы иметь верхней границей n (вместо
t-k+n). Наш вариант экономит часть работы, учитывая тот факт,
что предпоследний (k-1-ый) член не может превосходить n-1,
k-2-ой член не может превосходить n-2 и т.п.
Основная программа теперь выглядит так:
t:=1;
for j:=1 to 1-k+n do begin
| a[1]:=j;
| generate;
end;
Можно было бы добавить к массиву a слева еще и a[0]=0, положить
t=0 и ограничиться единственным вызовом процедуры generate.
7.3.4. Перечислить все представления положительного целого
числа n в виде суммы последовательности невозрастающих целых положительных
слагаемых.
Решение. Программа оперирует с массивом a[1..n] (максимальное
число слагаемых равно n) и с целой переменной t. Предполагая,
что a[1],...,a[t] - невозрастающая последовательность целых
чисел, сумма которых не превосходит n, процедура generate
печатает все представления требуемого вида, продолжающие эту
последовательность. Для экономии вычислений сумма a[1]+...+a[t]
хранится в специальной переменной s.
procedure generate;
| var i: integer;
begin
| if s = n then begin
| | печатать последовательность a[1]..a[t]
| end else begin
| | for i:=1 to min(a[t], n-s) do begin
| | | t:=t+1;
| | | a[t]:=i;
| | | s:=s+i;
| | | generate;
| | | s:=s-i;
| | | t:=t-1;
| | end;
| end;
end;
Основная программа при этом может быть такой:
t:=1;
for j:=1 to n do begin
| a[1]:=j
| s:=j;
| generate;
end;
Замечание. Можно немного сэконмить, вынеся операции увеличения
и уменьшения t из цикла, а также не возвращая s каждый раз
к исходному значению (а увеличивая его на 1 и возвращая к исходному
значению в конце). Кроме того, добавив фиктивный элемент
a[0]=n, можно упростить основную программу:
t:=0; s:=0; a[0]:=n; generate;
7.3.5. Написать рекурсивную программу обхода дерева (используя
те же команды и проверки, что и в главе про обход дерева).
Решение. Процедура обработать_над обрабатывает все листья
над текущей вершиной и заканчивает работу в той же вершине, что
и начала. Вот ее рекурсивное описание:
procedure обработать_над;
begin
| if есть_сверху then begin
| | вверх_налево;
| | обработать_над;
| | while есть_справа do begin
| | | вправо;
| | | обработать_над;
| | end;
| | вниз;
| end else begin
| | обработать;
| end;
end;
7.4. Другие применения рекурсии
Топологическая сортировка. Представим себе n чиновников,
каждый из которых выдает справки определенного вида. Мы хотим
получить все эти справки, соблюдая ограничения, установленные
чиновниками. Ограничения состоят в том, что у каждого чиновника
есть список справок, которые нужно собрать перед обращением к
нему. Дело безнадежно, если схема зависимостей имеет цикл
(справку A нельзя получить без B, B без C,..., Y без Z и Z без
A). Предполагая, что такого цикла нет, требуется составить план,
указывающий один из возможных порядков получения справок.
Изображая чиновников точками, а зависимости - стрелками,
приходим к такой формулировке. Имеется n точек, пронумерованных
от 1 до n. Из каждой точки ведет несколько (возможно, 0) стрелок
в другие точки. (Такая картинка называется ориентированным графом.)
Циклов нет. Требуется расположить вершины графа (точки) в
таком порядке, чтобы конец любой стрелки предшествовал ее началу.
Эта задача называется топологической сортировкой.
7.4.1. Доказать, что это всегда возможно.
Решение. Из условия отсутствия циклов вытекает, что есть
вершина, из которой вообще не выходит стрелок (иначе можно двигаться
по стрелкам, пока не зациклимся). Ее будем считать первой.
Выкидывая все стрелки, в нее ведущие, мы сводим задачу к
графу с меньшим числом вершин и продолжаем рассуждение по индукции.
7.4.2. Предположим, что ориентированный граф без циклов
хранится в такой форме: для каждого i от 1 до n в num[i] хранится
число выходящих из i стрелок, в adr[i][1],..., adr[i][num[i]]
- номера вершин, куда эти стрелки ведут. Составить (рекурсивный)
алгоритм, который производит топологическую сортировку не более
чем за C*(n+m) действий, где m - число ребер графа (стрелок).
Замечание. Непосредственная реализация приведенного выше
доказательства существования не дает требуемой оценки; ее приходится
немного подправить.
Решение. Наша программа будет печатать номера вершин. В
массиве printed: array[1..n] of boolean мы будем хранить сведения
о том, какие вершины напечатаны (и корректировать их одновременно
с печатью вершины). Будем говорить, что напечатанная
последовательность вершин корректна, если никакая вершина не напечатана
дважды и для любого номера i, входящего в эту последостельность,
все вершины, в которые ведут стрелки из i, напечатаны,
и притом до i.
procedure add (i: 1..n);
| {дано: напечатанное корректно;}
| {надо: напечатанное корректно и включает вершину i}
begin
| if printed [i] then begin {вершина i уже напечатана}
| | {ничего делать не надо}
| end else begin
| | {напечатанное корректно}
| | for j:=1 to num[i] do begin
| | | add(adr[i][j]);
| | end;
| | {напечатанное корректно, все вершины, в которые из
| | i ведут стрелки, уже напечатаны - так что можно
| | печатать i, не нарушая корректности}
| | if not printed[i] then begin
| | | writeln(i); printed [i]:= TRUE;
| | end;
| end;
end;
Основная программа:
for i:=1 to n do begin
| printed[i]:= FALSE;
end;
for i:=1 to n do begin
| add(i)
end;
7.4.3. В приведенной программе можно выбросить проверку,
заменив
if not printed[i] then begin
| writeln(i); printed [i]:= TRUE;
end;
на
writeln(i); printed [i]:= TRUE;
Почему? Как изменится спецификация процедуры?
Решение. Спецификацию можно выбрать такой:
дано: напеватанное корректно
надо: напечатанное корректно и включает вершину i;
все вновь напечатанные вершины доступны из i.
7.4.4. Где использован тот факт, что граф не имеет циклов?
Решение. Мы опустили доказательство конечности глубины
...Закладка в соц.сетях
