Для универсальных языков программирования (каковым является
паскаль) рекурсия не дает ничего нового: для всякой рекурсивной
программы можно написать эквивалентную программу без рекурсии.
Мы не будем доказывать этого, а продемонстрируем некоторые при-
емы, позволяющие избавиться от рекурсии в конкретных ситуациях.
Зачем это нужно? Ответ прагматика мог бы быть таким: во
многих компьютерах (в том числе, к сожалению, и в современных,
использующих так называемые RISC-процессоры), рекурсивные прог-
раммы в несколько раз медленнее соответствующих нерекурсивных
программ. Еще один возможный ответ: в некоторых языках програм-
мирования рекурсивные программы запрещены. А главное, при удале-
нии рекурсии возникают изящные и поучительные конструкции.
8.1.1. Следующая рекурсивная процедура вычисляет числа со-
четаний (биномиальные коэффициенты). Написать эквивалентную не-
рекурсивную программу.
function C(n,k: integer):integer;
| {n,k >=0; k <=n}
begin
| if (k = 0) or (k = n) then begin
| | C:=1;
| end else begin {0<k<n}
| | C:= C(n-1,k-1)+C(n-1,k)
| end;
end;
Замечание. C(n,k) - число k-элементных подмножеств n-элементного
множества. Соотношение C(n,k) = C(n-1,k-1)+C(n-1,k) получится,
если мы фиксируем некоторый элемент n-элементного множества и
отдельно подсчитаем k-элементные множества, включающие и не
включающие этот элемент. Таблица значений C(n,k)
1
1 1
1 2 1
1 3 3 1
.................
называется треугольником Паскаля (того самого). В нем каждый
элемент, кроме крайних единиц, равен сумме двух стоящих над ним.
Решение. Можно воспользоваться формулой
C(n,k) = n! / (k! * (n-k)!)
Мы, однако, не будем этого делать, так как хотим продемонстриро-
вать более общие приемы устранения рекурсии. Составим таблицу
значений функции C(n,k), заполняя ее для n = 0, 1, 2,..., пока
не дойдем до интересующего нас элемента.
8.1.2. Что можно сказать о времени работы рекурсивной и не-
рекурсивной версий в предыдущей задаче? Тот же вопрос о памяти.
Решение. Таблица занимает место порядка n*n, его можно сок-
ратить до n, если заметить, что для вычисления следующей строки
треугольника Паскаля нужна только предыдущая. Время работы в
обоих случаях порядка n*n. Рекурсивная программа требует су-
щественно большего времени: вызов C(n,k) сводится к двум вызовам
для C(n-1,..), те - к четырем вызовам для C(n-2,..) и т.д. Таким
образом, время оказывается экспоненциальным (порядка 2 в степени
n). Используемая рекурсивной версией память пропорциональна n -
умножаем глубину рекурсии (n) на количество памяти, используемое
одним экземпляром процедуры (константа).
Кардинальный выигрыш во времени при переходе от рекурсивной вер-
сии к нерекурсивной связан с тем, что в рекурсивном варианте од-
ни и те же вычисления происходят много раз. Например, вызов
C(5,3) в конечном счете порождает два вызова C(3,2):
C(5,3)
/ \
C(4,2) C(4,3)
/ \ / \
C(3,1) C(3,2) C(3,3)
......................
Заполняя таблицу, мы каждую клетку заполняем только однажды -
отсюда и экономия. Этот прием называется динамическим программи-
рованием, и применим в тех случаях, когда объем хранимой в таб-
лице информации оказывается не слишком большим.
8.1.2. Порассуждать на ту же тему на примере рекурсивной и
(простейшей) нерекурсивной программ для вычисления чисел Фибо-
наччи, заданных соотношением
f(1) = f (2) = 1; f(n) = f(n-1) + f(n-2) для n > 2.
8.1.3. Дан выпуклый n-угольник (заданный координатами своих
вершин в порядке обхода). Его разрезают на треугольники диагона-
лями, для чего необходимо n-2 диагонали (докажите индукцией по
n). Стоимостью разрезания назовем сумму длин всех использованных
диагоналей. Найти минимальную стоимость разрезания. Число
действий должно быть ограничено некоторым многочленом от n. (Пе-
ребор не подходит, так как число вариантов не ограничено многоч-
леном.)
Решение. Будем считать, что вершины пронумерованы от 1 до n
и идут по часовой стрелке. Пусть k, l - номера вершин, причем
l>k. Через A(k,l) обозначим многоугольник, отрезаемый от нашего
хордой k--l. (Эта хорда разрезает многоугольник на 2, один из
которых включает сторону 1--n; через A(k,l) мы обозначаем дру-
гой.) Исходный многоугольник естественно обозначить A(1,n). При
l=k+1 получается "двуугольник" с совпадающими сторонами.
Через a(k,l) обозначим стоимость разрезания многоугольника
A(k,l) диагоналями на треугольники. Напишем рекуррентную формулу
для a(k,l). При l=k+1 получается двуугольник, и мы полагаем
a(k,l)=0. При l=k+2 получается треугольник, и в этом случае так-
же a(k,l)=0. Пусть l > k+2. Хорда k--l является стороной много-
угольника A(k,l) и, следовательно, стороной одного из тре-
угольников, на которые он разрезан. Противоположной вершиной i
этого треугольника может быть любая из вершин k+1,...,l-1, и ми-
нимальная стоимость разрезания может быть вычислена как
min {(длина хорды k--i)+(длина хорды i--l)+a(k,i)+a(i,l)}
по всем i=k+1,..., i=l-1. При этом надо учесть, что при i=k+1
хорда k--i - не хорда, а сторона, и ее длину надо считать равной
0 (по стороне разрез не проводится).
Составив таблицу для a(k,l) и заполняя ее в порядке возрас-
тания числа вершин (равного l-k+2), мы получаем программу, ис-
пользующую память порядка n*n и время порядка n*n*n (однократное
применение рекуррентной формулы требует выбора минимума из не
более чем n чисел).
8.1.4. Матрицей размера m*n называется прямоугольная табли-
ца из m строк и n столбцов, заполненная числами. Матрицу размера
m*n можно умножить на матрицу размера n*k (ширина левого сомно-
жителя должна равняться высоте правого), и получается матрица
размером m*k. Ценой такого умножения будем считать произведение
m*n*k (таково число умножений, которые нужно выполнить при стан-
дартном способе умножения - но сейчас это нам не важно). Умноже-
ние матриц ассоциативно, поэтому произведение n матриц можно вы-
числять в разном порядке. Для каждого порядка подсчитаем суммар-
ную цену всех матричных умножений. Найти минимальную цену вычис-
ления произведения, если известны размеры всех матриц. Число
действий должно быть ограничено многочленом от числа матриц.
Пример. Матрицы размером 2*3, 3*4, 4*5 можно перемножать
двумя способами. В первом цена равна 2*3*4 + 2*4*5 = 24 + 40 =
64, во втором цена равна 3*4*5 + 2*3*5 = 90.
Решение. Представим себе, что первая матрица написана на
отрезке [0,1], вторая - на отрезке [1,2],..., s-ая - на отрезке
[s-1,s]. Матрицы на отрезках [i-1,i] и [i,i+1] имеют общий раз-
мер, позволяющих их перемножить. Обозначим его через d[i]. Таким
образом, исходным данным в задаче является массив d[0]..d[s].
Через a(i,j) обозначим минимальную цену вычисления произве-
дения матриц на участке [i,j] (при 0<=i<j<=s). Искомая величина
равна a(0,s). Величины a(i,i+1) равны нулю (матрица одна и пе-
ремножать ничего не надо). Рекуррентная формула будет такой:
a(i,j) = min {a(i,k)+ a(k,j) + d[i]*d[k]*d[j]}
где минимум берется по всем возможных местам последнего умноже-
ния, то есть по всем k=i+1..j-1. В самом деле, произведение мат-
риц на отрезке [i,k] есть матрица размера d[i]*d[k], произведе-
ние матриц на отрезке [k,j] имеет размер d[k]*d[j], и цена вы-
числения их произведения равна d[i]*d[k]*d[j].
Замечание. Две последние задачи похожи. Это сходство станет
яснее, если написать матрицы - множители на сторонах 1--2,
2--3,..., s-1--s многоугольника, а на каждой хорде i--j написать
произведение всех матриц, стягиваемых этой хордой.
8.1.5. Железная дорога с односторонним движением имеет n
станций. Известны цены белетов от i-ой станции до j-ой (при i <
j - в обратную сторонону проезда нет). Найти минимальную сто-
имость проезда от начала до конца (с учетом возможной экономии
за счет пересадок).
Мы видели, что замена рекурсивной программы на заполнение
таблицы значений иногда позволяет уменьшить число действий. При-
мерно того же эффекта можно добиться иначе: оставить программу
рекурсивной, но в ходе вычислений запоминать уже вычисленные
значения, а перед очередным вычислением проверять, нет ли уже
готового значения.
8.1.6. Задано конечное множество с бинарной операцией (во-
обще говоря, не коммутативной и даже не ассоциативной). Имеется
n элементов a[1]..a[n] этого множества и еще один элемент x.
Проверить, можно ли так расставить скобки в произведении
a[1]..a[n], чтобы в результате получился x. Число операций
должно не превосходить C*n*n*n для некоторой константы C (зави-
сищей от числа элементов в выбранном конечном множестве).
Решение. Заполняем таблицу, в которой для каждого участка
a[i]..a[j] нашего произведения хранится список всех возможных
его значений (при разной расстановке скобок).
По существу этот же прием применяется в полиномиальном ал-
горитме проверки принадлежности слова произвольному кон-
текстно-свободному языку (см. главу 13).
Следующая задача (задача о рюкзаке) уже упоминалась в главе
3 (Обход дерева).
8.1.7. Имеется n положительных целых чисел x[1]..x[n] и
число N. Выяснить, можно ли получить N, складывая некоторые из
чисел x[1]..x[n]. Число действий должно быть порядка N*n.
Указание. После i шагов хранится множество тех чисел на от-
реке 0..N, которые предствимы в виде суммы некоторых из
x[1]..x[i].
Другой прием устранения рекурсии продемонстрируем на приме-
ре задачи о ханойских башнях.
8.2.1. Написать нерекурсивную программу для нахождения пос-
ледовательности перемещений дисков в задаче о ханойских башнях.
Решение. Вспомним рекурсивную программу:
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-
| | writeln ('сделать ход', m, '->', n);
| | move (i-1, s, n);
| end;
end;
Видно, что задача "переложить i верхних дисков с m-го стержня на
n-ый" сводится к трем задачам того же типа: двум задачам с i-1
дисками и к одной задаче с единственным диском. Выполняя эти за-
дачи, важно не позабыть, что еще осталось сделать.
Для этой цели заведем стек отложенных заданий, элементами
которого будут тройки <i,m,n>. Каждая такая тройка интерпретиру-
ется как заказ "переложить i верхних дисков с m-го стержня на
n-ый". Заказы упорядочены в соответствии с требуемым порядком их
выполнения: самый срочный - вершина стека. Получам такую прог-
рамму:
procedure move(i,m,n: integer);
begin
| сделать стек заказов пустым
| положить в стек тройку <i,m,n>
| {инвариант: осталось выполнить заказы в стеке}
| while стек непуст do begin
| | удалить верхний элемент, переложив его в <j,p,q>
| | if j = 1 then begin
| | | writeln ('сделать ход', p, '->', q);
| | end else begin
| | | s:=6-p-q;
| | | {s - третий стержень: сумма номеров равна 6}
| | | положить в стек тройки <j-1,s,q>, <1,p,q>, <j-1,p,s>
| | end;
| end;
end;
(Заметим, что сначала в стек кладется тройка, которую надо вы-
полнять последней.) Стек троек может быть реализован как стри
отдельных стека. (Кроме того, в паскале есть специальный тип,
называемый "запись", который может быть применен.)
8.2.2. (Сообщил А.К.Звонкин со ссылкой на Анджея Лисовско-
го.) Для задачи о ханойских башнях есть и другие нерекусивные
алгоритмы. Вот один из них: простаивающим стержнем (не тем, с
которого переносят, и не тем, на который переносят) должны быть
все стержни по очереди. Другое правило: поочередно перемещать
наименьшее кольцо и не наименьшее кольцо, причем наименьшее - по
кругу.
8.2.3. Использовать замену рекурсии стеком отложенных зада-
ний в рекурсивной программе печати десятичной записи целого чис-
ла.
Решение. Цифры добываются с конца и закладываются в стек, а
затем печатаются в обратном порядке.
8.2.4. Написать нерекурсивную программу, печатающую все
вершины двоичного дерева.
Решение. В этом случае стек отложенных заданий будет содер-
жать заказы двух сортов: заказ напечатать (в свое время) данную
вершину и заказ напечатать все вершины поддерева с данным корнем
(при этом nil считается корнем пустого дерева). Таким образом,
элемент стека есть пара: <тип заказа, номер вершины>.
Вынимая элемент из стека, мы либо сразу исполняем его (если
это заказ первого типа) либо помещаем в стек три порожденных им
заказа - в одном из шести возможных порядков.
8.2.5. Что изменится, если требуется не печатать вершины
двоичного дерева, а подсчитать их количество?
Решение. Печатание вершины следует заменить прибавлением
единицы к счетчику. Другими словами, инвариант таков: (общее
число вершин) = (счетчик) + (сумма чисел вершин в поддеревьях,
корни которых лежат в стеке).
8.2.6. Для некоторых из шести возможных порядков возможны
упрощения, делающие ненужным хранение в стеке элементов двух ви-
дов. Указать некоторые из них.
Решение. Если требуемый порядок таков:
корень, левое поддерево, правое поддерево,
то заказ на печатание корня можно не закладывать в стек, а вы-
полнять сразу.
Несколько более сложная конструкция применима для порядка
левое поддерево, корень, правое поддерево.
В этом случае все заказы в стеке, кроме самого первого (напеча-
тать поддерево) делятся на пары:
напечатать вершину x, напечатать правое поддерево x
(т.е. поддерево с корнем в правом сыне x). Объединив эти пары в
заказы специального вида и введя переменную для отдельного хра-
нения первого заказа, мы обойдемся стеком однотипных заказов.
То же самое, разумеется, верно, если поменять местами левое
и правое - получается еще два порядка.
Замечание. Другую программу печати всех вершин дерева можно
построить на основе программы обхода дерева, разобранной в соот-
ветствующей главе. Там используется команда "вниз". Поскольку
теперешнее представление дерева с помощью массивов l и r не поз-
воляет найти предка заданной вершины, придется хранить список
всех вершин на пути от корня к текущей вершине. Cмотри также
главу об алгоритмах на графах.
8.2.7. Написать нерекурсивный вариант программы быстрой
сортировки. Как обойтись стеком, глубина которого ограничена
C*log n, где n - число сортируемых элементов?
Решение. В стек кладутся пары <i,j>, интерпретируемые как
отложенные задания на сортировку соответствующих участков масси-
ва. Все эти заказы не пересекаются, поэтому размер стека не мо-
жет превысить n. Чтобы ограничиться стеком логарифмической глу-
бины, будем придерживаться такого правила: глубже в стек поме-
щать больший из возникающих двух заказов. Пусть f(n) - макси-
мальная глубина стека, которая может встретиться при сортировке
массива из не более чем n элементов таким способом. Оценим f(n)
сверху таким способом: после разбиения массива на два участка мы
сначала сортируем более короткий (храня в стеке про запас) более
длинный, при этом глубина стека не больше f(n/2)+1, затем сорти-
руем более длинный, так что
f(n) <= max (f(n/2)+
откуда очевидной индукцией получаем f(n) = O(log n).
Пусть функция f с натуральными аргументами и значениями оп-
ределена рекурсивно условиями
f(0) = a,
f(x) = h(x, f(l(x))),
где a - некоторое число, а h и l - известные функции. Другими
словами, значение функции f в точке x выражается через значение
f в точке l(x). При этом предполагается, что для любого x в пос-
ледовательности
x, l(x), l(l(x)),...
рано или поздно встретится 0.
Если дополнительно известно, что l(x) < x для всех x, то
вычисление f не представляет труда: вычисляем последовательно
f(0), f(1), f(2),...
8.3.1. Написать нерекурсивную программу вычисления f для
общего случая.
Решение. Для вычисления f(x) вычисляем последовательность
l(x), l(l(x)), l(l(l(x))),...
до появления нуля и запоминаем ее, а затем вычисляем значения f
в точках этой последовательности, идя справа налево.
Еще более сложный случай из следующей задачи вряд ли встре-
тится на практике (а если и встретися, то проще рекурсию не
устранять, а оставить). Но тем не менее: пусть функция f с нату-
ральными аргументами и значениями определяется соотношениями
f(0) = a,
f(x) = h(x, f(l(x)), f(r(x))),
где a - некоторое число, а l, r и h - известные функции. Предпо-
лагается, что если взять произвольное число и начать применять к
нему функции l и r в произвольном порядке, то рано или поздно
получится 0.
8.3.2. Написать нерекурсивную программу вычисления f.
Решение. Можно было бы сначала построить дерево, у которого
в корне находится x, а в сыновьях вершины i стоят l(i) и r(i) -
если только i не равно нулю, а затем вычислять значения функции,
идя от листьев к корню. Однако есть и другой способ.
"Обратной польской записью" (или "постфиксной записью") вы-
ражения называют запись, где знак функции стоит после всех ее
аргументов, а скобки не используются. Вот несколько примеров:
f(2)
f(g(2))
s(2,t(7)) 2 7 t s
s(2, u(2, s(5,3)) 2 2 5 3 s u s
Постфиксная запись выражения позволяет удобно вычислять его с
помощью "стекового калькулятора". Этот калькулятор имеет стек,
который мы будем представлять себе расположенным горизонтально
(числа вынимаются и кладутся справа). При нажатии на клавишу с
числом это число кладется в стек. При нажатии на функциональную
клавишу соответствующая функция применяется к нескольким аргу-
ментам у вершины стека. Например, если в стеке были числа
2 3 4 5 6
и нажата функциональная клавиша s, соотвтетствующая функции от
двух аргументов, то в стеке окажутся числа
2 3 4 s(5,6)
Перейдем теперь к нашей задаче. В процессе вычисления значения
функции f мы будем работать со стеком чисел, а также с последо-
вательностью чисел и символов "f", "l", "r", "h", которую мы бу-
дем интерпретировать как последовательность нажатий кнопок на
стековом калькуляторе. Инвариант такой:
если стек чисел представляет собой текущее состояние
стекового калькулятора, то после нажатия всех клавиш
последовательности в стеке останется единственное
число, и оно будет искомым ответом.
Пусть нам требуется вычислить значение, к примеру, f(100). Тогда
вначале мы помещаем в стек число 100, а последовательность со-
держит единственный символ "f". (При этом инвариант соблюдает-
ся.) Далее с последовательностью и стеком выполняются такие пре-
образования:
старый старая новый новая
стек последовательность стек последовательность
X x P X x P
X x l P X l(x) P
X x r P X r(x) P
X x y z h P X h(x,y,z) P
X 0 f P X a P
X x f P X x x l f x r f h P
Обозначения: x, y, z,.. - числа, X - последовательность чисел, P
- последовательность чисел и символов "f", "l", "r", "h". В пос-
ледней строке предполагается, что m не равно 0. Эта строка соот-
ветствует равенству
f(x) = h(x, f(l(x)), f(r(x))),
Эти преобразования выполняются, пока последовательность не ста-
нет пуста. В этот момент в стеке окажется единственное число,
которое и будет ответом.
Замечание. Последовательность по существу представляет со-
бой стек отложенных заданий (вершина которого находится слева).