Практикум по методам построения алгоритмов

Рекурсия

Разбить на страницы
Показывать лекцию целиком

7.1. Примеры рекурсивных программ

При анализе рекурсивной программы возникает, как обычно, два вопроса:

  • почему программа заканчивает работу?
  • почему она работает правильно, если заканчивает работу?
    •

    Для (2) достаточно проверить, что (содержащая рекурсивный вызов) программа работает правильно, предположив, что вызываемая ею одноименная программа работает правильно. В самом деле, в этом случае в цепочке рекурсивно вызываемых программ все программы работают правильно (убеждаемся в этом, идя от конца цепочки к началу).

    Чтобы доказать (1), обычно проверяют, что с каждым рекурсивным вызовом значение какого-то параметра уменьшается, и это не может продолжаться бесконечно.

    7.1.1. Написать рекурсивную процедуру вычисления факториала целого положительного числа $$n$$ (т. е. произведения $$1\cdot2\cdots n$$, обозначаемого $$n$$!).

    Решение. Используем равенства $$1!=1$$, $$n!= (n-1)!\cdot n$$.

    procedure factorial (n: integer; var fact: integer);
| {положить fact равным факториалу числа n}
begin
| if n=1 then begin
| | fact:=1;
| end else begin {n>1}
| | factorial (n-1, fact);
| | {fact = (n-1)!}
| | 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;

    Обратите внимание на некоторую двойственность использования имени $$\w{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*a, n div 2);
| end else begin
| | power:= power(a, n-1)*a;
| end;
end;

    7.1.5. Что будет, если изменить программу, приведенную в решении предыдущей задачи, заменив строку

    power:= power(a*a, n div 2)

    на

    power:= power(a, n div 2)* power(a, n div 2)?

    Решение. Программа останется правильной. Однако она станет работать медленнее. Дело в том, что теперь вызов может породить два вызова (хотя и одинаковых) вместо одного - и число вызовов быстро растет с глубиной рекурсии. Программа по-прежнему имеет логарифмическую глубину рекурсии, но число шагов работы становится линейным вместо логарифмического.

    Этот недостаток можно устранить, написав

    t:= power(a, n div 2);
power:= t*t;

    или воспользовавшись функцией возведения в квадрат $$(\w{sqr})$$.

    7.1.6. Используя команды $$\w{write(x)}$$ лишь при $${x}=0\ldots9$$, написать рекурсивную программу печати десятичной записи целого положительного числа $$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$$ колец (большие кольца снизу, меньшие сверху). Требуется переместить кольца на другой стержень. Разрешается перекладывать кольца со стержня на стержень, но класть большее кольцо поверх меньшего нельзя. Составить программу, указывающую требуемые действия.

    Решение. Напишем рекурсивную процедуру перемещения $$\w{i}$$ верхних колец с $$\w{m}$$ -го стержня на $$\w{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}$$ колец на третью палочку. После этого $$\hbox{{i}-ое}$$ кольцо освобождается, и его можно перенести куда следует. Остается положить на него пирамидку.)

    7.1.8. Написать рекурсивную программу суммирования массива $$\text{a: array [1..n] of integer}$$.

    Указание. Рекурсивно определяемая функция должна иметь дополнительный параметр - число складываемых элементов.

    7.2. Рекурсивная обработка деревьев

    Двоичным деревом называется картинка вроде такой:

    Нижняя вершина называется корнем. Из каждой вершины могут идти две линии: влево вверх и вправо вверх. Вершины, куда они ведут, называются левым и правым сыновьями } исходной вершины. Вершина может иметь двух сыновей, а может иметь только одного сына (левого или правого). Она может и вовсе не иметь сыновей, и в этом случае называется листом.

    Пусть $$x$$ - какая-то вершина двоичного дерева. Она сама вместе с сыновьями, внуками, правнуками и т.д. образует поддерево с корнем в $$x$$ - поддерево потомков x.

    В следующих задачах мы предполагаем, что вершины дерева пронумерованы целыми положительными числами, причем номера всех вершин различны. Мы считаем, что номер корня хранится в переменной $$\w{root}$$. Мы считаем, что имеются два массива

    l,r: array [1..N] of integer

    и левый и правый сын вершины с номером $$\w{i}$$ имеют соответственно номера $$\w{l[i]}$$ и $$\w{r[i]}$$. Если вершина с номером $$\w{i}$$ не имеет левого (или правого) сына, то $$\w{l[i]}$$ (соответственно $$\w{r[i]})$$ равно $$\w{0}$$. (По традиции при записи программ мы используем вместо нуля константу $$\w{nil}$$, равную нулю.)

    Здесь $$\w{N}$$ - достаточно большое натуральное число (номера всех вершин не превосходят $$\w{N})$$. Отметим, что номер вершины никак не связан с ее положением в дереве и что не все числа от $$\w{1}$$ до $$\w{N}$$ обязаны быть номерами вершин (и, следовательно, часть данных в массивах $$\w{l}$$ и $$\w{r}$$ - это мусор).

    7.2.1. Пусть $${N}=7$$, $${root}=3$$, массивы $$\w{l} $$ и $$\w{r}$$ таковы:$$\begin{tabular}{r|ccccccc} \w{i} 1 2 3 4 5 6 7\\ \w{l[i]} 0 0 1 0 6 0 7\\ \w{r[i]} 0 0 5 3 2 0 7 \end{tabular}$$ Нарисовать соответствующее дерево.

    Ответ.

    7.2.2. Написать программу подсчета числа вершин в дереве.

    Решение. Рассмотрим функцию $$\w{n(x)}$$, равную числу вершин в поддереве с корнем в вершине номер $$\w{x}$$. Считаем, что $${n(nil)}={0}$$ (полагая соответствующее поддерево пустым), и не заботимся о значениях $$\w{nil(s)}$$ для чисел $$\w{s}$$, не являющихся номерами вершин. Рекурсивная программа для $$\w{n}$$ такова:

    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;

    (Число вершин в поддереве над вершиной $$\w{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 else begin
| | n:= n(l[x]) + n(r[x]);
| end;
end;

    7.2.4. Написать программу подсчета высоты дерева (корень имеет высоту $$0$$, его сыновья - высоту $$1$$, внуки - $$2$$ и т.п.; высота дерева - это максимум высот его вершин).

    Указание. Рекурсивно определяется функция $${f(x)} = {}$$ высота поддерева с корнем в $$\w{x}$$.

    7.2.5. Написать программу, которая по заданному $$\w{n}$$ считает число всех вершин высоты $$\w{n}$$ (в заданном дереве).

    Вместо подсчета количества вершин того или иного рода можно просить напечатать список этих вершин (в том или ином порядке).

    7.2.6. Написать программу, которая печатает (по одному разу) все вершины дерева.

    Решение. Процедура $$\w{print\_subtree(x)}$$ печатает все вершины поддерева с корнем в $$\w{x}$$ по одному разу; главная программа содержит вызов $$\w{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;

    Данная программа печатает сначала корень поддерева, затем поддерево над левым сыном, а затем над правым. Три строки в $$\w{else}$$ -части могут быть переставлены $$6$$ способами, и каждый из этих способов дает свой порядок печати вершин.

    7.3. Порождение комбинаторных объектов, перебор

    Рекурсивные программы являются удобным способом порождения комбинаторных объектов заданного вида. Мы решим заново несколько задач соответствующей лекции.

    7.3.1. Написать программу, которая печатает по одному разу все последовательности длины $$\w{n}$$, составленные из чисел $${1}\ldots{k}$$ (их количество равно $${k}^{{n}}$$ ).

    Решение. Программа будет оперировать с массивом $${a[1]}\ldots{a[n]}$$ и числом $$\w{t}$$. Рекурсивная процедура $$\w{generate}$$ печатает все последовательности, начинающиеся на $${a[1]}\ldots{a[t]}$$ ; после ее окончания $$\w{t}$$ и $${a[1]}\ldots{a[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;

    Замечание. Команды $$\w{t:=t+1}$$ и $$\w{t:=t-1}$$ для экономии можно вынести из цикла $$\w{for}$$.

    7.3.2. Написать программу, которая печатала бы все перестановки чисел $${1}\ldots{n}$$ по одному разу.

    Решение. Программа оперирует с массивом $${a[1]}\ldots{a[n]}$$, в котором хранится перестановка чисел $${1}\ldots{n}$$. Рекурсивная процедура $$\w{generate}$$ в такой ситуации печатает все перестановки, которые на первых $$\w{t}$$ позициях совпадают с перестановкой $$\w{a}$$ ; по выходе из нее переменные $$\w{t}$$ и $$\w{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. Напечатать (по одному разу) все последовательности из $$\w{n}$$ нулей и единиц, содержащие ровно $$\w{k} $$ единиц.

    7.3.4. Напечатать все возрастающие последовательности длины $$\w{k}$$, элементами которых являются натуральные числа от $$\w{1}$$ до $$\w{n}$$. (Предполагается, что $${k}\le {n}$$, иначе таких последовательностей не существует.)

    Решение. Программа оперирует с массивом $${a[1]}\ldots{a[k]}$$ и целой переменной $$\w{t}$$. Предполагая, что $${a[1]}\ldots{a[t]}$$ - возрастающая последовательность натуральных чисел из отрезка $${1}\ldots{n}$$, рекурсивно определенная процедура $$\w{generate}$$ печатает все ее возрастающие продолжения длины $$\w{k}$$. (При этом $$\w{t}$$ и $${a[1]}\ldots{a[t]}$$ в конце такие же, как в начале.)

    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;

    Замечание. Цикл $$\w{for}$$ мог бы иметь верхней границей $$\w{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;

    Можно было бы добавить к массиву $$\w{a}$$ слева фиктивный элемент $${a[0]}\hm={0}$$, положить $${t}={0}$$ и ограничиться единственным вызовом процедуры $$\w{generate}$$.

    7.3.5. Перечислить все представления положительного целого числа $$\w{n}$$ в виде суммы последовательности невозрастающих целых положительных слагаемых.

    Решение. Программа оперирует с массивом $$\w{a[1..n]}$$ (максимальное число слагаемых равно $$\w{n}$$ ) и с целой переменной $$\w{t$$ }. Предполагая, что $${a[1]}\ldots{a[t]}$$ - невозрастающая последовательность целых чисел, сумма которых не превосходит $$\w{n}$$, процедура $$\w{generate}$$ печатает все представления требуемого вида, продолжающие эту последовательность. Для экономии вычислений сумма $${a[1]}+\ldots+{a[t]}$$ хранится в специальной переменной $$\w{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}$$ из цикла, а также не возвращая $$\w{s}$$ каждый раз к исходному значению (увеличивая его на $$\w{1}$$ и возвращая к исходному значению в конце). Кроме того, добавив фиктивный элемент $${a[0]}={n}$$, можно упростить основную программу:

    t:=0; s:=0; a[0]:=n; generate;

    7.3.6. Написать рекурсивную программу обхода дерева (используя те же команды и проверки, что и в лекции 3 (Обход дерева) .

    Решение. Процедура обработать_над обрабатывает все листья над текущей вершиной и заканчивает работу в той же вершине, что и начала. Вот ее рекурсивное описание:

    procedure обработать_над;
begin
| if есть_сверху then begin
| | вверх_налево;
| | обработать_над;
| | while есть_справа do begin
| | | вправо;
| | | обработать_над;
| | end;
| | вниз;
| end else begin
| | обработать;
| end;
end;

    7.4. Другие применения рекурсии

    Топологическая сортировка. Представим себе $$n$$ чиновников, каждый из которых выдает справки определенного вида. Мы хотим получить все эти справки, соблюдая установленные ограничения: у каждого чиновника есть список справок, которые нужно собрать перед обращением к нему. Дело безнадежно, если схема зависимостей имеет цикл (справку $$A$$ нельзя получить без $$B$$, $$B$$ без $$C,\ldots,Y$$ без $$Z$$ и $$Z$$ без $$A$$ ). Предполагая, что такого цикла нет, требуется составить план, указывающий один из возможных порядков получения справок.

    Изображая чиновников точками, а зависимости - стрелками, приходим к такой формулировке. Имеется $$n$$ точек, пронумерованных от $$1$$ до $$n$$. Из каждой точки ведет несколько (возможно, $$0$$ ) стрелок в другие точки. (Такая картинка называется ориентированным графом.) Циклов нет. Требуется расположить вершины графа (точки) в таком порядке, чтобы конец любой стрелки предшествовал ее началу. Эта задача называется топологической сортировкой.

    7.4.1. Доказать, что это всегда возможно.

    Решение. Из условия отсутствия циклов вытекает, что есть вершина, из которой вообще не выходит стрелок (иначе можно двигаться по стрелкам, пока не зациклимся). Ее будем считать первой. Выкидывая все стрелки, в нее ведущие, мы сводим задачу к графу с меньшим числом вершин и продолжаем рассуждение по индукции.

    7.4.2. Предположим, что ориентированный граф без циклов хранится в такой форме: для каждого $$\w{i}$$ от $$\w{1}$$ до $$\w{n}$$ в $$\w{num[i]}$$ хранится число выходящих из $$\w{i}$$ стрелок, в $${adr[i][1]},\ldots, {adr[i][num[i]]}$$ - номера вершин, куда эти стрелки ведут. Составить (рекурсивный) алгоритм, который производит топологическую сортировку не более чем за $$C\cdot({n}+{m})$$ действий, где $$\w{m}$$ - число ребер графа (стрелок).

    Замечание. Непосредственная реализация приведенного выше доказательства существования не дает требуемой оценки; ее приходится немного подправить.

    Решение. Наша программа будет печатать номера вершин. В массиве

    printed: array[1..n] of boolean

    мы будем хранить сведения о том, какие вершины напечатаны (и корректировать их одновременно с печатью вершины). Будем говорить, что напечатанная последовательность вершин корректна, если никакая вершина не напечатана дважды и для любого номера $$\w{i}$$, входящего в эту последовательность, все вершины, в которые ведут стрелки из $$\w{i}$$, напечатаны, и притом до $$\w{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. Где использован тот факт, что граф не имеет циклов?

    Решение. Мы опустили доказательство конечности глубины рекурсии. Для каждой вершины рассмотрим ее "глубину" - максимальную длину пути по стрелкам, из нее выходящего. Условие отсутствия циклов гарантирует, что эта величина конечна. Из вершины нулевой глубины стрелок не выходит. Глубина конца стрелки по крайней мере на $$1$$ меньше, чем глубина начала. При работе процедуры $$\w{add(i)}$$ все рекурсивные вызовы $$\w{add(j)}$$ относятся к вершинам меньшей глубины.

    Вернемся к оценке времени работы. Сколько вызовов $$\w{add(i)}$$ возможно для какого-то фиксированного $$\w{i}$$? Прежде всего ясно, что первый из них печатает $$\w{i}$$, остальные сведутся к проверке того, что $$\w{i}$$ уже напечатано. Ясно также, что вызовы $$\w{add(i)}$$ индуцируются "печатающими" (первыми) вызовами $$\w{add(j)}$$ для тех $$\w{j}$$, из которых в $$\w{i}$$ ведет ребро. Следовательно, число вызовов $$\w{add(i)}$$ равно числу входящих в $$\w{i}$$ ребер (стрелок). При этом все вызовы, кроме первого, требуют $$O(1)$$ операций, а первый требует времени, пропорционального числу исходящих из $$\w{i}$$ стрелок. (Не считая времени, уходящего на выполнение $$\w{add(j)}$$ для концов $$\w{j}$$ выходящих ребер.) Отсюда видно, что общее время пропорционально числу ребер (плюс число вершин).

    Связная компонента графа. Неориентированный граф - набор точек (вершин), некоторые из которых соединены линиями (ребрами). Неориентированный граф можно считать частным случаем ориентированного графа, в котором для каждой стрелки есть обратная.

    Связной компонентой вершины $$\w{i}$$ называется множество всех тех вершин, в которые можно попасть из $$\w{i}$$, идя по ребрам графа. (Поскольку граф неориентированный, отношение " $$\w{j}$$ принадлежит связной компоненте $$\w{i}$$ " является отношением эквивалентности.)

    7.4.5. Дан неориентированный граф (для каждой вершины указано число соседей и массив номеров соседей, как в задаче о топологической сортировке). Составить алгоритм, который по заданному $$\w{i}$$ печатает все вершины связной компоненты $$\w{i}$$ по одному разу (и только их). Число действий не должно превосходить $$C\cdot{}$$ (общее число вершин и ребер в связной компоненте).

    Решение. Программа в процессе работы будет "закрашивать" некоторые вершины графа. Незакрашенной частью графа будем называть то, что останется, если выбросить все закрашенные вершины и ведущие в них ребра. Процедура $$\w{add(i)}$$ закрашивает связную компоненту $$\w{i}$$ в незакрашенной части графа (и не делает ничего, если вершина $$\w{i}$$ уже закрашена).

    procedure  add (i:1..n);
begin
| if вершина i закрашена then begin
| | ничего делать не надо
| end else begin
| | закрасить i (напечатать и пометить как закрашенную)
| | для всех j, соседних с i
| | | add(j);
| | end;
| end;
end;

    Докажем, что эта процедура действует правильно (в предположении, что рекурсивные вызовы работают правильно). В самом деле, ничего, кроме связной компоненты незакрашенного графа, она закрасить не может. Проверим, что вся она будет закрашена. Пусть $$\w{k}$$ - вершина, доступная из вершины $$\w{i}$$ по пути $${i}\rightarrow{j}\rightarrow\ldots\rightarrow{k}$$, проходящему только по незакрашенным вершинам. Будем рассматривать только пути, не возвращающиеся снова в $$\w{i}$$. Из всех таких путей выберем путь с наименьшим $$\w{j}$$ (в порядке просмотра соседей в процедуре). Тогда при рассмотрении предыдущих соседей ни одна из вершин пути $${j}\rightarrow\ldots\rightarrow{k}$$ не будет закрашена (иначе $$\w{j}$$ не было бы минимальным) и потому $$\w{k}$$ окажется в связной компоненте незакрашенного графа к моменту вызова $$\w{add(j)}$$. Что и требовалось.

    Чтобы установить конечность глубины рекурсии, заметим, что на каждом уровне рекурсии число незакрашенных вершин уменьшается хотя бы на $$1$$.

    Оценим число действий. Каждая вершина закрашивается не более одного раза - при первым вызове $$\w{add(i)}$$ с данным $$\w{i}$$. Все последующие вызовы происходят при закрашивании соседей - количество таких вызовов не больше числа соседей - и сводятся к проверке того, что вершина $$\w{i}$$ уже закрашена. Первый же вызов состоит в просмотре всех соседей и рекурсивных вызовах $$\w{add(j)}$$ для всех них. Таким образом, общее число действий, связанных с вершиной $$\w{i}$$, не превосходит константы, умноженной на число ее соседей. Отсюда и вытекает требуемая оценка.

    7.4.6. Решить ту же задачу для ориентированного графа (напечатать все вершины, доступные из данной по стрелкам; граф может содержать циклы).

    Ответ. Годится по существу та же программа (строку "для всех соседей" надо заменить на "для всех вершин, куда ведут стрелки").

    Следующий вариант задачи о связной компоненте имеет скорее теоретическое значение (и называется теоремой Сэвича).

    7.4.7. Ориентированный граф имеет $$2^n$$ вершин (двоичные слова длины $$n$$ ) и задан в виде функции есть_ребро, которая по двум вершинам $$x$$ и $$y$$ сообщает, есть ли в графе ребро из $$x$$ в $$y$$. Составить алгоритм, который для данной пары вершин $$u$$ и $$v$$ определяет, есть ли путь (по ребрам) из $$u$$ в $$v$$, используя память, ограниченную многочленом от $$n$$. (Время при этом может быть - и будет - очень большим.)

    Указание. Использовать рекурсивную процедуру, выясняющую, существует ли путь из $$x$$ в $$y$$ длины не более $$2^k$$ (и вызывающую себя с уменьшенным на единицу значением $$k$$ ).

    Быстрая сортировка Хоара. В заключение приведем рекурсивный алгоритм сортировки массива, который на практике является одним из самых быстрых. Пусть дан массив $${a[1]}\ldots{a[n]}$$. Рекурсивная процедура $$\w{sort(l,r:integer)}$$ сортирует участок массива с индексами из полуинтервала $$({l},{r}]$$, то есть $${a[l+1]}\ldots{a[r]}$$, не затрагивая остального массива.

    procedure sort (l,r: integer);
begin
| if l = r then begin
| | ничего делать не надо - участок пуст
| end else begin
| | выбрать случайное число s в полуинтервале (l,r]
| | b := a[s]
| | переставить элементы сортируемого участка так, чтобы
| |   сначала шли элементы, меньшие b - участок (l,ll]
| |   затем элементы, равные b- участок (ll,rr]
| |   затем элементы, большие b       - участок (rr,r]
| | sort (l,ll);
| | sort (rr,r);
| end;
end;

    Разделение элементов сортируемого участка на три категории (меньшие, равные, больше) рассматривалась в лекции 1 (это можно сделать за время, пропорциональное длине участка). Конечность глубины рекурсии гарантируется тем, что длина сортируемого участка на каждом уровне рекурсии уменьшается хотя бы на $$1$$.

    7.4.8. (Для знакомых с основами теории вероятностей). Доказать, что математическое ожидание числа операций при работе этого алгоритма не превосходит $$Cn log n$$, причем константа $$C$$ не зависит от сортируемого массива.

    Указание. Пусть $$T(n)$$ - максимум математического ожидания числа операций для всех входов длины $$n$$. Из текста процедуры вытекает такое неравенство:$$T(n) \le Cn + \frac{1}{n}\sum_{k+l=n-1} \bigl( T(k)+T(l) \bigr)$$ Первый член соответствует распределению элементов на меньшие, равные и большие. Второй член - это среднее математическое ожидание для всех вариантов случайного выбора. (Строго говоря, поскольку среди элементов могут быть равные, в правой части вместо $$T(k)$$ и $$T(l)$$ должны стоять максимумы $$T(x)$$ по всем $$x$$, не превосходящим $$k$$ или $$l$$, но это не мешает дальнейшим рассуждениям.) Далее индукцией по $$n$$ нужно доказывать оценку $$T(n) \le C'n\ln n$$. При этом для вычисления среднего значения $$x ln x$$ по всем $$x=1,\ldots,n-1$$ нужно вычислять $$\int_1^n x ln x\,dx$$ по частям как $$\int ln x \, d(x^2)$$. При достаточно большом $$C'$$ член $$Cn$$ в правой части перевешивается за счет интеграла $$\int x^2\, d ln x$$, и индуктивный шаг проходит.

    7.4.9. Имеется массив из $$n$$ различных целых чисел $${a[1]}\ldots{a[n]}$$ и число $$k$$. Требуется найти $$k$$ -ое по величине число в этом массиве, сделав не более $$Cn$$ действий, где $$C$$ - некоторая константа, не зависящая от $$k$$ и $$n$$.

    Замечание. Сортировка позволяет очевидным образом сделать это за $$Cn\log n$$ действий. Очевидный способ: найти наименьший элемент, затем найти второй, затем третий, $$\ldots, k$$ -ый требует порядка $$kn$$ действий, то есть не годится (константа при $$n$$ зависит от $$k$$ ).

    Указание. Изящный (хотя практически и бесполезный - константы слишком велики) способ сделать это таков:

    А. Разобьем наш массив на $$n/5$$ групп, в каждой из которых по $$5$$ элементов. Каждую группу упорядочим.

    Б. Рассмотрим средние элементы всех групп и перепишем их в массив из $$n/5$$ элементов. С помощью рекурсивного вызова найдем средний по величине элемент этого массива.

    В. Сравним этот элемент со всеми элементами исходного массива: они разделятся на большие его и меньшие его (и один равный ему). Подсчитав количество тех и других, мы узнаем, в какой из этих частей должен находится искомый ( $$k$$ -ый) элемент и каков он там по порядку.

    Г. Применим рекурсивно наш алгоритм к выбранной части.

    Пусть $$T(n)$$ - максимально возможное число действий, если этот способ применять к массивам из не более чем $$n$$ элементов ( $$k$$ может быть каким угодно). Имеем оценку:$$T(n) \le Cn + T(n/5) + T (\text{примерно 0{,}7n}).$$ Последнее слагаемое объясняется так: при разбиении на части каждая часть содержит не менее $$0{,}3n$$ элементов. В самом деле, если $$x$$ - средний из средних, то примерно половина всех средних меньше $$x$$. А если в пятерке средний элемент меньше $$x$$, то еще два заведомо меньше $$x$$. Тем самым по крайней мере $$3/5$$ от половины элементов меньше $$x$$.

    Теперь по индукции можно доказать оценку $$T(n) \le Cn$$ (решающую роль при этом играет то обстоятельство, что $$1/5 + 0{,}7 < 1$$ ).

    Страницы:

    7.1. Примеры рекурсивных программ

    При анализе рекурсивной программы возникает, как обычно, два вопроса:

  • почему программа заканчивает работу?
  • почему она работает правильно, если заканчивает работу?
    •

    Для (2) достаточно проверить, что (содержащая рекурсивный вызов) программа работает правильно, предположив, что вызываемая ею одноименная программа работает правильно. В самом деле, в этом случае в цепочке рекурсивно вызываемых программ все программы работают правильно (убеждаемся в этом, идя от конца цепочки к началу).

    Чтобы доказать (1), обычно проверяют, что с каждым рекурсивным вызовом значение какого-то параметра уменьшается, и это не может продолжаться бесконечно.

    7.1.1. Написать рекурсивную процедуру вычисления факториала целого положительного числа $$n$$ (т. е. произведения $$1\cdot2\cdots n$$, обозначаемого $$n$$!).

    Решение. Используем равенства $$1!=1$$, $$n!= (n-1)!\cdot n$$.

    procedure factorial (n: integer; var fact: integer);
| {положить fact равным факториалу числа n}
begin
| if n=1 then begin
| | fact:=1;
| end else begin {n>1}
| | factorial (n-1, fact);
| | {fact = (n-1)!}
| | 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;

    Обратите внимание на некоторую двойственность использования имени $$\w{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*a, n div 2);
| end else begin
| | power:= power(a, n-1)*a;
| end;
end;

    7.1.5. Что будет, если изменить программу, приведенную в решении предыдущей задачи, заменив строку

    power:= power(a*a, n div 2)

    на

    power:= power(a, n div 2)* power(a, n div 2)?

    Решение. Программа останется правильной. Однако она станет работать медленнее. Дело в том, что теперь вызов может породить два вызова (хотя и одинаковых) вместо одного - и число вызовов быстро растет с глубиной рекурсии. Программа по-прежнему имеет логарифмическую глубину рекурсии, но число шагов работы становится линейным вместо логарифмического.

    Этот недостаток можно устранить, написав

    t:= power(a, n div 2);
power:= t*t;

    или воспользовавшись функцией возведения в квадрат $$(\w{sqr})$$.

    7.1.6. Используя команды $$\w{write(x)}$$ лишь при $${x}=0\ldots9$$, написать рекурсивную программу печати десятичной записи целого положительного числа $$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$$ колец (большие кольца снизу, меньшие сверху). Требуется переместить кольца на другой стержень. Разрешается перекладывать кольца со стержня на стержень, но класть большее кольцо поверх меньшего нельзя. Составить программу, указывающую требуемые действия.

    Решение. Напишем рекурсивную процедуру перемещения $$\w{i}$$ верхних колец с $$\w{m}$$ -го стержня на $$\w{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}$$ колец на третью палочку. После этого $$\hbox{{i}-ое}$$ кольцо освобождается, и его можно перенести куда следует. Остается положить на него пирамидку.)

    7.1.8. Написать рекурсивную программу суммирования массива $$\text{a: array [1..n] of integer}$$.

    Указание. Рекурсивно определяемая функция должна иметь дополнительный параметр - число складываемых элементов.

    7.2. Рекурсивная обработка деревьев

    Двоичным деревом называется картинка вроде такой:

    Нижняя вершина называется корнем. Из каждой вершины могут идти две линии: влево вверх и вправо вверх. Вершины, куда они ведут, называются левым и правым сыновьями } исходной вершины. Вершина может иметь двух сыновей, а может иметь только одного сына (левого или правого). Она может и вовсе не иметь сыновей, и в этом случае называется листом.

    Пусть $$x$$ - какая-то вершина двоичного дерева. Она сама вместе с сыновьями, внуками, правнуками и т.д. образует поддерево с корнем в $$x$$ - поддерево потомков x.

    В следующих задачах мы предполагаем, что вершины дерева пронумерованы целыми положительными числами, причем номера всех вершин различны. Мы считаем, что номер корня хранится в переменной $$\w{root}$$. Мы считаем, что имеются два массива

    l,r: array [1..N] of integer

    и левый и правый сын вершины с номером $$\w{i}$$ имеют соответственно номера $$\w{l[i]}$$ и $$\w{r[i]}$$. Если вершина с номером $$\w{i}$$ не имеет левого (или правого) сына, то $$\w{l[i]}$$ (соответственно $$\w{r[i]})$$ равно $$\w{0}$$. (По традиции при записи программ мы используем вместо нуля константу $$\w{nil}$$, равную нулю.)

    Здесь $$\w{N}$$ - достаточно большое натуральное число (номера всех вершин не превосходят $$\w{N})$$. Отметим, что номер вершины никак не связан с ее положением в дереве и что не все числа от $$\w{1}$$ до $$\w{N}$$ обязаны быть номерами вершин (и, следовательно, часть данных в массивах $$\w{l}$$ и $$\w{r}$$ - это мусор).

    7.2.1. Пусть $${N}=7$$, $${root}=3$$, массивы $$\w{l} $$ и $$\w{r}$$ таковы:$$\begin{tabular}{r|ccccccc} \w{i} 1 2 3 4 5 6 7\\ \w{l[i]} 0 0 1 0 6 0 7\\ \w{r[i]} 0 0 5 3 2 0 7 \end{tabular}$$ Нарисовать соответствующее дерево.

    Ответ.

    7.2.2. Написать программу подсчета числа вершин в дереве.

    Решение. Рассмотрим функцию $$\w{n(x)}$$, равную числу вершин в поддереве с корнем в вершине номер $$\w{x}$$. Считаем, что $${n(nil)}={0}$$ (полагая соответствующее поддерево пустым), и не заботимся о значениях $$\w{nil(s)}$$ для чисел $$\w{s}$$, не являющихся номерами вершин. Рекурсивная программа для $$\w{n}$$ такова:

    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;

    (Число вершин в поддереве над вершиной $$\w{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 else begin
| | n:= n(l[x]) + n(r[x]);
| end;
end;

    7.2.4. Написать программу подсчета высоты дерева (корень имеет высоту $$0$$, его сыновья - высоту $$1$$, внуки - $$2$$ и т.п.; высота дерева - это максимум высот его вершин).

    Указание. Рекурсивно определяется функция $${f(x)} = {}$$ высота поддерева с корнем в $$\w{x}$$.

    7.2.5. Написать программу, которая по заданному $$\w{n}$$ считает число всех вершин высоты $$\w{n}$$ (в заданном дереве).

    Вместо подсчета количества вершин того или иного рода можно просить напечатать список этих вершин (в том или ином порядке).

    7.2.6. Написать программу, которая печатает (по одному разу) все вершины дерева.

    Решение. Процедура $$\w{print\_subtree(x)}$$ печатает все вершины поддерева с корнем в $$\w{x}$$ по одному разу; главная программа содержит вызов $$\w{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;

    Данная программа печатает сначала корень поддерева, затем поддерево над левым сыном, а затем над правым. Три строки в $$\w{else}$$ -части могут быть переставлены $$6$$ способами, и каждый из этих способов дает свой порядок печати вершин.

    7.3. Порождение комбинаторных объектов, перебор

    Рекурсивные программы являются удобным способом порождения комбинаторных объектов заданного вида. Мы решим заново несколько задач соответствующей лекции.

    7.3.1. Написать программу, которая печатает по одному разу все последовательности длины $$\w{n}$$, составленные из чисел $${1}\ldots{k}$$ (их количество равно $${k}^{{n}}$$ ).

    Решение. Программа будет оперировать с массивом $${a[1]}\ldots{a[n]}$$ и числом $$\w{t}$$. Рекурсивная процедура $$\w{generate}$$ печатает все последовательности, начинающиеся на $${a[1]}\ldots{a[t]}$$ ; после ее окончания $$\w{t}$$ и $${a[1]}\ldots{a[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;

    Замечание. Команды $$\w{t:=t+1}$$ и $$\w{t:=t-1}$$ для экономии можно вынести из цикла $$\w{for}$$.

    7.3.2. Написать программу, которая печатала бы все перестановки чисел $${1}\ldots{n}$$ по одному разу.

    Решение. Программа оперирует с массивом $${a[1]}\ldots{a[n]}$$, в котором хранится перестановка чисел $${1}\ldots{n}$$. Рекурсивная процедура $$\w{generate}$$ в такой ситуации печатает все перестановки, которые на первых $$\w{t}$$ позициях совпадают с перестановкой $$\w{a}$$ ; по выходе из нее переменные $$\w{t}$$ и $$\w{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. Напечатать (по одному разу) все последовательности из $$\w{n}$$ нулей и единиц, содержащие ровно $$\w{k} $$ единиц.

    7.3.4. Напечатать все возрастающие последовательности длины $$\w{k}$$, элементами которых являются натуральные числа от $$\w{1}$$ до $$\w{n}$$. (Предполагается, что $${k}\le {n}$$, иначе таких последовательностей не существует.)

    Решение. Программа оперирует с массивом $${a[1]}\ldots{a[k]}$$ и целой переменной $$\w{t}$$. Предполагая, что $${a[1]}\ldots{a[t]}$$ - возрастающая последовательность натуральных чисел из отрезка $${1}\ldots{n}$$, рекурсивно определенная процедура $$\w{generate}$$ печатает все ее возрастающие продолжения длины $$\w{k}$$. (При этом $$\w{t}$$ и $${a[1]}\ldots{a[t]}$$ в конце такие же, как в начале.)

    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;

    Замечание. Цикл $$\w{for}$$ мог бы иметь верхней границей $$\w{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;

    Можно было бы добавить к массиву $$\w{a}$$ слева фиктивный элемент $${a[0]}\hm={0}$$, положить $${t}={0}$$ и ограничиться единственным вызовом процедуры $$\w{generate}$$.

    7.3.5. Перечислить все представления положительного целого числа $$\w{n}$$ в виде суммы последовательности невозрастающих целых положительных слагаемых.

    Решение. Программа оперирует с массивом $$\w{a[1..n]}$$ (максимальное число слагаемых равно $$\w{n}$$ ) и с целой переменной $$\w{t$$ }. Предполагая, что $${a[1]}\ldots{a[t]}$$ - невозрастающая последовательность целых чисел, сумма которых не превосходит $$\w{n}$$, процедура $$\w{generate}$$ печатает все представления требуемого вида, продолжающие эту последовательность. Для экономии вычислений сумма $${a[1]}+\ldots+{a[t]}$$ хранится в специальной переменной $$\w{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}$$ из цикла, а также не возвращая $$\w{s}$$ каждый раз к исходному значению (увеличивая его на $$\w{1}$$ и возвращая к исходному значению в конце). Кроме того, добавив фиктивный элемент $${a[0]}={n}$$, можно упростить основную программу:

    t:=0; s:=0; a[0]:=n; generate;

    7.3.6. Написать рекурсивную программу обхода дерева (используя те же команды и проверки, что и в лекции 3 (Обход дерева) .

    Решение. Процедура обработать_над обрабатывает все листья над текущей вершиной и заканчивает работу в той же вершине, что и начала. Вот ее рекурсивное описание:

    procedure обработать_над;
begin
| if есть_сверху then begin
| | вверх_налево;
| | обработать_над;
| | while есть_справа do begin
| | | вправо;
| | | обработать_над;
| | end;
| | вниз;
| end else begin
| | обработать;
| end;
end;

    7.4. Другие применения рекурсии

    Топологическая сортировка. Представим себе $$n$$ чиновников, каждый из которых выдает справки определенного вида. Мы хотим получить все эти справки, соблюдая установленные ограничения: у каждого чиновника есть список справок, которые нужно собрать перед обращением к нему. Дело безнадежно, если схема зависимостей имеет цикл (справку $$A$$ нельзя получить без $$B$$, $$B$$ без $$C,\ldots,Y$$ без $$Z$$ и $$Z$$ без $$A$$ ). Предполагая, что такого цикла нет, требуется составить план, указывающий один из возможных порядков получения справок.

    Изображая чиновников точками, а зависимости - стрелками, приходим к такой формулировке. Имеется $$n$$ точек, пронумерованных от $$1$$ до $$n$$. Из каждой точки ведет несколько (возможно, $$0$$ ) стрелок в другие точки. (Такая картинка называется ориентированным графом.) Циклов нет. Требуется расположить вершины графа (точки) в таком порядке, чтобы конец любой стрелки предшествовал ее началу. Эта задача называется топологической сортировкой.

    7.4.1. Доказать, что это всегда возможно.

    Решение. Из условия отсутствия циклов вытекает, что есть вершина, из которой вообще не выходит стрелок (иначе можно двигаться по стрелкам, пока не зациклимся). Ее будем считать первой. Выкидывая все стрелки, в нее ведущие, мы сводим задачу к графу с меньшим числом вершин и продолжаем рассуждение по индукции.

    7.4.2. Предположим, что ориентированный граф без циклов хранится в такой форме: для каждого $$\w{i}$$ от $$\w{1}$$ до $$\w{n}$$ в $$\w{num[i]}$$ хранится число выходящих из $$\w{i}$$ стрелок, в $${adr[i][1]},\ldots, {adr[i][num[i]]}$$ - номера вершин, куда эти стрелки ведут. Составить (рекурсивный) алгоритм, который производит топологическую сортировку не более чем за $$C\cdot({n}+{m})$$ действий, где $$\w{m}$$ - число ребер графа (стрелок).

    Замечание. Непосредственная реализация приведенного выше доказательства существования не дает требуемой оценки; ее приходится немного подправить.

    Решение. Наша программа будет печатать номера вершин. В массиве

    printed: array[1..n] of boolean

    мы будем хранить сведения о том, какие вершины напечатаны (и корректировать их одновременно с печатью вершины). Будем говорить, что напечатанная последовательность вершин корректна, если никакая вершина не напечатана дважды и для любого номера $$\w{i}$$, входящего в эту последовательность, все вершины, в которые ведут стрелки из $$\w{i}$$, напечатаны, и притом до $$\w{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. Где использован тот факт, что граф не имеет циклов?

    Решение. Мы опустили доказательство конечности глубины рекурсии. Для каждой вершины рассмотрим ее "глубину" - максимальную длину пути по стрелкам, из нее выходящего. Условие отсутствия циклов гарантирует, что эта величина конечна. Из вершины нулевой глубины стрелок не выходит. Глубина конца стрелки по крайней мере на $$1$$ меньше, чем глубина начала. При работе процедуры $$\w{add(i)}$$ все рекурсивные вызовы $$\w{add(j)}$$ относятся к вершинам меньшей глубины.

    Вернемся к оценке времени работы. Сколько вызовов $$\w{add(i)}$$ возможно для какого-то фиксированного $$\w{i}$$? Прежде всего ясно, что первый из них печатает $$\w{i}$$, остальные сведутся к проверке того, что $$\w{i}$$ уже напечатано. Ясно также, что вызовы $$\w{add(i)}$$ индуцируются "печатающими" (первыми) вызовами $$\w{add(j)}$$ для тех $$\w{j}$$, из которых в $$\w{i}$$ ведет ребро. Следовательно, число вызовов $$\w{add(i)}$$ равно числу входящих в $$\w{i}$$ ребер (стрелок). При этом все вызовы, кроме первого, требуют $$O(1)$$ операций, а первый требует времени, пропорционального числу исходящих из $$\w{i}$$ стрелок. (Не считая времени, уходящего на выполнение $$\w{add(j)}$$ для концов $$\w{j}$$ выходящих ребер.) Отсюда видно, что общее время пропорционально числу ребер (плюс число вершин).

    Связная компонента графа. Неориентированный граф - набор точек (вершин), некоторые из которых соединены линиями (ребрами). Неориентированный граф можно считать частным случаем ориентированного графа, в котором для каждой стрелки есть обратная.

    Связной компонентой вершины $$\w{i}$$ называется множество всех тех вершин, в которые можно попасть из $$\w{i}$$, идя по ребрам графа. (Поскольку граф неориентированный, отношение " $$\w{j}$$ принадлежит связной компоненте $$\w{i}$$ " является отношением эквивалентности.)

    7.4.5. Дан неориентированный граф (для каждой вершины указано число соседей и массив номеров соседей, как в задаче о топологической сортировке). Составить алгоритм, который по заданному $$\w{i}$$ печатает все вершины связной компоненты $$\w{i}$$ по одному разу (и только их). Число действий не должно превосходить $$C\cdot{}$$ (общее число вершин и ребер в связной компоненте).

    Решение. Программа в процессе работы будет "закрашивать" некоторые вершины графа. Незакрашенной частью графа будем называть то, что останется, если выбросить все закрашенные вершины и ведущие в них ребра. Процедура $$\w{add(i)}$$ закрашивает связную компоненту $$\w{i}$$ в незакрашенной части графа (и не делает ничего, если вершина $$\w{i}$$ уже закрашена).

    procedure  add (i:1..n);
begin
| if вершина i закрашена then begin
| | ничего делать не надо
| end else begin
| | закрасить i (напечатать и пометить как закрашенную)
| | для всех j, соседних с i
| | | add(j);
| | end;
| end;
end;

    Докажем, что эта процедура действует правильно (в предположении, что рекурсивные вызовы работают правильно). В самом деле, ничего, кроме связной компоненты незакрашенного графа, она закрасить не может. Проверим, что вся она будет закрашена. Пусть $$\w{k}$$ - вершина, доступная из вершины $$\w{i}$$ по пути $${i}\rightarrow{j}\rightarrow\ldots\rightarrow{k}$$, проходящему только по незакрашенным вершинам. Будем рассматривать только пути, не возвращающиеся снова в $$\w{i}$$. Из всех таких путей выберем путь с наименьшим $$\w{j}$$ (в порядке просмотра соседей в процедуре). Тогда при рассмотрении предыдущих соседей ни одна из вершин пути $${j}\rightarrow\ldots\rightarrow{k}$$ не будет закрашена (иначе $$\w{j}$$ не было бы минимальным) и потому $$\w{k}$$ окажется в связной компоненте незакрашенного графа к моменту вызова $$\w{add(j)}$$. Что и требовалось.

    Чтобы установить конечность глубины рекурсии, заметим, что на каждом уровне рекурсии число незакрашенных вершин уменьшается хотя бы на $$1$$.

    Оценим число действий. Каждая вершина закрашивается не более одного раза - при первым вызове $$\w{add(i)}$$ с данным $$\w{i}$$. Все последующие вызовы происходят при закрашивании соседей - количество таких вызовов не больше числа соседей - и сводятся к проверке того, что вершина $$\w{i}$$ уже закрашена. Первый же вызов состоит в просмотре всех соседей и рекурсивных вызовах $$\w{add(j)}$$ для всех них. Таким образом, общее число действий, связанных с вершиной $$\w{i}$$, не превосходит константы, умноженной на число ее соседей. Отсюда и вытекает требуемая оценка.

    7.4.6. Решить ту же задачу для ориентированного графа (напечатать все вершины, доступные из данной по стрелкам; граф может содержать циклы).

    Ответ. Годится по существу та же программа (строку "для всех соседей" надо заменить на "для всех вершин, куда ведут стрелки").

    Следующий вариант задачи о связной компоненте имеет скорее теоретическое значение (и называется теоремой Сэвича).

    7.4.7. Ориентированный граф имеет $$2^n$$ вершин (двоичные слова длины $$n$$ ) и задан в виде функции есть_ребро, которая по двум вершинам $$x$$ и $$y$$ сообщает, есть ли в графе ребро из $$x$$ в $$y$$. Составить алгоритм, который для данной пары вершин $$u$$ и $$v$$ определяет, есть ли путь (по ребрам) из $$u$$ в $$v$$, используя память, ограниченную многочленом от $$n$$. (Время при этом может быть - и будет - очень большим.)

    Указание. Использовать рекурсивную процедуру, выясняющую, существует ли путь из $$x$$ в $$y$$ длины не более $$2^k$$ (и вызывающую себя с уменьшенным на единицу значением $$k$$ ).

    Быстрая сортировка Хоара. В заключение приведем рекурсивный алгоритм сортировки массива, который на практике является одним из самых быстрых. Пусть дан массив $${a[1]}\ldots{a[n]}$$. Рекурсивная процедура $$\w{sort(l,r:integer)}$$ сортирует участок массива с индексами из полуинтервала $$({l},{r}]$$, то есть $${a[l+1]}\ldots{a[r]}$$, не затрагивая остального массива.

    procedure sort (l,r: integer);
begin
| if l = r then begin
| | ничего делать не надо - участок пуст
| end else begin
| | выбрать случайное число s в полуинтервале (l,r]
| | b := a[s]
| | переставить элементы сортируемого участка так, чтобы
| |   сначала шли элементы, меньшие b - участок (l,ll]
| |   затем элементы, равные b- участок (ll,rr]
| |   затем элементы, большие b       - участок (rr,r]
| | sort (l,ll);
| | sort (rr,r);
| end;
end;

    Разделение элементов сортируемого участка на три категории (меньшие, равные, больше) рассматривалась в лекции 1 (это можно сделать за время, пропорциональное длине участка). Конечность глубины рекурсии гарантируется тем, что длина сортируемого участка на каждом уровне рекурсии уменьшается хотя бы на $$1$$.

    7.4.8. (Для знакомых с основами теории вероятностей). Доказать, что математическое ожидание числа операций при работе этого алгоритма не превосходит $$Cn log n$$, причем константа $$C$$ не зависит от сортируемого массива.

    Указание. Пусть $$T(n)$$ - максимум математического ожидания числа операций для всех входов длины $$n$$. Из текста процедуры вытекает такое неравенство:$$T(n) \le Cn + \frac{1}{n}\sum_{k+l=n-1} \bigl( T(k)+T(l) \bigr)$$ Первый член соответствует распределению элементов на меньшие, равные и большие. Второй член - это среднее математическое ожидание для всех вариантов случайного выбора. (Строго говоря, поскольку среди элементов могут быть равные, в правой части вместо $$T(k)$$ и $$T(l)$$ должны стоять максимумы $$T(x)$$ по всем $$x$$, не превосходящим $$k$$ или $$l$$, но это не мешает дальнейшим рассуждениям.) Далее индукцией по $$n$$ нужно доказывать оценку $$T(n) \le C'n\ln n$$. При этом для вычисления среднего значения $$x ln x$$ по всем $$x=1,\ldots,n-1$$ нужно вычислять $$\int_1^n x ln x\,dx$$ по частям как $$\int ln x \, d(x^2)$$. При достаточно большом $$C'$$ член $$Cn$$ в правой части перевешивается за счет интеграла $$\int x^2\, d ln x$$, и индуктивный шаг проходит.

    7.4.9. Имеется массив из $$n$$ различных целых чисел $${a[1]}\ldots{a[n]}$$ и число $$k$$. Требуется найти $$k$$ -ое по величине число в этом массиве, сделав не более $$Cn$$ действий, где $$C$$ - некоторая константа, не зависящая от $$k$$ и $$n$$.

    Замечание. Сортировка позволяет очевидным образом сделать это за $$Cn\log n$$ действий. Очевидный способ: найти наименьший элемент, затем найти второй, затем третий, $$\ldots, k$$ -ый требует порядка $$kn$$ действий, то есть не годится (константа при $$n$$ зависит от $$k$$ ).

    Указание. Изящный (хотя практически и бесполезный - константы слишком велики) способ сделать это таков:

    А. Разобьем наш массив на $$n/5$$ групп, в каждой из которых по $$5$$ элементов. Каждую группу упорядочим.

    Б. Рассмотрим средние элементы всех групп и перепишем их в массив из $$n/5$$ элементов. С помощью рекурсивного вызова найдем средний по величине элемент этого массива.

    В. Сравним этот элемент со всеми элементами исходного массива: они разделятся на большие его и меньшие его (и один равный ему). Подсчитав количество тех и других, мы узнаем, в какой из этих частей должен находится искомый ( $$k$$ -ый) элемент и каков он там по порядку.

    Г. Применим рекурсивно наш алгоритм к выбранной части.

    Пусть $$T(n)$$ - максимально возможное число действий, если этот способ применять к массивам из не более чем $$n$$ элементов ( $$k$$ может быть каким угодно). Имеем оценку:$$T(n) \le Cn + T(n/5) + T (\text{примерно 0{,}7n}).$$ Последнее слагаемое объясняется так: при разбиении на части каждая часть содержит не менее $$0{,}3n$$ элементов. В самом деле, если $$x$$ - средний из средних, то примерно половина всех средних меньше $$x$$. А если в пятерке средний элемент меньше $$x$$, то еще два заведомо меньше $$x$$. Тем самым по крайней мере $$3/5$$ от половины элементов меньше $$x$$.

    Теперь по индукции можно доказать оценку $$T(n) \le Cn$$ (решающую роль при этом играет то обстоятельство, что $$1/5 + 0{,}7 < 1$$ ).

    Предыдущее занятие Следующее занятие
    Вернуться к учебному плану
    ^