1. Алгоритм Дейкстры

n=0; c=a; s_c=TRUE; l_c=0; back_c=NULL //Q₀={(a,0, true,NULL)}

Вечный цикл

Для всех вершин v, смежных с

Если s_c==FALSE и (l_v==+INF или l_c+|(c,v)|< l_v) то

l_v = l_c+|(c,v)|; back_v=c

l=+INF

Для всех вершин графа v

Если s_c==FALSE и l_v< l то l = l_v; z=v

Если l==+INF то ВЫЙТИ// в графе не осталось элементов

Если z==b то ВЫЙТИ // дошли до конца пути

s_z=TRUE; c= z // Q_n+1= Q_n  {(z,l,true)}

2. Конец вечного цикла

Если после завершения первой части алгоритма l==+INF , то это означает, что от a до b дойти по ребрам невозможно. Иначе, мы можем по ссылкам back_w добраться от b до a.

Проанализировав алгоритм для случая планарных графов без кратных ребер и петель, мы сможем заметить, что его можно улучшить. Действительно, при коррекции l_v для каждой вершины перебираются все смежные ребра и это происходит ровно один раз. Поэтому суммарное количество операций по коррекции l_v не превосходит O(q), где – q количество ребер, а для рассматриваемого случая O(q)= O(p), где – q количество вершин графа.

Допустим, что мы сможем создать структуру данных, содержащую вещественные числа, в которую можно добавлять элементы, удалять из нее минимальный элемент, искать минимум элементов, модифицировать положение элемента при изменении его значения, причем каждая из этих операций должна выполняться за время O(log N), где – N количество элементов, занесенных в данную структуру. Назовем множество, реализованное с помощью указанной структуры данных, P.

На каждом шаге вышеописанного алгоритма мы можем хранить в множестве P ссылки на все элементы, содержащие вершины, смежные с вершинами очередного Q_n, которые сами в Q_n не содержатся. Заметим, что именно среди этих элементов происходит коррекция l_v и поиск минимально l_v. На каждом шаге алгоритма Дейкстры мы должны сначала добавить в P ссылки на все элементы, смежные c, при изменении значений l_v модифицировать положение соответствующих элементов, а в конце извлечь из P ссылку на элемент с минимальным значением l_v. Т.о. алгоритм придет к следующему виду

3. Алгоритм Дейкстры модифицированный

n=0; c=a; s_c=TRUE; l_c=0; back_c=NULL //Q₀={(a,0, true,NULL)}

P={ }

Вечный цикл

Для всех вершин v, смежных с

Если s_c==FALSE и l_v==+INF то

Добавить ссылку на v в P

Если P пусто то l_z =+INF; ВЫЙТИ// в графе не осталось элементов

Для всех вершин v, смежных с

Если s_c==FALSE и (l_v==+INF или l_c+|(c,v)|< l_v) то

l_v = l_c+|(c,v)|; back_v=c;

Скорректировать положение ссылки на v в P

Извлечь из P ссылку на минимальный элемент и

поместить минимальный элемент в z

l = l_z

Если z==b то ВЫЙТИ // дошли до конца пути

s_z=TRUE; c= z // Q_n+1= Q_n  {(z,l,true)}

4. Конец вечного цикла

Осталось заметить, что для корректировки положения ссылки на v в P нам еще необходимо уметь находить эту ссылку на v в P, поэтому в каждом элементе исходного множества v еще придется хранить ссылку на ссылку на v в P. Т.о. при всех перемещениях элементов в P ссылки на эти элементы в исходном множестве придется модифицировать.

Итак для случая планарных графов без кратных ребер и петель, в каждом переборе смежных вершин на протяжении всего алгоритма каждое ребро встречается только два раза, поэтому суммарное время работы первого цикла Для всех… равно O(p log p), суммарное время работы второго цикла Для всех… имеет такую же ассимптотику. Наконец, извлечение из P ссылки на минимальный элемент выполняется за время O(log p), а т.к. таких элементов O(p), то суммарное время этих извлечений = O(p log p). Таким образом, доказана следующая

Теорема 1. Для случая планарных графов без кратных ребер и петель алгоритм Дейкстры работает за время O(p²), а модифицированный алгоритм Дейкстры работает за время O(p log p), где p – количество вершин в графе.

До сих пор мы не предъявили реализации структуры данных, содержащей вещественные числа, такой, что она должна уметь выполнять следующие операции:

• добавлять элемент,

• удалять минимальный элемент,

• искать минимум элементов,

• модифицировать положение элемента при изменении его значения,

причем каждая из этих операций должна выполняться за время O(log N), где – N количество элементов, занесенных в данную структуру.

В качестве подобной структуры данных может выступать пирамида, определенная для сортировки Heapsort. При ее определении мы требовали, чтобы в ее вершине лежал максимальный элемент (исходя из того, что A_[i/2]  A_i ). Мы можем не менять определения пирамиды, потребовав, чтобы в нее заносились исходные элементы, умноженные на –1, в таком случае в вершине будет храниться минимальный элемент исходного множества (умноженный на –1).

Удалять максимальный элемент из пирамиды за время O(log N) мы научились в алгоритме Heapsort. Находить максимальный элемент за время O(1) можно элементарно – он лежит в первом элементе массива пирамиды. Осталось научиться вставлять новый элемент в пирамиду и корректировать его положение при изменении значения.

Добавление элемента

Пусть дан пирамидально-упорядоченный массив A_i, (i=1,…,N). Требуется добавить к нему еще один элемент A_i+1 и переупорядочить массив. Для этого введем текущий номер элемента в массиве k. В начальный момент положим k= N+1.

Свойство пирамидально-упорядоченности выполняется для всех соответствующих пар элементов, кроме, быть может, пары (k,k/2). Если для этой пары свойство A_[k/2]  A_k выполняется, то массив пирамидально упорядочен и ничего больше делать не надо. Иначе поменяем местами пару элементов с индексами k и k/2. При этом элемент с индексом k/2 не уменьшится, поэтому поддерево, с него начинающееся, но идущее по другой ветке, чем (k,k/2) останется пирамидально-упорядоченным (т.е., например для четного k, останется верным A_[k/2]  A_k+1).

Перед обменом местами элементов с индексами (k,k/2), элемент A_[k/2] был не меньше всех элементов в поддереве, начинающегося с A_[k/2], кроме, быть может, A_k. Поэтому, после обмена местами элементов с индексами (k,k/2), элемент A_k будет не меньше всех элементов в поддереве, начинающегося с A_k. Осталось присвоить k=[k/2], и выполнить те же самые действия для нового k.

Таким образом, мы произведем не более [log N]+1 обменов местами соседних элементов, из чего следует, что процедура добавления элемента в пирамиду может быть произведена за время O(log N).

Корректировка положения элемента

Пусть дан пирамидально-упорядоченный массив A_i, (i=1,…,N). Для текущего элемента в массиве с номером k изменим значение элемента A_k. Требуется переупорядочить массив.

Если A_k A_2k и A_k A_2k+1, то задача полностью сводится к предыдущей.

Пусть, для определенности, A_k< A_2k. Но тогда A_[k/2]  A_k (т.к. A_[k/2]  A_2k> A_k), из чего получаем, что все элементы из поддерева, начинающегося с k-го элемента массива не превосходят A_[k/2] . В этом случае возможно применить процедуру Heapify(A,k,N). Время ее работы O(log N).

