Дасгупты, Пападимитриу, Вазирани «Алгоритмы»

52 Глава 2. Метод «разделяй и властвуй»

Если бы не трюк Гаусса, то коэффициент ветвления дерева (количество детей у внутренней вершины) был бы равен 4. У дерева тогда было бы 4log2 n = = n2 листьев, и время работы алгоритма было бы квадратичным. Так что коэффициент ветвления в методе «разделяй и властвуй» очень важен.

На практике нет смысла спускаться в дереве рекурсии до однобитовых чисел. В большинстве процессоров умножение 16или 32-битовых чисел является элементарной операцией, поэтому на этом уровне можно (и нужно) воспользоваться встроенной командой умножения.

А существует ли ещё более быстрый алгоритм? Оказывается, что да; он тоже основан на методе «разделяй и властвуй» (см. раздел 2.6 о быстром преобразовании Фурье).

2.2. Рекуррентные соотношения

Представим себе алгоритм, работающий по методу «разделяй и властвуй». Пусть он сводит данную задачу размера n к a подзадачам размера n=b и из найденных ответов строит ответ для исходной задачи. Будем считать, что на разбиение и сборку уходит время O(nd ) (в рассмотренном выше алгоритме умножения a = 3, b = 2, d = 1). Рекуррентное соотношение на время работы такого алгоритма:

Доказательство. Для простоты будем считать, что n есть степень b. Это не сказывается на асимптотике, так как n отличается от ближайшей сверху степени b не более чем в b раз (упражнение 2.2); ясно, что при уменьшении n высота дерева и его размер могут только уменьшиться.

Дерево работы алгоритма имеет logb n уровней, поскольку с увеличением номера уровня размер подзадач уменьшается в b раз. Коэффициент ветвления дерева есть a, так что k-й уровень содержит ak подзадач размера n=bk (рис. 2.3). Количество операций, которое алгоритм производит на этом уровне, есть

Последовательность ftkg (где k меняется от 0 до logb n), таким образом, является геометрической прогрессией со знаменателем a=bd . Её первый член t0

Рис. 2.3. Задача размера n разбивается на a подзадач размера n=b.

равен O(nd ); последний член, при k = logb n, соответствует alogb n = nlogb a задачам размера 1, то есть равен O(nlogb a).

Оценка на сумму членов геометрической прогрессии зависит от её знаменателя (упражнение 0.2). Получаем три варианта, соответствующие трём случаям в теореме:

1. Знаменатель меньше 1.

Прогрессия убывает, и её сумма оценивается через первый член: O(nd ).

2. Знаменатель больше 1.

Прогрессия возрастает; сумма оценивается через последний член O(nlogb a).

3. Знаменатель равен 1.

Тогда все O(log n) членов прогрессии равны, и её сумма есть O(nd log n).

Двоичный поиск

Стандартный алгоритм, основанный на методе «разделяй и властвуй», –– алгоритм двоичного поиска: для нахождения элемента k в отсортированном массиве элементов z[0, 1, ‌, n 1] мы сперва сравниваем k с z[n=2] и в зависимости от результата рекурсивно вызываем алгоритм либо для первой части z[0, 1, ‌, n=2 1], либо для второй части z[n=2, ‌, n 1]. Рекур-

Воспользовавшись доказанной выше теоремой при a = 1, b = 2, d = 0, получаем, что T (n) = O(log n).

2.3. Сортировка слиянием

Метод «разделяй и властвуй» можно применить для сортировки массива: разделим массив на две части, рекурсивно отсортируем каждую из них, после чего сольём (merge) отсортированные части.

функция MergeSort(a[1‌n])

{Вход: массив чисел a[1‌n].} {Выход: отсортированный массив.}

DRAFTесли n > 1:Merge(MergeSort(a[1‌dn=2e]), MergeSort(a[dn=2e+1‌n]))

вернуть

иначе: вернуть a

Корректность этого алгоритма очевидна (если, конечно, мы правильно запрограммировали слияние). Как же слить два отсортированных массива x[1‌k] и y[1‌l] в один массив z[1‌k + l]? Ясно, что первым элементом массива z будет меньшее из чисел x[1] и y[1]. Оставшаяся часть z может

быть заполнена рекурсивно.

функция Merge(x[1‌k], y[1‌l])

если k = 0: вернуть y[1‌l] если l = 0: вернуть x[1‌k]

если x[1] ¶ y[1]:

вернуть x[1] Merge(x[2‌k], y[1‌l])

иначе:

вернуть y[1] Merge(x[1‌k], y[2‌l])

Через мы обозначаем конкатенацию массивов (приписывание их друг к другу). Алгоритм Merge тратит время O(1) на каждый рекурсивный вызов (если он реализован аккуратно и не копирует элементы массивов без надобности). Общее время его работы O(k + l), то есть линейное. Отсюда получаем рекуррентное соотношение для времени сортировки слиянием n элементов:

T (n) = 2T 2n + O(n),

а значит, T (n) = O(n log n).

Куда уходит это время? В основном на слияние массивов, которое начинается с массивов единичного размера. Они сливаются в массивы размера 2, которые потом сливаются в массивы размера 4 и так далее. Пример работы алгоритма приведён на рис. 2.4.

Имея это в виду, напишем нерекурсивную версию алгоритма MergeSort. В каждый момент будем поддерживать множество «активных» массивов (упорядоченных кусков исходного; изначально куски состоят из одного элемента), которые попарно сливаются и образуют следующее множество активных массивов. Массивы можно хранить в очереди, из начала которой мы будем извлекать два массива, сливать их и помещать полученный массив в конец очереди. Вот что при этом получается (операция Inject добавляет элемент в конец очереди, а операция Eject извлекает элемент из

Рис. 2.4. Вызовы процедуры Merge в алгоритме MergeSort.

начала очереди):

функция IterativeMergeSort(a[1‌n])

{Вход: массив чисел a[1‌n].} {Выход: отсортированный массив.}

Q [ ] {пустая очередь}

для i от 1 до n:

Inject(Q, [ai ])

пока jQj > 1:

Inject(Q, Merge(Eject(Q), Eject(Q)))

вернуть Eject(Q)

Нижняя оценка n log n для сортировки

Работу алгоритма сортировки можно изобразить в виде дерева. Например, алгоритм на рисунке сортирует по возрастанию массив из трёх элементов a1, a2, a3. Первым делом он сравнивает a1 с a2. Если a1 не меньше a2, он сравнивает его с a3, в противном же случае сравнивает a2 с a3 и так далее. В конце концов мы приходим в лист, где уже известен правильный порядок трёх элементов (как перестановка чисел 1, 2, 3). Например, если

56 Глава 2. Метод «разделяй и властвуй»

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

Глубина (depth) данного дерева, то есть количество сравнений на самом длинном пути от корня к листу (в примере глубина равна 3), является нижней оценкой времени работы алгоритма в худшем случае.

Рассматривая алгоритмы сортировки такого типа, можно показать, что

DRAFTтребует (n log n) сравнений в худшем случае, а значит, алгоритм сортировки слиянием оптимален.

алгоритм сортировки слиянием оптимален: для сортировки n элементов

в худшем случае требуется (n log n) сравнений.

В самом деле, рассмотрим дерево сортировки n элементов. Каждый его лист помечен перестановкой множества f1, 2, ‌, ng. Более того, нетрудно видеть, что для каждой перестановки должен найтись такой лист (поскольку соответствующая перестановка может быть подана на вход). Значит, у

рассматриваемого нами дерева есть хотя бы n! листьев.

У двоичного дерева глубины d может быть не более 2d листьев. Таким образом, глубина дерева (и сложность нашего алгоритма) не меньше log(n!).

Известно, что log(n!) ¾ c n log n для некоторой константы c > 0.

Есть несколько способов это доказать. Самый простой –– заметить, что n! ¾ (n=2)(n=2), поскольку в произведении 1 2 ‌ n есть хотя бы n=2 множителей, не меньших n=2, и взять логарифм обеих частей неравенства.

Тонкость в данном рассуждении заключается в том, что оно применимо только к алгоритмам сортировки сравнениями (такой алгоритм может сравнивать числа и их копировать, но никак не использует их внутреннюю структуру). Может быть, существуют алгоритмы, более хитро обращающиеся с числами и имеющие линейное время работы? Да, существуют: стандартный пример –– сортировка чисел из небольшого по размеру диапазона (упражнение 2.20).

2.4. Медианы

Медианой (median) массива чисел называют число, которое будет стоять посередине, если массив отсортировать по возрастанию (неубыванию). Например, медианой массива [45, 1, 10, 30, 25] является число 25. Если массив имеет чётную длину, то есть две позиции, которые можно назвать средними; договоримся в такой ситуации выбирать меньшую из них (левую).

Медиана, как и среднее арифметическое, даёт некоторое представление о всём массиве чисел, но это разные вещи. Например, и медиана, и среднее значение массива из ста единиц равны 1. Однако если заменить одну из единиц на число 10000, то среднее станет больше 100, а медиана не изменится.

Ещё можно отметить, что медиана всегда будет элементом массива, в отличие от среднего.

Найти медиану n чисел можно с помощью сортировки. Однако это требует времени (n log n). Нет ли линейного алгоритма? Ведь сортировка делает много лишнего: нам нужен только средний элемент.

Оказывается, что такой алгоритм есть, и мы его построим. Для начала отметим, что при построении рекурсивного алгоритма часто помогает переход к более общей (и тем самым более трудной!) задаче. Дело в том, что обобще-

ние позволяет использовать более сильное предположение индукции.

DRAFTрекурсивно вызвать алгоритм для одной из частей SL или SR: мы переходим от массива размера jSj к массиву размера maxfjSL j, jSRjg.

В нашем случае вместо нахождения медианы мы рассмотрим задачу нахождения k-го по величине элемента. В ней дан массив чисел S и число k; надо найти элемент, который будет стоять на k-м месте, если отсортировать элементы S по возрастанию. Например, при k = 1 ищется минимум, а при

k = bjSj=2c –– медиана.

2.4.1. Вероятностный алгоритм

Мы рассмотрим вероятностный алгоритм поиска k-го по величине элемента, основанный на методе «разделяй и властвуй».

Пусть v –– элемент массива S. Разобьём S на три части: элементы, мень-

Поиск нужного элемента в исходном массиве легко может быть сведён к поиску в одной из трёх частей. Например, восьмой по величине элемент S –– это третий по величине элемент SR, поскольку jSL j + jSv j = 5. В общем случае достаточно сравнить k с размерами частей, чтобы понять, в какой из частей находится нужный нам элемент:

Как выбирать v? Это надо делать быстро; в то же время хотелось бы, чтобы размер массива быстро уменьшался. В идеале массив уменьшается вдвое: jSL j, jSRj jSj=2. Если бы мы могли гарантировать такое уменьшение, то для времени работы получили бы соотношение

T (n) = T 2n + O(n),

60 Глава 2. Метод «разделяй и властвуй»

Умножение матриц не коммутативно (X Y и Y X могут различаться), но ассоциативно: (X Y )Z = X (Y Z).

«Наивный» алгоритм, основанный на этой формуле, вычисляет произве-

дение за O(n3) операций: на каждое из O(n2) значений требуется O(n) операций. Довольно долго наивный алгоритм казался асимптотически оптимальным; было даже доказано, что в некоторых моделях вычислений не существует более быстрых алгоритмов. Поэтому более эффективный алгоритм, предложенный немецким математиком Фолькером Штрассеном в 1969 году, оказался неожиданным. Он использует метод «разделяй и властвуй».1

DRAFTТеперь для времени работы получаем соотношение T (n) = 7T (n=2) + O(n2),

Задачу умножения матриц достаточно легко разбить на подзадачи, поскольку произведение можно составлять из блоков. Разобьём каждую из мат-

риц X и Y на четыре блока размера 2n 2n :

A B E F

X = C D , Y = G H .

Тогда их произведение выражается в терминах этих блоков по обычной формуле умножения матриц (упражнение 2.11):

Вычислив рекурсивно восемь произведений AE, BG, AF, BH, C E, DG, C F, DH и просуммировав их за время O(n2), мы вычислим необходимое нам произведение матриц. Соответствующее рекуррентное соотношение на время работы алгоритма,

Однако его можно ускорить с помощью алгебраического трюка: для вычисления произведения X Y достаточно перемножить семь пар матриц размера 2n 2n , после чего хитрым образом (и как только Штрассен догадался?) полу-

чить ответ:

так что T (n) = O(nlog2 7) O(n2,81).

1На практике данный алгоритм даёт выигрыш только при достаточно больших´ n. Асимптотически и он не оптимален; лучшую оценку O(n2,37‌) даёт алгоритм Копперсмита––Винограда и его модификации. Более того, некоторые предполагают, что произведение матриц может быть

вычислено за время O(n2+o(1)). –– Прим. перев.