следовательно, всегда позже) принадлежат 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. Рекурсия
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
\ /
3
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]);
