Общий подход к решению задач на графах коллективом автоматов Текст научной статьи по специальности «Математика»

Общий подход к решению задач на графах коллективом автоматов

И.Б. Бурдонов <[email protected]> A.C. Косачее <ко[email protected]> Институт системного программирования РАН, 109004, Россия, г. Москва, ул. А. Солженицына, д. 25

Аннотация. Предложен общий подход к решению задач на неориентированном упорядоченном корневом связном графе коллективом автоматов, расположенных в вершинах графа и обменивающихся сообщениями по рёбрам графа. Автоматы считаются полуроботами, т.е. размер их памяти может расти вместе с ростом числа п вершин и числа т рёбер графа, но описание графа может не помещаться в памяти автомата. В разделе 2 классифицируются модели коллектива автоматов на графе в зависимости от размера памяти автомата, времени срабатывания автомата и ёмкости ребра (числа сообщений, одновременно перемещающихся по ребру). Выбрана модель максимального распараллеливания, в которой время срабатывания автомата считается нулевым, а ёмкость ребра неограниченной. Это позволяет получать нижние оценки сложности алгоритмов решения задач. Раздел 3 определяет правила оценки алгоритмов. В разделе 4 описаны базовые процедуры обработки сообщений и проводится классификация используемых сообщений в зависимости от маршрутов, проходимых сообщениями, и способа размножения или слияния сообщений. На основе этих процедур предлагается строить алгоритмы решения задач на графах, что демонстрируется в следующих разделах статьи. В разделах 5-9 предложены алгоритм построения остова графа, алгоритм универсального «стопора», определяющего конец работы любого алгоритма по отсутствию в графе сообщений, используемых этим алгоритмом, алгоритм построения дерева кратчайших путей, алгоритм нумерации вершин графа, и алгоритм сбора полуроботами информации о графе в неограниченной памяти автомата корня. Предложенные алгоритмы имеют линейную сложность от и и »г, и используют число сообщений, линейно зависящее от и и »г. В разделе 10 рассматривается задача поиска максимального пути в нумерованном графе, которая относится к классу NP. За счёт неограниченного (экспоненциального) числа сообщений алгоритм решения этой задачи имеет линейную сложность. В заключении подводятся итоги и намечаются направления дальнейших исследований: решение других задач на графах и расширение подхода на ориентированные графы, а также недетерминированные и динамические графы.

Ключевые слова: неориентированные графы; задачи на графах; асинхронные распределённые системы; распределенные алгоритмы.

DOI: 10.15514/ISPRAS-2017-29(2)-2

Для цитирования: Бурдонов И.Б., Косачев A.C. Общий подход к решению задач на графах коллективом автоматов. Труды ИСП РАН, vol. 29, issue 2, 2017, рр.27-76. DOI: 10.15514Л SPRAS-2017-29(2)-2

1. Введение

Необходимость в решении различных задач на графах возникает во многих приложениях: в информатике и программировании, в коммуникационных и транспортных системах, схемотехнике, экономике, логистике, физике, химии и др. Примером таких задач могут служить задачи поиска максимального пути в графе, построение минимального остовного дерева во взвешенном графе, построение максимального независимого множества вершин, определение всех мостов в неориентированном графе, проверка наличия эйлерового пути или цикла, проверка наличия гамильтонового пути или цикла и построение их, проверка планарности графа и раскраска планарного графа, построение наибольшего ациклического подграфа ориентированного графа и др. В мировой литературе, как в теоретическом, так и в практическом планах описано много различных алгоритмов решения актуальных задач на графах с оценками времени работы в зависимости от числа вершин, рёбер и других параметров графа. Однако в большинстве своём эти алгоритмы имеют большую вычислительную сложность, поэтому в последние годы растёт интерес к параллельным и распределённым компьютерным алгоритмам. Такие алгоритмы позволяют существенно уменьшить время решения задач и требуют меньше памяти в каяедом из используемых компьютеров. Известные и апробированные алгоритмы часто плохо распараллеливаются или возможность такого распараллеливания требует дополнительных исследований. В первом случае необходим поиск новых алгоритмов, а во втором случае - адаптация имеющихся алгоритмов.

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

Для того чтобы из вершины по инцидентному ей ребру (выходящему ребру в ориентированном графе) мог перемещаться автомат или сообщение, автомат в вершине должен это ребро указать. Для этого предполагается, что в неориентированном графе все рёбра, инцидентные вершине, а в ориентированном графе все рёбра, выходящие из вершины, перенумерованы. При перемещении по ребру указывается его номер. В ориентированном графе ребро имеет только один номер - в той вершине, из которой оно выходит, а в неориентированном графе ребро имеет два номера - по одному в каждой инцидентной ему вершине. Такой граф с нумерацией рёбер называется упорядоченным. В дальнейшем предполагается, что граф упорядочен. Мы будем считать, что в графе выделена одна вершина, эту вершину будем называть корнем графа, а граф - корневым. С корня и начинается решение той или иной задачи на графе: автомат, находящийся в корне, получает извне графа (по «фиктивному» ребру, входящему в корень) сообщение, инициирующее решение задачи. После окончания решения задачи автомат корня также вовне (по «фиктивному» ребру, выходящему из корня) посылает сообщение с «ответом». Для того чтобы коллектив автоматов мог решать задачу на всём графе, такой граф, очевидно, должен быть связным.

Ранее мы изучали задачу обхода графа коллективом автоматов, когда должно быть пройдено каждое ребро графа: каким-нибудь автоматом в первой метамодели ([1],[2],[3],[4],[5]) или каким-нибудь сообщением во второй метамодели ([6],[7],[8],[9],[10],[11]). Для второй метамодели также решалась задача вычисления функции от мультимножества значений, записанных в вершинах графа ([7],[8],[10],[11]). Данная статья открывает серию статей, посвящённых решению коллективом автоматов других задач на графах, которые не сводятся к обходу графа, хотя могут использовать алгоритмы обхода. Мы будем исходить из второй метамодели: автоматы неподвижно «сидят» в вершинах графа, а сообщения пересылаются по рёбрам графа. Распределённая система предполагается асинхронной. Это означает, что время перемещения сообщения по ребру может быть разным как для разных рёбер, так и в разные моменты времени для одного и того же ребра. Будем считать, чтоб время перемещения сообщения по ребру ограничено сверху. Методы решения задач на графах коллективом автоматов существенно зависят от 1) типа графа, 2) типа автоматов, 3) типа решаемой задачи. Граф может быть неориентированным, ориентированным и смешанным. В неориентированном графе предполагается использовать возможность посылки ответного сообщения по тому же ребру, по которому было получено прямое сообщение. Это позволяет существенно уменьшить время решения задачи. Этот же способ можно использовать в смешанном графе для его неориентированных рёбер. В ориентированном графе для ответного сообщения приходится искать обратный путь из конца ребра в его начало. Для этого могут использоваться прямой (ориентированный от корня) и обратный (ориентированный к корню) остовы графа ([6],[7],[8],[10],[11]).

Граф может быть детерминированным или недетерминированным. В недетерминированном графе несколько рёбер, выходящих из одной вершины, могут иметь один номер; множество таких рёбер называется дельта-ребром. При посылке сообщения выбор ребра из дельта-ребра с данным номером выполняется недетерминированным образом. Для того чтобы гарантировать возможность решения задачи на недетерминированном графе приходится налагать те или иные ограничения на недетерминизм графа (для первой метамодели см. [3],[5]). Примером такого ограничения может служить справедливый недетерминизм, гарантирующий передачу сообщения по данному ребру из данного дельта-ребра после конечного (не обязательно ограниченного) числа попыток.

Другой подход к обходу недетерминированного графа - это изменение самой цели обхода: вместо того, чтобы проходить по всем рёбрам, требуется пройти по всем дельта-рёбрам, то есть хотя бы по одному ребру в каждом дельта-ребре [12]. Это имеет практический смысл при тестировании программной реализации модели системы: в каждом состоянии системы мы пробуем подать на неё каждое тестовое воздействие хотя бы по одному разу. Если граф ориентирован, то для обхода всех его дельта-рёбер требуется дельта-связность графа (в ориентированном графе сильно-дельта-связность [12]). В частности, достаточно наличия в графе детерминированного остова (в ориентированном графе два остова: ориентированный от корня и ориентированный к корню). Также граф может быть динамически меняющимся: его ребро может исчезать, появляться или менять один из своих концов. Для решения задач на динамическом графе приходится использовать какие-то ограничения на «скорость» изменения рёбер, чтобы гарантировать доставку сообщений в нужные вершины. Например, некоторые рёбра «долгоживущие», т.е. такое ребро не меняется в течение времени, которое достаточно для передачи по нему хотя бы одного сообщения ([9],[10],[11]).

Кроме этого, существенной характеристикой графа является наличие или отсутствие нумерации его вершин. Граф нумерованный, если все его вершины помечены различными идентификаторами, в частности, пронумерованы целыми числами 0, 1, 2,... Нумерация графа даёт возможность различать вершины графа по их номерам, что существенно влияет на алгоритмы решения задач на графе. Во многих случаях для решения задачи полезно сначала выполнить нумерацию графа с помощью подходящего алгоритма, а уже потом решать задачу на нумерованном графе.

Специфической характеристикой асинхронной распределённой системы является ёмкость ребра - максимальное число сообщений, одновременно передаваемых по ребру, или их суммарный размер.

Автоматы характеризуются размером памяти и временем срабатывания. По размеру памяти автоматы делятся на роботы, полуроботы и неограниченные автоматы в зависимости от размера их памяти, который определяется числом состояний, входных и выходных символов. Роботы - это конечные автоматы,

память которых ограничена и не зависит от размера графа. Память неограниченного автомата зависит от размера графа и достаточно велика, чтобы в ней могло размещаться описание всего графа. Память полуробота тоже растёт вместе с ростом размера графа, однако описание графа может не помещаться в память одного автомата, хотя обычно предполагается, что это описание помещается в суммарную память коллектива автоматов. В [13] доказано, что для неориентированных упорядоченных корневых графов «граница» между неограниченным автоматом и полуроботом - это память размером ®(mlogn) для нумерованных графов и ®{{m-n+\)logn+n) для ненумерованных графов, где да - число рёбер, а п - число вершин графа. Поскольку (m-n+\)logn+n < mlogn при п > 3. для того чтобы автомат был полуроботом на классах нумерованных и ненумерованных графов, достаточно, чтобы память автомата имела размер o{{m-n+\)logn+n). В частности, 0(nlognm) = o{{m-n+\)logn+n) для фиксированного (но произвольного) п> 1 и да—>оо. Заметим, что полуробот на классе графов может быть неограниченным автоматом на подклассе. Тривиальный пример - автомат с памятью ®(nlognm) на подклассе деревьев, где да = п-1 и поэтому (m-n+\)logn+n = п = o(nlognm). Для ориентированных графов нужны дополнительные исследования, чтобы определить «границу» между неограниченными автоматами и полуроботами. Время срабатывания автомата - это время, за которое автомат принимает одно или несколько сообщений, изменяет своё состояние и посылает одно или несколько сообщений. В асинхронных системах обычно не учитывают время срабатывания автомата, измеряя сложность алгоритма временем перемещения сообщений. Важно также, ограничено или нет число сообщений, которые автомат принимает и/или посылает за одно срабатывание. Понятно, что как сама возможность решения задачи на графе, так и оценка требуемых для этого ресурсов (время, память и число сообщений) зависят от типа автоматов.

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

методов решения этих задач с целью выработки общей методологии и базового набора распределённых алгоритмов решения типовых подзадач. В данной статье мы ограничиваемся случаем неориентированных детерминированных статических графов.

В разделе 2 формально определяется вторая метамодель коллектива автоматов на графе, и обсуждаются различные модели в рамках этой метамодели в зависимости от размера памяти автомата, времени срабатывания и ёмкости рёбер. Выбирается модель с максимальным параллелизмом для полуроботов, которая используется в дальнейшем. Раздел 3 посвящён правилам оценки предлагаемых далее алгоритмов как функции от числа вершин и рёбер графа. В разделе 4 предложены базовые процедуры обработки сообщений, и дана классификация используемых сообщений в зависимости от маршрутов, проходимых сообщениями, и способа размножения или слияния сообщений. Вводимые здесь классы сообщений используются в предлагаемых далее распределённых алгоритмах. В разделе 5 описаны алгоритмы построения остова графа. В разделе 6 предложен алгоритм универсального «стопора», определяющего конец работы любого алгоритма по отсутствию в графе сообщений, используемых этим алгоритмом, а также процедура очистки графа от сообщений указанных типов. В разделе 7 представлен алгоритм построения дерева кратчайших путей. В разделе 8 описаны алгоритмы нумерации графа. В разделе 9 предлагается алгоритм сбора информации о графе в памяти неограниченного автомата корня, автоматы остальных вершин - полуроботы. Раздел 10 посвящён задаче поиска максимального пути в нумерованном графе, относящейся к классу ЫР. В заключении подводятся итоги и намечаются направления дальнейших исследований.

2. Классификация моделей и выбор модели

Как сказано во введении, в данной статье используется вторая метамодель асинхронной распределённой системы: автоматы «привязаны» к вершинам графа, а сообщения посылаются по рёбрам графа. Сообщение понимается как набор параметров сообщения, а состояние автомата - как набор значений переменных. Допуская вольность речи, мы будем часто для краткости говорить «вершина» вместо «автомат вершины».

Граф неориентированный, статический, упорядоченный, детерминированный, корневой и связный. Обозначения: п - число вершин графа, т - число рёбер графа, Р) - длина максимального пути в графе, !)<, - длина максимального пути от корня, ¿/-диаметр графа, т.е. максимальное расстояние между вершинами, где расстояние между вершинами - это длина кратчайшего пути между вершинами, (¡о - эксцентриситет корня, т.е. максимальное расстояние от корня до вершины, Д - максимальная степень вершины.

Очевидно, п<т +1, ё0<(1<2¿о, £>0<£><2£>0, й?0<А), й<Б<п-1 и Д<2т. Различие между п. с/ и I) демонстрируют граф-звезда £„-1, в котором с! = /) = 2

при /? > 2, и полный граф К1Ь в котором d = 1 и I) = п-1. При d= 0 граф состоит из одной вершины с петлями, поэтому п= 1 и I) = 0. При с! = 1 любые две различные вершины связаны ребром, поэтому D = п-1. Для любых d, D и ;?, удовлетворяющих условию 2 <d<D< п-1, существует граф с параметрами rf, Вии (см. Рис. 1). В графе без кратных рёбер и петель т < п(п-1)/2 и А < п-1.

Рис. 1. Граф с п вершинами, диаметром d>\ и длиной D максимального пути.

Fig. 1. A graph with п vertices, diameter d >1, and length D of the maximal path.

Ребро графа будет пониматься как дуплексный канал передачи сообщений. При этом сообщения, перемещаемые по ребру в одном направлении, не генерируются самим ребром, не искажаются, не пропадают и не обгоняют друг друга. Иными словами, ребру ab соответствуют две очереди сообщений: посланных по этому ребру вершиной я, но ещё не принятых с него вершиной />. и, наоборот, посланных вершиной />. но ещё не принятых вершиной а. Будем исходить из следующих предположений: 1) время перемещения сообщения по ребру ограничено сверху 1 тактом, 2) время срабатывания (автомата) вершины ограничено сверху 1 тактом, 3) за одно срабатывание вершина принимает не более одного сообщения и посылает не более одного сообщения. Третье предположение нуждается в пояснении. Сообщение может быть принято, если оно «дошло» по ребру до вершины, т.е. истекло время перемещения этого сообщения по ребру. Однако, поскольку сообщения, перемещаемые по ребру из вершины а в вершину />. образуют очередь, вершина b может принять только сообщение из головы этой очереди. Если есть несколько рёбер, по которым вершина может принять сообщения, то выбирается одно из них недетерминированным образом. Вместе с принимаемым сообщением вершина получает номер ребра, по которому это сообщение принимается. Если нет сообщений, которые вершина могла бы принять, она получает фиктивное пустое сообщение е с нулевым номером ребра (рёбра в вершине нумеруются, начиная с 1). Если вершина не посылает сообщение, то указывается пустое сообщение е с нулевым номером ребра. Предполагается, что вершина «знает» (или может «узнать») свою степень, которая в дальнейшем хранится в переменной вершины. В некоторых алгоритмах граф предполагается нумерованным: его вершинам приписаны уникальные идентификаторы, в частности числа от 0 до п-1. Если граф

d вершин

D-d+1 вершин

нумерованный, то предполагается, что вершина «знает» (или может «узнать») свой номер. Если граф ненумерованный, его можно пронумеровать, используя алгоритм нумерации из раздела 8. В любом случае будем предполагать, что для нумерованного графа номер вершины хранится в переменной вершины. Ёмкостью ребра будем называть максимальное число сообщений, которые могут одновременно находиться на ребре (посланы, но не приняты) в одном направлении. Если ребро ab имеет ограниченную ёмкость к ив направлении от вершины а к вершине b по нему перемещается к сообщений, то вершина а не может посылать сообщение по ребру ab до тех пор, пока вершина b не примет с ребра хотя бы одно сообщение. Для того чтобы вершина смогла «узнать», можно или нельзя посылать по ребру сообщение, при ограниченной ёмкости ребра нужен сигнал «освобождение ребра» ф с параметром «номер ребра». Если ёмкость ребра неограниченная, сообщение по ребру всегда можно посылать, и такого сигнала не требуется.

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

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

Если ёмкость ребра ограничена числом к, то это может приводить к тому, что вершина, инцидентная ребру, не может посылать сообщения по нему, если ребро полностью занято (на нём уже находится к сообщений), пока ребро не освободится. Поэтому при оценке времени работы нужно учитывать такие задержки в пересылке сообщений, и оценка становится достаточно сложной (в качестве примера, можно посмотреть оценку времени работы алгоритма в [8]). Табл. 1. Классификация моделей Tab. 1. Classification of models

Модель Полный размер автомата Время срабатывания Ёмкость ребра

1 неограниченный автомат >0 не ограничена

2 неограниченный автомат = 0 ограничена

3 неограниченный автомат >0 ограничена

4 неограниченный автомат = 0 не ограничена

РАН, том. 29, вып. 2, 2017 г., pp.27-76.

5 робот >0 не ограничена

6 робот = 0 ограничена

7 робот >0 ограничена

8 робот = 0 не ограничена

9 полуробот >0 не ограничена

10 полуробот = 0 ограничена

11 полуробот >0 ограничена

12 полуробот = 0 не ограничена

Формально, автомат в вершине - это набор (Mes,S,Tr,so), где Mes - множество всех непустых сообщений, которые автомат может принимать или посылать, S - множество состояний, Тг - множество переходов, .vu - начальное состояние. Переход имеет вид s—(i,x),(J,y)^>-s\ s—(/,х),(0,е)—»s1, s—(i,i?),(j,y)^>s\ s—(/,ф),(0,е)—»s', s—(0,6),(j,y)^s\ или s—(0,e),(0,6)—где seS - состояние, в котором выполняется переход, е - пустое сообщение, ф - сигнал «освобождение ребра», / - номер ребра, по которому принимается непустое сообщение или сигнал ф, хеMes - принимаемое сообщение, / - номер ребра, по которому посылается непустое сообщение, yeMes - посылаемое сообщение, .v ' е S -состояние, в которое автомат переходит.

Если полный размер автомата ограничен (робот или полуробот) и ёмкость ребра тоже ограниченная, то возможны состояния, где вершина не принимает сообщений, поскольку не может послать сообщения. Вершина ожидает только сигналов освобождения рёбер, т.е. в таких состояниях определены только переходы вида s—(/,ф),(/,>>)—»s1 или s—(/,ф),(0,е)—В остальных состояниях вершина v принимает любое сообщение, т.е. её автомат «всюду определён по приёму сообщений»: в каждом таком состоянии определены переходы по всем возможным парам (i,x), (г,ф), (0,е), где /= 1 ..Л,-. xeMes и Д,- - степень вершины v.

2.1. Неограниченный автомат

Случай неограниченного автомата (модели 1-4) не очень интересен: решение любой задачи можно свести к следующей процедуре. Сначала информация о графе собирается в корне графа, а затем автомат корня решает задачу. В разделе 9 мы опишем алгоритм выполнения процедуры сбора информации.

2.2. Робот

В литературе имеется ряд работ по обходу графа роботом. Для неориентированного графа известен алгоритм Тэрри, основанный на обходе в глубину (DFS), с оценкой времени работы 2т, и алгоритм, основанный на обходе в ширину (BFS), с оценкой т+0(п2) ([14]). Для ориентированного графа наилучшая полученная оценка равна 0(nm+n2loglogn) или, выражая через Do, O(D0m+D(/iloglogn) ([14],[15]). При повторном обходе графа, когда автоматы могут использовать результаты первого обхода, оценка 0(nm+n2log*n) или

35

()(!), ,m+f.)i л log* it). где log* - итерированный логарифм (число логарифмирований, после которых результат меньше или равен 1) [16]. Если имеются два робота, передвигающихся по графу и обменивающихся между собой сообщениями по дополнительной сети связи (первая метамодель), то время обхода уменьшается до минимального по порядку 0(пт) или, выражая через Do, 0(Dm) ([14]).

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

2.3. Полуробот

Как и в общем случае, для полуроботов ненулевое время срабатывания и/или ограниченная ёмкость ребра приводят к задержкам в пересылке сообщений, что усложняет оценку времени работы алгоритмов. Но в случае полуроботов (как и роботов) ограниченная ёмкость ребра может также приводить к тупику (deadlock). Дело в том, что, если ребро полностью заполнено, и вершина не может по нему послать сообщение, то, поскольку полный размер автомата ограничен (хотя и зависит от размера графа для полуробота), может оказаться, что вершина приостановит приём сообщений. На цикле в графе может возникнуть тупик, когда каждая вершина цикла «хочет» послать сообщение по «выходящему» ребру цикла, но не может этого сделать, и поэтому не принимает сообщение по «входящему» ребру цикла. Алгоритмы решения задач на графе должны учитывать возможность тупика и не допускать тупика, что, конечно, налагает дополнительные требования к построению алгоритмов.

2.4. Выбор модели

Для серии статей, открываемой данной статьёй, мы выбираем модель 12: ёмкость ребра неограниченная, автомат - полуробот с нулевым временем срабатывания. Время перемещения сообщения по ребру ограничено сверху 1 тактом. Такая модель даёт возможность максимального распараллеливания, поскольку не возникает задержек и тупиков из-за ограниченной ёмкости ребра или ненулевого времени срабатывания. Тем самым, будет учитываться только время перемещения сообщений по рёбрам. Оценки сложности алгоритмов решения задач в такой модели являются нижними границами сложности аналогичных алгоритмов в других моделях с ограниченными автоматами (модели 5-11). Алгоритм в модели 12 либо будет работать медленнее в моделях 5-11, либо не будет работать из-за тупиков или размера памяти в моделях 5-8 для роботов. Однако любой алгоритм в моделях 5-11 будет работать и не большее время в модели 12.

Отметим, что при нулевом времени срабатывания не имеет смысла принимать или посылать больше одного сообщения за одно срабатывание, поскольку это

не уменьшает времени работы, но приводит к увеличению полного размера автомата за счёт хранения в его памяти сразу нескольких сообщений. Наша модель отличается от хорошо известной модели распределённых вычислений LOCAL [17] асинхронностью и наличием корня. В модели LOCAL все автоматы в вершинах работают синхронно и начинают работать одновременно, поэтому сложность алгоритма в этой модели - это число срабатываний. В нашей модели работа начинается с корня, другая вершина включается в работу при получении ею первого сообщения. Кроме того, при оценке сложности алгоритма мы считаем концом работы алгоритма не момент времени, когда задача решена, а момент времени, когда об этом «узнал» корень и сообщил вовне. Асинхронность моделируется не разными временами срабатываний автоматов, а разными и, вообще говоря, переменными временами перемещения сообщений по рёбрам, хотя и ограниченными сверху 1 тактом. Это приводит к тому, что по ребру может передаваться не одно сообщение, а последовательность сообщений, посланных с одного конца ребра и ещё не принятых другим концом.

Для нашей модели, очевидно, получается нижняя оценка 2do+\ сложности любого алгоритма, не имеющего предварительных знаний о графе (вершина знает только свою степень и, для нумерованного графа, свой номер) и решающего глобальную задачу на графе. Задача глобальна, если она не может быть решена без исследования каждого ребра графа. Такое исследование требует, очевидно, времени d,+ \ в наихудшем случае, когда по каждому ребру сообщение двигается ровно 1 такт. Для того чтобы сообщить корню о завершении работы, требуется ещё не менее do тактов в наихудшем случае. Следует, однако, учитывать, что неограниченная ёмкость ребра и нулевое время срабатывания в некоторых алгоритмах может приводить к неограниченному росту числа сообщений, одновременно циркулирующих в графе и, более того, одновременно перемещающихся по одному ребру. Иными словами, решение задачи на графе может использовать неограниченные ресурсы памяти за счёт сообщений. В этом смысле наша модель сближается с недетерминированной машиной Тьюринга, которая неограниченно (экспоненциально) копируется по дереву вычислений. Поэтому оценки сложности предлагаемых нами алгоритмов решения некоторых задач могут оказаться полиномиальными, хотя эти задачи относятся к классу NP. Примером может служить задача о поиске максимального пути в графе (Longest Path Problem [18]), которой посвящен раздел 10 данной статьи.

3. Оценка алгоритмов

Обозначения в оценках алгоритмов: М- максимальный размер сообщения, А -размер автомата (сумма размеров переменных), F = M+A - полный размер автомата, Т - время работы алгоритма, N - максимальное число сообщений, одновременно передаваемых по одному ребру в одном направлении, и Е — максимальный суммарный размер таких сообщений. Очевидно, Е < NM.

Для оценки размера памяти от двух переменных и и да будем считать, что п любое, но фиксированное, достаточно большое число, а да—>оо. Будем писать: Лп,т) = от-^х(£(п,т)), если Эио Уп > т УС > 0 Эдао Ут > то/(п,т) < Cg(n,m), что в нашем случае эквивалентно Эио Уп > т Нтт-^оо(/(п,т)^(п,т)) = 0. Тем не менее, там, где это возможно, будем применять оценки памяти, когда независимо и—>■со и да—>оо при условии связности графа да > п-1. Будем писать: Лп,т) = опт-^оо(£(п,т)), если УС > 0 Б»о Уп > по Ут > п-\^п,т) < Cg(n,m). Согласно [13], если Р = то автомат полуробот на классе

нумерованных графов, а если Р = om-^x{n+{m-n+\)logn), то автомат полуробот на классе ненумерованных графов. Класс ненумерованных графов можно рассматривать как подкласс класса нумерованных графов, а полуробот на подклассе является полуроботом на классе. Далее для краткости будем обозначать: оп/п->«, = 0и,т^ю(я+(да-я+1)/о£я), (и+(да-и+1)/о£и).

Конечно, на подклассе графов, где да = 0(п), в частности, для деревьев т = п-1, уже не верно, что 0(nlognm) = от-+поскольку да не может бесконечно расти (для деревьев да не меняется) при фиксированном п. На таких подклассах могут существовать алгоритмы с меньшей памятью автоматов. Однако нас интересуют алгоритмы, работающие на классе всех графов, и они могут иметь «лишнюю» память на подклассах.

Для корректного использования некоторых наших оценок достаточно, чтобы на рассматриваемом классе графов число рёбер да могло расти быстрее, чем число вершин п, т.е. на некоторой последовательности графов т/п—>у-. Обозначая ]г(п) = т/п, имеем да = пк{п). Если Ит„^тЬ(п)

— оо влечёт

О, то будем писать _Ди,да) Оуут п—(§-(и,да)). Пример: если да = nlogn, то 171 Оуп/п—(и2). Обозначим (п+(т-п+\ )1о^п). Автоматы с памятью

являются полуроботами на классе ненумерованных графов. На подклассе графов без кратных рёбер и петель с п вершинами оценки зависят только от п, а да ограничено сверху по порядку п2. Согласно [13] на этом подклассе автомат полуробот, если F=o(n2logn). Для краткости обозначим оц—>со = o(n2logn). Если /•' имеет эту оценку на подклассе графов без кратных рёбер и петель, будем указывать её в квадратных скобках | о„ > /1. Докажем следующие основные отношения:

1) logm = оп^т, 2) nlognm = от-+м и n2logm = 3) да = от/„^ со, 4) nlogn = о и—»со и п2 = 1) Пусть С > 0. Тогда для п > 1/С+З имеем п > е. что для к > 0 влечёт пк> ек = = (ексУ,с и, поскольку е* > 1+х, имеем пк > (екс)ус > (1 +кС)ус > (1+М«-3))1/с >

> (1+&/(и-1))1/с = ((и-1+&)/(и-1))1/с. Отсюда klogn > {llC)log{n-l+k)-{llC)log{n-l\ что влечёт n+klogn-(l/C)log(n-l+k) > n-{\IC)log{n-\). Поскольку в связном графе т-п+1 > О, выберем к = т-п+1. Поэтому n+{m-n+\)logn-{\IC)logm >

> n-{\IC)log{n-\). Поскольку limn^oo(n/((l/C)log(n-l)У) = оо, найдётся такое

по > 1/С+З, что для каждого п>по будет n-(l/C)log(n-l) > 0. Тем самым, для п>по будет n+{m-n+\)logn-{\IC)logm > 0, что влечёт logm < C{n+{m-n+\)logn). Тем самым, logm =

2) nlognm = от >/ доказано в [13]. При любом, но фиксированном п> 2, имеем limm^x((n2logm)l(n+(m-n+l)logn)) = 0. Следовательно, n2logm = от-+

3) Пусть т = пк{п) и \lYYl п—> со И(п) = 00. Т0ГДа limn-^oo(m/(п+(m-П+l)logпУ) =

\lfYlyi—»со {ml{n+mlogn-nlogn+logn)) = limn^x{h{n)l{l+h{n)logn-logn+{logn)ln)) = \lfYlyi—>со

= Пт„^{(\1^п)1(\1(к(п)1о^)+\Л1к(п))) = 0/(0+1-0) = 0. Поэтому т = от/„

4) Итп-^т{{п^п)/(п2^п)) = Нт„-^оо(1/п) = 0. Поэтому = Итп^т{{п2)/(п2^п)) = limn-^oo(l/logn) = 0. Поэтому п2 =

В дальнейшем при оценках мы будем также учитывать, что с/и < с/ < I) < п-1. ¿/о<А)<АД< 2да, а для графа без кратных рёбер и петель Д < п-1. Когда алгоритм Б использует результат работы другого алгоритма В, то иногда даётся оценка только алгоритма Б без учёта ресурсов, используемых алгоритмом В. Если нужна суммарная оценка, то величины М, А, Т и Е суммируются, а для величины N берётся максимум.

4. Классификация сообщений

В предлагаемых алгоритмах будут использоваться некоторые базовые процедуры обработки сообщений в вершинах. Каждой процедуре соответствует класс сообщения, где под классом сообщения понимается не функциональное предназначение сообщения, а способ его передачи по графу: маршрут, который проходит сообщение, и способ «размножения» или «слияния» сообщений. Те параметры сообщения и переменные вершины, которые существенны для обработки сообщений данного класса, будем называть, соответственно, базовыми параметрами и базовыми переменными. Временем работы алгоритма базовой процедуры будет считаться время распространения сообщения от его создания до уничтожения. Для любого класса базовым параметром является тип сообщения. Сообщение данного типа, попадая в вершину, далее либо 1) уничтожается, после чего, возможно, из вершины посылается одно или несколько сообщений уже другого типа, либо 2) пересылается вершиной дальше по одному или нескольким ребрам, быть может, с модификацией содержимого сообщения, но не его типа. Если принимается одно сообщение, а потом посылаются сообщения того же типа по нескольким ребрам, то это будем называть размножением сообщения. Если принимается несколько сообщений одного типа, быть может за несколько срабатываний, а потом посылается сообщение того же типа по одному ребру, то это будем называть слиянием сообщений.

Сообщение данного типа однозначно определяется маршрутом, который оно прошло: для любого маршрута одновременно существует не более одного сообщения этого типа, которое прошло этот маршрут. При размножении получаются сообщения одного типа, маршруты которых имеют одинаковый префикс, заканчивающийся в вершине, где произошло размножение. При слиянии нескольких сообщений одного типа маршрут каждого сообщения, кроме одного, заканчивается в вершине, где произошло слияние. Таким образом, класс сообщения определяется способом размножения или слияния сообщений и маршрутом, которое сообщение проходит до уничтожения; такой маршрут будем называть маршрутом класса. Мы определим девять базовых классов сообщений, иллюстрируемых Рис. 2. Формально маршрутом называется чередующаяся последовательность вершин и ребер, начинающаяся и заканчивающаяся вершиной, в которой каждое 1-ое ребро инцидентно предыдущей /-ой и последующей /+1-ой вершинам. Номер /-ой вершины маршрута будем обозначать v,, номер /-ого ребра в /-ой вершине будем называть прямым номером и обозначать/;, а его номер в /+1-ой вершине будем называть обратным номером и обозначать г,.

Сообщение может накапливать в себе пройденный им маршрут в виде последовательности Р = <у\/\,г\,у%/2/2,..Ук/к,ГкУк+\/к+\> номеров пройденных вершин и прямых и обратных номеров рёбер, а сообщение передаётся из вершины \'к 1 по ребру /к \. Когда такое сообщение создаётся вершиной VI и посылается по ребру /ь в сообщении параметр Р = <г| ./]>. Когда вершина v, по ребру г,_ 1 получает сообщение с параметром Р = и

посылает сообщение далее по ребру (,. в посылаемом сообщении параметр Р '.= .!',./,>. Если какие-то номера не нужно накапливать: номера вершин, прямые номера рёбер или обратные номера рёбер, - то в конец Р не добавляется соответствующий номер, и последовательность Р не содержит эти номера. Будем называть вариант накопления х-накоплением, а накопленную последовательность Р - х-вектором маршрута, где х определяется регулярным выражением х = V ?/? г ? (знак «?» означает число повторений предыдущего символа 0 или 1 раз). По умолчанию накопления нет (х пусто). В данной статье хордой подграфа будем называть ребро, оба конца которого принадлежат подграфу, но само ребро не принадлежит подграфу. Путём называется маршрут без самопересечения, т.е. такой маршрут длины к, что (Щ Иногда такой маршрут называют простым путём.

Терминальной вершиной будем называть вершину степени 1. Путём с хордой назовем маршрут, который состоит из пути, продолженного хордой этого пути, т.е. имеет вид Р-<еу>, где Р - путь, е - хорда пути Р, инцидентная конечной вершине пути и вершине V. Путём с ребром назовем маршрут, являющийся путём или путём с хордой. Очевидно, длина пути не превосходит Р), а если начало маршрута - корень, то Б о. Максимальная длина пути с хордой на 1 больше. Для корневого дерева листом или листовой вершиной дерева называют терминальную вершину дерева, отличную от корня, а внутренней вершиной

дерева - его вершину, не являющуюся листом или корнем дерева. Корнем остова графа, будем считать корень графа.

3 L

. \

Граф

(корень обозначен *)

1. Одиночная передача

2. Вопрос / Ответ а) Вопрос, Ь) Ответ.

К

К

3. Рассылка по 4. Рассылка по отмеченным 5. Рассыпка против отмеченных

запомненному маршруту.

/-вектор <2,2,1 >.

(белым) рёбрам:

a) по прямому остову,

b) по обратному пути.

(белых) рёбер:

a) против прямого пути,

b) против обратного остова. Пунктиром показаны пересылки с уничтожением сообщения.

4

6. Сбор по обратному дереву (его рёбра белые).

ЧислоРёбер = число входящих обратных рёбер.

7. Рассыпка до самопересечения.

Показаны все маршруты из корня.

8. Рассыпка без повторения.

Маршруты из корня. Пунктиром показаны сообщения, повторно приходящие в вершину.

9. Множественная рассыпка.

Показаны рассылки из всех инициаторов (инициаторы выделены белым центром). Пунктиром показаны сообщения, повторно приходящие в вершину.

Рис. 2. Базовые классы сообщений Fig. 2. Basic message classes

Размеченным графом назовём такой граф, в некоторых вершинах которого отмечены некоторые инцидентные им рёбра со следующими ограничениями: 1) каждое ребро отмечено не более чем в одной из инцидентных ему вершин, и

отмеченное ребро считается условно ориентированным от этой вершины; 2) условно ориентированные отмеченные ребра образуют ациклический граф. Очевидно, длина пути по отмеченным рёбрам не превосходит D, а если один из концов пути корень, то Do. Будем говорить, что отмеченное ребро выходит из вершины, если оно отмечено в этой вершине, и входит в вершину, если оно инцидентно этой вершине, но не отмечено в ней.

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

При описании классов сообщений специальный критерий понимается как некоторое условие, основанное на значениях переменных вершины. В дальнейшем мы будем описывать алгоритмы, составленные как из «кирпичиков» из нескольких алгоритмов, в том числе, из базовых процедур, быть может, с какими-то их модификациями. Там, где будет возникать коллизия совпадающих имён переменных или типов сообщений из разных комбинируемых алгоритмов или при разных модификациях одного и того же алгоритма, будем предполагать систематическое переименование этих имён и типов, не оговаривая этого специально.

4.1. Одиночная передача

Сообщение этого класса двигается по одному ребру, после чего уничтожается. Базовые параметры: Тип - тип сообщения размером 0( 1). Базовые переменные: Степень - степень вершины размером O(logA).

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

Оценка.М= Р( 1).А = Q(logA).F = Q(logА) = <>„\о„ >,|. Т< 1 ,N< \.Е=0{\).

4.2. Вопрос/Ответ

В этой процедуре используются два типа сообщений: Вопрос и Ответ. Базовые параметры: Тип - тип сообщения размером ()(1). Базовые переменные: Степень - степень вершины размером O(logA), СчётчикОтветов - изменяется от Степень до 0, имеет размер O(logA). 42

Вершина посылает Вопрос по каждому инцидентному ей ребру, после чего ожидает получения сообщений Ответ по каждому такому ребру. Предполагается, что по каждому ребру должен придти ровно один Ответ. Сначала СчётчикОтеетое = Степень, а потом счётчик уменьшается на 1 при получении сообщения Ответ. Когда счётчик становится равным 0, он снова инициализируется СчётчикРёбер := Степень для дальнейшего использования. Получив Вопрос по некоторому ребру, вершина посылает по этому же ребру в обратном направлении Ответ. По каждому ребру в каждом направлении проходит не более одного Вопроса и не более одного Ответа', причём Ответ посылается по ребру только после получения по этому ребру Вопроса. Возможны модификации этого алгоритма, когда Вопрос посылается только по тем рёбрам, которые удовлетворяют тому или иному специальному критерию, и вместо Степень используется число таких рёбер.

Оценка. M=0(l).A = OQogA). F = OQogA) = <>„.„, >, \о„ >, |. Т< 2. N< 2. Е = 0(1).

4.3. Пересылка по запомненному маршруту

Сообщение содержит в себе маршрут, по которому оно должно пройти, в виде /-вектора маршрута. Сообщение не размножается, а уничтожается тогда, когда проходит запомненный в нём маршрут.

Базовые параметры: 1) Тип - тип сообщения размером 0(1), 2) Маршрут -/-вектор Р = </i./:... Jt> ещё не пройденной части маршрута размером 0(klogA). Базовых переменных нет.

Пока/вектор имеет вид 1' = <f\J~2,•••/>, где к > 0, из сообщения удаляется номер ребра/, т.е. Р := </,.../>, и сообщение посылается по ребру /. Если к = 0. то сообщение уничтожается.

Оценка. Тогда M=0{klogA). A = 0(l). F=0(klogA). Для k=0(D) имеем F= 0(DlogA) = о,,, >/ |о„ >, |. T < к. Сообщение не размножается, поэтому \'< 1. Е = 0(klogA).

4.4. Рассылка по отмеченным рёбрам

Граф размеченный. Маршрут этого класса является путём, состоящим из отмеченных рёбер. Ребро проходится по его условной ориентации: из вершины, в которой ребро отмечено, в вершину, в которой оно не отмечено. Базовые параметры: Тип - тип сообщения размером 0(1). Базовых переменных нет, не считая отметок рёбер.

Рассылка сообщений начинается с одной или нескольких вершин-инициаторов. Сообщение двигается по отмеченным рёбрам. Обычно при размножении создается столько сообщений, сколько из вершины выходит отмеченных рёбер и сообщения посылаются по этим рёбрам. Возможно также, что сообщение посылается не по всем таким рёбрам, а только по тем, которые удовлетворяют тому или иному специальному критерию. Обычно сообщение уничтожается в

стоке ациклического подграфа отмеченных рёбер, т.е. в такой вершине, из которой не выходят отмеченные рёбра. Возможно также, что сообщение уничтожается раньше по тому или иному специальному критерию. Нам понадобятся два важных частных случаях: рассылка по прямому лесу и пересылка по обратному пути. Если подграф отмеченных рёбер - это прямой лес, то рассылка обычно начинается в корне дерева этого леса; в каждой внутренней вершине степени больше 2 происходит размножение сообщения. Число сообщений равно числу листьев деревьев прямого леса. Если же подграф отмеченных рёбер - это обратный лес, то размножения не происходит, поскольку из каяедой вершины выходит не более одного обратного ребра. Сообщение двигается по обратным рёбрам до корня дерева. Оценка. М = 0( 1). Не считая отметок рёбер,. I = 0(\) и /•' = 0(\) = olrm >, | о„ >, |. T<D (T<Do при рассылке от корня или если корень единственный сток подграфа отмеченных рёбер). Для прямого леса, когда инициаторы - это корни деревьев, N< 1 и Е= ()(1). для обратного леса, когда инициаторы - это листья деревьев, N < п-1 и Е= 0(п).

4.5. Рассылка против отмеченных рёбер

Граф размеченный. Маршрут этого класса состоит из отмеченных рёбер, но проходимых против их условной ориентации: из вершины, в которой ребро не отмечено, в вершину, в которой оно отмечено. Точнее, сообщение пересылается и по рёбрам, не отмеченным в их другом конце, но после такой пересылки сообщение сразу уничтожается. Не считая таких пересылок, сообщение двигается по ациклическому графу отмеченных рёбер в направлении, обратном условной ориентации этих рёбер.

Базовые параметры: Тип - тип сообщения размером ()(1). Базовые переменные (не считая отметок рёбер): Степень - степень вершины размером O(logA). Рассылка сообщений начинается с одной или нескольких вершин-инициаторов. Инициатор рассылает сообщение по всем инцидентным ему рёбрам, не отмеченным в нём. Вершина, получив сообщение по некоторому ребру, проверяет, отмечено ли в ней это ребро. Если ребро не отмечено, сообщение уничтожается. Если ребро отмечено, сообщение пересылается дальше по всем инцидентным вершине неотмеченным рёбрам. Возможно также, что сообщения посылаются только по тем рёбрам, которые удовлетворяют тому или иному специальному критерию. Сообщение уничтожается после того, как оно, пройдя по ребру, попало в вершину, где это ребро не отмечено. В частности, всегда уничтожается сообщение, посланное из истока ациклического подграфа отмеченных рёбер. Возможно также, что сообщение уничтожается раньше по тому или иному специальному критерию. Например, если вершина «знает», что она является истоком, то она может не посылать дальше сообщение, а сразу уничтожать его. Отмеченное ребро будет пройдено один раз в одном направлении - против его условной ориентации. Не отмеченное ребро будет

пройдено по одному разу в каждом направлении (кроме рёбер, инцидентных истокам, если истоки «знают», что они истоки).

Наиболее важные частные случаи размеченного графа - прямой и обратный лес. В случае обратного леса инициатором является обычно корень дерева. Сообщение двигается по рёбрам дерева от корня до листьев с размножением. Если вершина «знает», что она лист дерева, сообщение сразу уничтожается. В случае прямого леса инициатор - это, как правило, лист дерева. Сообщение двигается по рёбрам дерева от листа до корня без размножения. Если вершина «знает», что она корень дерева, она сразу уничтожает сообщение. Оценка. М= 0( 1). .1 = O(logA). F = O(logA) = onjr, >, \o„ >,|. T<D+1 или T<D, если истоки «знают», что они истоки. При рассылке от корня или к корню, соответственно, T<Do+l или T<Do. Для обратного леса, когда инициаторы -это корни деревьев, N < 1 и Е = O(l), для прямого леса, когда инициаторы - это листья деревьев, N <п-\ и Е= 0(п).

4.6. Сбор по обратному дереву

Граф размеченный, подграф отмеченных рёбер является обратным лесом. Базовые параметры: Тип - тип сообщения размером ()(1). Базовые переменные: Степень - степень вершины размером O(logA), ОбратноеРебро - номер выходящего обратного ребра (в корнях деревьев равен 0) размером 0(logA), ЧислоРёбер - число входящих обратных рёбер размером O(logA), СчётчикРёбер - изменяется от ЧислоРёбер до 0, имеет размер O(logA). Это единственная процедура обработки со слиянием сообщений: сообщение данного типа посылается из вершины по выходящему обратному ребру только тогда, когда получены сообщения этого типа по всем входящим обратным рёбрам. Возможно и дополнительное условие посылки сообщения. Сначала СчётчикРёбер = ЧислоРёбер, потом счётчик уменьшается на 1 при получении сообщения по входящему обратному ребру. Когда (не в корне) СчётчикРёбер становится равным 0, посылается сообщение по выходящему обратному ребру, а СчётчикРёбер := ЧислоРёбер для дальнейшего использования. Сбор по обратному дереву обычно начинается в листьях обратных деревьев, по каждому обратному ребру проходит ровно одно сообщение данного типа. Возможна модификация этого алгоритма, когда ожидаются сообщения (не обязательно этого типа) не по множеству входящих обратных рёбер, а по некоторому его надмножеству, не содержащему выходящего обратного ребра. Например, по всем инцидентным рёбрам, кроме выходящего обратного ребра. В этом случае переменная ЧислоРёбер инициализируется не числом входящих обратных рёбер, а числом рёбер в нужном надмножестве, например, Степень-1. Сообщение проходит одно ребро и далее путь по дереву. По каждому ребру леса проходит не более одного сообщения, а по другому ребру - не более одного сообщения в каждом направлении.

Оценка. M= ()(\). A = OQogA). F = O(logA) = o„.m >> \o„ T < I) и T< /.)„. если корень дерева - это корень графа. Для модифицированной процедуры, соответственно, Т<D+1 и 7 < /Л,+ 1. В любом случае N< 1. Е= ()(1).

4.7. Рассылка до самопересечения

Граф нумерованный, номер вершины меняется от 0 до л-1 и имеет размер O(logn). Маршрут класса является путём с хордой или путём, заканчивающимся в терминальной вершине графа. Применяется v-накопление. Базовые параметры: 1) Тип - тип сообщения размером ()(1). 2) Маршрут -v-вектор пути Р = <v\,v2,...vk,vk+i> размером 0((k+l)logn). Базовые переменные: Степень - степень вершины размером O(logA), Номер - номер вершины размером 0(logn).

Когда сообщение создаётся в вершине vi, оно рассылается по всем инцидентным ей рёбрам и содержит v-вектор P=<v\>. Пусть сообщение с v-вектором Р = <vi,v2,...vi,vi+i>, принимается в вершине v по ребру г. Если это «новая» вершина, т.е. V/-\..к+\ v Ф у,, сообщение далее посылается по каждому ребру, инцидентному вершине v, кроме ребра г. В сообщении указывается v-вектор Р := P-<v>. Если степень вершины больше 2, происходит размножение сообщения. Сообщение уничтожается, когда оно проходит хорду пути, т.е. образуется цикл: Э/-1..&+1 v = v,, или когда вершина v терминальная. Рассылка до самопересечения начинается в одной вершине. По каждому маршруту с началом в этой вершине, являющемуся путём с хордой или путём, заканчивающимся в терминальной вершине, проходит ровно одно сообщение. Возможны модификации алгоритма, когда сообщение посылается только по тем рёбрам, которые удовлетворяют тому или иному специальному критерию. Оценка. М= 0(Dlogn). А = 0{logA+logn). F = 0(Dlogn+logA) = « «]. Т < d+1, а при рассылке от корня Т < с/,,+1. Число N сообщений на ребре не больше числа путей, начинающихся в инициаторе и заканчивающихся ребром а—>Ь. На классе всех графов \' и /•.' экспоненциально зависят от п.

4.8. Рассылка без повторения

Маршрут этого класса является путём с ребром.

Базовые параметры: Тип - тип сообщения размером ()(1). Базовые переменные: Степень - степень вершины размером O(logA), Было - булевский признак, равный true, если в вершине было сообщение этого типа. Когда вершина получает сообщение первый раз (Было = false), оно пересылается по каждому ребру, инцидентному вершине, кроме того, по которому оно пришло в вершину, и Было := true. Повторные (Было = true) принимаемые сообщения игнорируются. Если степень вершины больше 2, сообщение размножается. Сообщение уничтожается, если оно повторное (Было = true), или когда сообщение попадает в терминальную вершину графа.

Рассылка без повторения начинается в одной вершине, обычно в корне графа, из которой сообщения рассылаются по всем инцидентным рёбрам. В связном графе для каждой вершины b будет ровно одно инцидентное ей ребро ab, по которому сообщение данного типа первый раз приходит в вершину Ь. Если это ребро условно ориентировать как а—то множество так ориентированных рёбер образует прямой остов графа (ориентированный от корня). Если ребро условно ориентируется как й—ы, то множество так ориентированных рёбер образует обратный остов графа (ориентированный к корню). По каждому ребру остова пройдёт ровно одно сообщение в направлении а—»6. По каждой хорде остова пройдут ровно два сообщения, по одному в каждом направлении. Возможны модификации алгоритма, когда сообщение посылается только по тем рёбрам, которые удовлетворяют тому или иному специальному критерию. Оценка. М=0( 1). А = O(logA). /•'= O(logA) = olrm >, \о„ >, |. Если сообщение рассылается по всем рёбрам, то Т < d+\ (Т < ch,+ \ при рассылке от корня), а если не по всем, то Т <D+1 ('/ < /Л,+1 при рассылке от корня). Л' < 1. /•' = ()(1).

4.9. Множественная рассылка

Граф нумерованный, номер вершины меняется от 0 до л-1 и имеет размер O(logn). Множественная рассылка - это рассылка без повторения, которая параллельно ведётся, начиная с нескольких начальных вершин, которые мы назовём инициаторами. Для того чтобы различать сообщения от разных инициаторов, вершина хранит множество номеров инициаторов, сообщения от которых были в вершине. Обычно цель рассылки - доставить информацию в некоторые конечные вершины (не инициаторы), в частности, в корень, в которых сообщение не посылается дальше, а уничтожается. Время доставки информации в конечные вершины, если они есть, будем считать временем Т, а общее время существования сообщений обозначим Т*. Если после доставки информации в конечные вершины нужно, не дожидаясь времени Т*, удалить оставшиеся в графе сообщения, можно воспользоваться универсальной процедурой очистки, описываемой ниже в подразделе 6.3. Базовые параметры: Тип - тип сообщения размером ()(1). Инициатор - номер инициатора размером O(logn). Базовые переменные: Степень - степень вершины размером O(logA), Номер - номер вершины размером O(logn), Инициаторы - множество номеров инициаторов размером 0(nlogn). Если вершина не конечная, то первое полученное ею сообщение от данного инициатора она пересылает по каждому инцидентному вершине ребру, кроме того, по которому оно получено, а номер инициатора добавляет в переменную Инициаторы. Повторные сообщения от того же инициатора, а в терминальной и конечной вершине любые сообщения, уничтожаются. По ребру в одном направлении пройдёт не более одного сообщения от каждого инициатора. Возможны модификации алгоритма, когда сообщение посылается только по тем рёбрам, которые удовлетворяют тому или иному специальному критерию.

Оценка. М=0(1о^). А = 0(nlogn+logA). Б = 0(nlogn+logA) = [0Я-*»].

Пусть к число конечных вершин. Если к > 0, то '/ < с/, а если сообщение посылается не по всем рёбрам, тоТ<Б. Если только корень конечная вершина, то Т < с!и и Т < /.),,. соответственно. 7* < с/+1. а если сообщение посылается не по всем рёбрам, то Т* < £>+1. N < п-к. Е = 0((п-к)1о^).

Модификация для векторов: Множественная рассылка для случая, когда номер вершины - это /вектор пути от корня до вершины по прямому остову, рассматривается ниже в подразделе 5.5. Здесь мы приведём только оценку. Оценка. M=0{Do¡ogA). . I = ()(п1оаА). F=0{n¡ogA) = о„, >, \о„ >,\. Оценка времени Т и числа сообщений N такие же. Е = 0((n-k)DologA).

5. Построение остова графа

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

5.1. Построение обратного остова

Используется сообщение Вперёд класса «Рассылка без повторения». Вершина имеет дополнительную переменную ОбратноеРебро размером O(logA), предназначенную для хранения номера выходящего обратного ребра. В начале процедуры корень создаёт сообщение Вперёд и посылает его по всем инцидентным рёбрам. Когда некорневая вершина первый раз (переменная Было = false) получает сообщение Вперёд, переменная ОбратноеРебро инициализируется номером ребра, по которому получено сообщение Вперёд. Остальное регулируется правилами обработки сообщения класса «Рассылка без повторения». Остов будет построен через время do, но ещё не более 1 такта сообщения могут двигаться по графу (по хордам остова). Для определения конца построения остова, применяется процедура из следующего подраздела.

Оценка. М=0( 1). A = 0(IogA). F= O(IogA) = опт-^ T<do+l. N<\.

Е=0{ 1).

А

1раф

(корень обозначен *

Сообщение Вперёд класса Сообщение Назад класса

«Рассылка без повторения». «Сбор по обратному дереву».

Пунктиром показаны сообщения, повторно приходящие в вершину.

Рис. 3. Построение остова графа. Fig. 3. Construction of the spanning tree.

5.2. Определение конца построения обратного остова

Если нужно не только построить обратный остов, но и определить момент завершения построения, то дополнительно используется сообщение Назад класса «Сбор по обратному дереву», где ЧислоРёбер понимается как число инцидентных вершине рёбер, кроме выходящего обратного ребра. Переменные ЧислоРёбер и СчётчикРёбер в корне инициализируются степенью корня в начале процедуры построения обратного остова, а в некорневой вершине - степенью вершины минус 1, когда вершина первый раз (переменная Было = false) получит сообщение Вперёд. Некорневая вершина ожидает получения по каждому инцидентному ей ребру сообщения Вперёд или Назад, что требует времени не более do+\, после чего посылает по выходящему обратному ребру сообщение Назад. Сообщение Назад проходит путь к корню, но из-за различного и переменного времени прохождения сообщения по рёбрам графа этот путь может быть не кратчайшим. Поэтому сообщение Назад может пройти путь длиной не do, a Do.

Процедура заканчивается, когда корень получит сообщение Вперёд или Назад по всем инцидентным корню рёбрам. По каждому ребру остова пройдёт сообщение Вперёд в прямом направлении и сообщение Назад в обратном направлении, а по каждой хорде остова в каждом направлении пройдёт по одному сообщению Вперёд.

Оценка суммарно с построением обратного остова. М= 0( 1). А = 0(logA). F= O(logA) = со \о„ >,\. T<do+l+Do. N< 1. /•' = ()(1).

5.3. Установка счётчиков входящих обратных рёбер

Одновременно с построением обратного остова и определением конца построения можно инициализировать в каяедой вершине переменную ЧислоОбратныхРёбер размером O(logA). Для этого, во-первых, инициализируется переменная ЧислоОбратныхРёбер := 0 в корне в начале работы, а в некорневой вершине при получении первого (переменная Было = false) сообщения Вперёд. Во-вторых, при получении сообщения Назад, которое приходит по входящему обратному ребру, вершина увеличивает ЧислоОбратныхРёбер на 1. При посылке сообщения Назад по выходящему обратному ребру вершина присваивает СчётчикРёбер := ЧислоРёбер := ЧислоОбратныхРёбер. Корень делает это в конце работы. Переменные СчётчикРёбер и ЧислоРёбер могут впоследствии использоваться в базовой процедуре «Сбор по обратному дереву», когда ЧислоРёбер понимается как число входящих обратных рёбер.

Оценка суммарно с построением обратного остова и определением конца построения. М=0( 1). А = O(logA). F=0(logA) = o„,m^co [оп-+«]. Т< d0+l+D0. N< l.E=0(l).

5.4. Отметка прямых рёбер

Одновременно с построением обратного остова с определением конца построения можно построить и прямой остов, отметив рёбра остова в других их концах. Для этого в каждой вершине нужна переменная ШкалаРёбер - битовая шкала размером 0(А), содержащая по одному биту на каждое инцидентное ребро. Шкала инициализируется нулями в корне в начале работы, а в некорневой вершине при получении первого (переменная Было = false) сообщения Вперёд. При получении по ребру / сообщения Назад в /-ый бит шкалы записывается 1.

Оценка суммарно с построением остова. М= ()(1). А = 0(logA+A). F= 0(logA+A) = От/и—»co \o„ >,\. T<c!o+l+Do. N< 1. /•' = ()(1).

5.5. Быстрое построение остова

Можно уменьшить оценку времени при построении остова до оптимальной, если использовать сообщение Назад класса «Множественная рассылка», когда только корень конечная вершина. Для этого класса граф должен быть нумерованным, но мы будем нумеровать вершины одновременно с построением остова. Мы применим способ нумерации вершин, аналогичный тому, который использовался в [6],[8] для ориентированного графа. Для этого в качестве номера вершины возьмём /вектор прямого пути от корня до этой вершины, который назовём вектором вершины. Он имеет размер 0(DologA). Сообщение Вперёд посылается с /-накоплением, и вершина получает свой вектор из первого полученного ею сообщения Вперёд. Как и раньше, при получении первого сообщения Вперёд по ребру / вершина запоминает / как номер выходящего обратного ребра.

Добавляется ещё одно сообщение Остов класса «Одиночная передача» без дополнительных параметров, которое при передаче из вершины а по ребру а— сообщает вершине b, что это ребро является ребром остова. Сообщение посылается в ответ на первое сообщение Вперёд, полученное вершиной а. При получении сообщения Остов (а не Назад как раньше) по ребру j вершина увеличивает ЧислоОбратныхРёбер на 1 и, если нужно отметить прямые рёбра, то в j-ый бит переменной ШкалаРёбер записывает 1.

Сообщение Назад содержит вектор создавшего его инициатора и число входящих обратных рёбер инициатора как дополнительный параметр. Сообщение создаётся в вершине, когда по каждому инцидентному ей ребру будет получено сообщение Вперёд или Остов, т.е. когда полностью определится ЧислоОбратныхРёбер и, если нужно, ШкалаРёбер. Поскольку корень конечная вершина, он не пересылает дальше сообщение Назад, но запоминает вектор инициатора р и число qp входящих в него обратных рёбер. Заметим, что входящее обратное ребро совпадает с прямым выходящим ребром с точностью до условной ориентации. Поэтому qp равно числу выходящих прямых рёбер. Остов построен, когда множество Р

запомненных векторов инициаторов содержит вектора всех вершин, что определяется условием «векторной замкнутости»: 1) префикс-замкнутость: \fpeP любой префикс р принадлежит Р. 2) постфикс-замкнутость: вектор вершины продолжается в Р каждым прямым ребром, выходящим из неё: \fpeP саг (К {/ р-</>еР }) = (здесь сагй(Х) мощность множества Л). Пусть вершина а получит первое сообщение Вперёд через время г. Очевидно, г < с1о. Затем, если г = с/,,, то не более чем через 1 такт вершина а получит по каждому инцидентному ей ребру сообщение Вперёд, и сообщение Назад будет создано через время не более г+1 = с/,,+1. Если г < с/,,-\. то не более чем через 2 такта вершина а получит по каждому инцидентному ей ребру сообщение Вперёд или Остов, и сообщение Назад будет создано через время не более г+2 < с/и+1. Сообщение Назад двигается до корня не более с/и тактов. Поэтому Т < 2й?о+1.

Размер вектора вершины равен 0(DologA), поэтому переменная Инициаторы имеет размер О(пО0^А) = от >,. Однако на классе графов без кратных рёбер и петель, где Д < п-1, этот размер может достигать по порядку размера описания графа n2logn. Например, если в графе есть путь от корня длиной п-1 по рёбрам с максимальными номерами п-1, то может получиться так, что к-ая вершина пути получит свой вектор размером порядка {k-\)log{n-\) как вектор префикса пути длиной к-1, а сумма размеров векторов по всем инициаторам будет порядка n2logn.

Размер памяти автомата можно уменьшить, если в переменной Инициаторы хранить не список векторов, а прямое дерево [13], в котором пометить инициаторы. Это дерево будем называть деревом инициаторов. Оно задаётся как список описаний вершин в порядке обхода дерева в ширину. Описание вершины - это список выходящих из вершины прямых номеров рёбер дерева. Прямой номер ребра, имеющий двоичное представление х\,х2,...хг хранится в виде последовательности 0,Х\,0,Х2,... 0.x,. 1 размером Конец описания

вершины задаётся кодом 100, конец списка описаний вершин задаётся кодом 110 (в [13] это коды 10 и 11, соответственно). Если вершина - это запомненный инициатор, то код 100 заменяется кодом 101. Тогда переменная Инициаторы имеет размер 0{n+nlogA) = ()(п/о^А). В корне после кода 101 дополнительно помещается число входящих обратных рёбер инициатора размером 0(logA); суммарно по всем инициаторам добавляется 0{nlogA) бит. Оценка. М= ()(/),Если прямые рёбра не отмечаются, то . ! = ()(п1оаА). F=0{nlogA) — от~>со [^п^со], & если отмечаются (5.4), то А —

0{nlogA+A) \оц—>со]. 7:< 2с/и+1. По ребру в одном направлении

одновременно перемещаются не более одного сообщения Вперёд или Остов и не более одного сообщения Назад от каждого инициатора (числом п-1), поэтому N <п.Е= 0{пБо^А).

6. Стопор и очистка

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

6.1. Стопор

Любой алгоритм D, использующий сообщения конечного числа типов, завершает свою работу не позже того момента, когда в графе исчезнут все сообщения используемых им типов. Предполагается, что работа алгоритма D инициируется корнем, т.е. сообщения указанных типов генерирует только корень, а любая некорневая вершина посылает сообщение одного из указанных типов только в таком срабатывании, в котором она получает сообщение одного из указанных типов. Если нужно отслеживать наличие или отсутствие в графе сообщений любого из типов t\,t2,...tk, то множество этих типов t {t\,t2,...tk} понимается как обобщённый тип, и считается, что сообщение имеет тип t, если оно имеет тип Ue.t.

Стопор используется корнем в цикле: корень начинает процедуру стопора и, когда она заканчивается и оказывается, что в графе ещё есть сообщение указанного типа, начинается новая процедура стопора, и так далее до тех пор, пока не окажется, что сообщений указанного типа нет.

Стопор строится как модификация процедуры (не быстрого) построения обратного остова с определением конца построения (раздел 5). В сообщение Вперёд добавлен один параметр: тип учитываемого сообщения Утип размером 0( 1). Задача сообщений Вперёд - известить все вершины о начале процедуры стопора. Сообщение Назад содержит дополнительный булевский параметр Найдено, который сообщает о том, обнаружено или нет сообщение типа Утип. Задача сообщений Назад - доставить в корень дизъюнкцию их параметров Найдено.

Вершина находится в одном из двух режимов работы: Рабочий и Учёт. Режим работы хранится в переменной Режим размера 0( 1). Также в вершине имеется дополнительная булевская переменная Найдено. Корень переходит из режима Рабочий в режим Учёт, когда он начинает процедуру стопора. Можно считать, что это происходит сразу после начала работы алгоритма D, когда корень генерирует первое сообщение типа Утип, или при завершении очередной процедуры стопора, если в графе ещё остались сообщения типа Утип и должна начаться следующая процедура стопора. В этот момент корень инициализирует переменную Найдено :=false, создаёт сообщение Вперёд и рассылает его по всем инцидентным корню рёбрам.

Некорневая вершина в режиме Рабочий, получив сообщение Вперёд, переходит в режим Учёт и присваивает своей переменной Найдено :=false. Когда вершина в режиме Учёт посылает сообщение типа Утип, она присваивает

своей переменной Найдено := true. Когда вершина получает сообщение Назад с параметром Найдено = true, она присваивает своей переменной Найдено := true. Когда вершина посылает сообщение Назад, параметр Найдено делается равным значению переменной Найдено, и вершина переходит в режим Рабочий. Когда процедура завершается, корень переходит в режим Рабочий. Если при этом в корне Найдено = true, то корень начинает новую процедуру стопора, снова переходя в режим Учёт.

Утверждение 1: Если в начале процедуры стопора в графе нет сообщений типа Утип, и во время процедуры корень не генерирует таких сообщений, то при окончании процедуры стопора в корне Найдено = false.

Доказательство: Действительно, при этих условиях во время процедуры стопора в графе не могут возникнуть сообщения типа Утип, поскольку некорневые вершины не генерируют такие сообщения, а только пересылают их. Поэтому в каяедой вершине переменная Найдено =false в течение всей процедуры стопора. А тогда в конце процедуры стопора в корне Найдено = false, что и требовалось доказать.

Утверждение 2: Если при окончании процедуры стопора в корне Найдено = false, то в графе нет сообщений типа Утип.

Доказательство: Допустим, это не так, и при окончании процедуры стопора в графе на некотором ребре а-^Ъ есть сообщение М\ типа Утип. Поскольку при окончании процедуры стопора в корне Найдено = false, в каждой вершине также Найдено = false. Сообщения типа Утип не генерируются во время процедуры стопора. Следовательно, сообщение М\ послано из вершины а до её перехода в режим Учёт и всё ещё находится на ребре, когда вершина b выходит из режима Учёт. Но вершина b выходит из режима Учёт только после получения по ребру а-^Ъ сообщения Мг типа Вперёд или Назад, а такое сообщение посылается только в режиме Учёт. Следовательно, Мг посылается из а позже М\, а принимается в b раньше, чего быть не может. Мы пришли к противоречию, и утверждение доказано.

Оценка. М = 0(1). А = O(logA). F=0(logA) = опт^ T<d0+D0+\. N< 1.

Е=0( 1).

Для определения конца работы алгоритма D, использующего сообщения типа Утип, процедура стопора запускается в цикле до тех пор, пока она не завершится с переменной в корне Найдено = false. Поэтому в тот момент времени, когда в графе реально исчезают сообщения типа Утип, уже может быть запущена процедура стопора, которая может дать Найдено = true. Но зато следующая процедура стопора даст гарантированно Найдено = false. Поэтому время может удвоиться: Т< 2(d,,+/.),,+1).

6.2. Быстрый стопор

Процедуру стопора можно реализовать как модификацию процедуры быстрого построения остова (подраздел 5.5). Вершина находится в режиме Учёт не более

2 тактов между получением первого сообщения Вперёд и посылкой сообщения Назад: за эти 2 такта по каждому инцидентному вершине ребру придёт сообщение Вперёд или Остов. В доказательстве утверждения 2 сообщение Мг - это сообщение типа Вперёд или Остов.

После выполнения процедуры быстрого стопора в графе могут остаться сообщения Назад, поскольку они рассылаются множественной рассылкой. Для того чтобы эти сообщения не перепутывались с сообщениями Назад следующей процедуры быстрого стопора, будем разделять эти процедуры на чётные и нечётные. Чётность процедуры является дополнительным параметром сообщений Вперёд и Назад. Когда вершина первый раз получает сообщение Вперёд, она запоминает чётность процедуры и далее игнорирует все принимаемые сообщения Назад предыдущей чётности. Когда вершина посылает сообщение Назад, она помещает в него текущую чётность, а сама готова к приёму сообщения Вперёд следующей чётности, считая его первым сообщением Вперёд следующей процедуры. Важно отметить, что процедура быстрого стопора не заканчивается, пока по каждому ребру в каждом направлении не пройдёт сообщение Вперёд или Остов. Эти сообщения «очищают» рёбра от сообщений Назад предыдущей чётности. Поэтому, когда закончится процедура с данной чётностью, в графе не останется сообщений Назад предыдущей чётности.

Оценка. M=O(D0logÁ). A = 0(nlogA). F=0(nlogA) = от^ [о^]. T<2d0+\. N<n.E=O(nD0logA).

6.3. Очистка и быстрая очистка

Процедуры стопора и быстрого стопора легко модифицировать в процедуры очистки и быстрой очистки, которые вместо того, чтобы определять, есть ли в графе сообщения указанного типа, удаляют все такие сообщения. Вершина после перехода в режим Учёт не посылает сообщений типа Утип. Правда, если применяется процедура быстрой очистки, то она использует сообщения класса «Множественная рассылка», и эти её сообщения могут остаться в графе при завершении очистки, хотя сообщений типа Утип уже не будет.

7. Дерево кратчайших путей

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

7.1. Построение обратного дерева кратчайших путей

Для того чтобы построить обратное дерево кратчайших путей, модифицируем алгоритм построения остова, описанный в подразделе 5.1. Сообщение Вперёд

будет накапливать длину пройденного им маршрута в дополнительном параметре Длина размером 0(logDo). Некорневая вершина сохраняет в своей дополнительной переменной Расстояние размером 0(logDo) минимум из параметров Длина сообщений Вперёд, полученных этой вершиной, а в переменной ОбратноеРебро номер ребра, по которому получено сообщение Вперёд с минимальным значением параметра Длина.

Корень посылает сообщение Вперёд с параметром Длина = 1. Некорневая вершина, получив сообщение Вперёд первый раз, инициализирует Расстояние :=Длина, ОбратноеРебро :=/, где /- номер ребра, по которому получено сообщение. Сообщение Вперёд посылается дальше по всем инцидентным вершине рёбрам, кроме ребра / с параметром Длина, увеличенным на 1. Повторное сообщение Вперёд игнорируется только в том случае, когда Длина > Расстояние. Если же Длина < Расстояние, то выполняются присваивания Расстояние := Длина и ОбратноеРебро :=/, где/-номер ребра, по которому получено сообщение. Сообщение Вперёд посылается дальше по всем инцидентным вершине рёбрам, кроме ребра/ с параметром Длина, увеличенным на 1.

Для определения конца построения используется универсальный стопор -процедура стопора из раздела 6 для типа сообщения Вперёд. Покажем, что через с/, тактов в графе не останется сообщений Вперёд, и будет построено дерево кратчайших путей. Действительно, пусть расстояние от корня до вершины равно г. Тогда не более чем через г тактов вершина получит сообщение, прошедшее от корня до этой вершины кратчайший путь. Тем самым, после г тактов вершина перестанет посылать сообщение Вперёд. Поэтому сообщения Вперёд исчезнут из графа не позже чем через й?о тактов. Очевидно, что если в каждой некорневой вершине выбрать в качестве обратного ребра любое инцидентное вершине ребро, лежащее на кратчайшем пути от корня до вершины, то получится дерево кратчайших путей. Оценка без учёта стопора. По сравнению с алгоритмом 5.1 размер сообщения и памяти автомата увеличиваются на 0(logDo). М= 0(logDo). А = 0(logDo+logA). Б = 0(logDo+logA) = от„ >/ |о„ >/1. Т < с/,,. Вершина может получить несколько подряд сообщений Вперёд со строго уменьшающимися значениями параметра Длина и переслать их дальше. Для пересылаемых дальше сообщений Длина < А). Поэтому N < £>о, Е = 0(Бо/с^/^о).

7.2. Установка счётчиков входящих обратных рёбер

В подразделе 5.3 счётчики входящих обратных рёбер устанавливались одновременно с построением обратного остова и определением конца построения. Здесь мы применим аналогичный алгоритм, но только после определения конца построения обратного дерева кратчайших путей. Вместо сообщения Вперёд класса «Рассылка без повторения» используется сообщение Вперёд1 класса «Рассылка против отмеченных рёбер», где отмеченное ребро -

это ребро обратного дерева кратчайших путей. Сообщение Вперёд1 отличается от сообщения Вперёд не только своим классом, т.е. способом рассылки, но также тем, что не происходит инициализации переменной ОбратноеРебро, поскольку она уже установлена при построении дерева кратчайших путей. Соответственно, сообщение Назад создаётся и посылается по выходящему обратному ребру тогда, когда вершина получит по каждому инцидентному ей ребру сообщение Вперёд1 (вместо Вперёд) или сообщение Назад. Оценка без учёта построения дерева кратчайших путей. М= ()(1). А = O(logA). F= O(logA) = Oyijn—»со \o„ >, |. T<2d0+\. N< 1. /•' = ()(1).

Можно совместить установку счётчиков с процедурой стопора для определения конца построения дерева кратчайших путей. Переименуем сообщения Вперёд в стопоре на Вперёд2. Первое сообщение Вперёд2, приходящее в вершину, инициирует сброс счётчика в ноль и посылку сообщения Остов по текущему выходящему обратному ребру. Получая сообщение Остов, вершина увеличивает счётчик на 1. Если очередная процедура стопора не обнаруживает сообщений Вперёд, то счётчики будут установлены правильно. Это даёт суммарную оценку верхней границы времени построения дерева кратчайших путей с установкой счётчиков не do+2{do+Do+V)+2do+\ = 5do+2Do+3, а do+2(do+Do+l) = 3d0+2D0+l.

7.3. Отметка прямых рёбер

После определения конца построения обратного дерева кратчайших путей можно построить и прямой остов, т.е. отметить рёбра остова в других их концах. Это можно совместить с установкой счётчиков входящих обратных рёбер. Алгоритм аналогичен описанному в подразделе 5.4. Переменная ШкалаРёбер - инициализируется нулями при получении сообщения Вперёд1 по выходящему обратному ребру (в корне с самого начала). При получении по ребру / сообщения Назад в /-ый бит шкалы записывается 1. Оценка без учёта построения дерева кратчайших путей. М= ()(1). А = 0(logA+A),F=0(logA+A) = от/п^ \о„ >,\. T<2d0+\.N< 1 ,Е= 0(1). Можно совместить отметку прямых рёбер с процедурой стопора для определения конца построения дерева кратчайших путей аналогично тому, как это делается в подразделе 7.2. Получая сообщение Остов по некоторому ребру, вершина отмечает это ребро в шкале рёбер.

8. Нумерация графа

В этом разделе мы предложим несколько алгоритмов нумерации графа. Вершина имеет дополнительную переменную Номер, которая инициализируется в процедуре нумерации графа. Вершины можно пронумеровать произвольными уникальными идентификаторами, например, векторами вершин. Однако отметим, что минимальная память, требуемая для

хранения идентификаторам вершины, получается тогда, когда вершины пронумерованы числами от 0 до п-\.

8.1. Нумерация векторами

Если на нумерацию графа налагается единственное ограничение: разные вершины имеют разные номера, - то в качестве номера вершины можно использовать вектора вершин. Процедура нумерация векторами является модификацией процедуры построения обратного остова с определением конца построения (подраздел 5.2). Сообщение Вперёд выполняется с /накоплением и поэтому имеет размер не 0( 1) как в подразделе 5.2, a O(D0logA). Когда такое сообщение первый раз (переменная Было = false) попадает в вершину,/вектор пути запоминается в переменной Номер вершины.

Оценка. M=O(D0logA), A = O(D0logA). F=O(D0logA) = от«]. Т< d0+D0+l. N< l.E= O(D0logA).

Модификация 1. Если предварительно построен обратный остов с установкой счётчиков входящих обратных рёбер и отметкой прямых рёбер, то можно предложить другой алгоритм нумерации векторами. Используются сообщения Вперёд класса «Рассылка по отмеченным рёбрам» с /накоплением размером 0(DologA), где отмеченными рёбрами считаются прямые рёбра остова, и сообщение уничтожается в листе остова, и сообщение Назад класса «Сбор по обратному дереву», где ЧислоРёбер понимается как число входящих обратных рёбер. Вершина, получая сообщение Вперёд, запоминает/вектор пути как свой вектор вершины. Листовая вершина остова, кроме этого, создаёт сообщение Назад без дополнительных параметров. Процедура заканчивается, когда в корне становится СчётчикРёбер = 0, после чего для дальнейшего использования СчётчикРёбер := ЧислоРёбер. Сообщение Вперёд проходит путь от корня до листа остова длиной не более Do, после чего сообщение Назад проходит постфикс этого пути в обратном направлении.

Оценка без учёта ресурсов для предварительного построения остова. M=O(D0logA). A = O(D0logA). F=O(D0logA) = от^ [о„-+„]. T<2D0, а если остов - это дерево кратчайших путей, то Т < 2d,,. N < 1. Е = 0(DologA). Модификация 2: Алгоритм модификации 1 можно применить и тогда, когда предварительно построен обратный остов с установкой счётчиков входящих обратных рёбер, но без отметки прямых рёбер. Для этого достаточно использовать сообщение Вперёд с /накоплением не класса «Рассылка по отмеченным рёбрам», а класса «Рассылка против отмеченных рёбер», где под отмеченными рёбрами понимаются рёбра обратного остова. Поскольку установлены счётчики входящих обратных рёбер, вершина «знает», что является листом, если в ней счётчик равен нулю, и в этом случае не посылает сообщение Вперёд дальше. Поэтому сообщение Вперёд проходит путь от корня до листа остова длиной не более Do. После этого сообщение Назад проходит постфикс этого пути в обратном направлении.

Оценка без учёта ресурсов для предварительного построения остова. М= 0(DologA). A = O(D0logA). F=O(D0logA) = от-+м [о„_«,]. T<2D0, а если остов - это дерево кратчайших путей, то Т < 2do. N< l. Е= 0(DologA).

8.2. Быстрая нумерация векторами

Процедуру нумерации векторами можно построить как модификацию процедуры быстрого построения остова (подраздел 5.5).

Оценка. M=O(D0logA). A = 0(nlogA). F=0(nlogA) = om«]. T<2d0+\. N<n.E=O(nD0logA).

8.3. Нумерация по алгоритму Тэрри

Для того чтобы пронумеровать граф числами от 0 до п-1, можно воспользоваться хорошо известным алгоритмом Тэрри обхода неориентированного графа [14]. Сообщение обходит граф, проходя по каждому ребру ровно 2 раза. Более строго, здесь используются сообщения трёх типов: Вперёд класса «Рассылка без повторения» при пересылке по ещё не пройденным рёбрам, ОткатПоХорде класса «Одиночная передача» при возвращении по хорде остова, и Назад класса «Рассылка по отмеченным рёбрам», где отмеченное ребро - это выходящее обратное ребро, и сообщение уничтожается сразу после прохода этого ребра. См. Рис. 4. Дополнительные переменные вершины: МойНомер размером O(logn), Ребро размером 0(logA), в которой хранится номер ребра, по которому последний раз из вершины посылалось сообщение Вперёд, и ШкалаРёбер размером 0(Д), в которой отмечаются пройденные рёбра: как при посылке, так и при получении по ребру сообщения Вперёд.

Переменные Ребро и ШкалаРёбер инициализируются нулями: в корне - в начале работы, а в некорневой вершине - при получении первого (Было = false) сообщения Вперёд. Затем некорневая вершина дополнительно присваивает: ОбратноеРебро \=f, где/- ребро, по которому получено сообщение Вперёд, ШкалаРёбер^) := 1. Если все рёбра, инцидентные некорневой вершине, пройдены, что проверяется по переменной ШкалаРёбер, то посылается сообщение Назад по выходящему обратному ребру. Если все рёбра пройдены в корне, обход закончен. Если не все рёбра, инцидентные вершине, пройдены, то посылается сообщение Вперёд (с использованием специального критерия) по одному ребру - следующему после Ребро непройденному ребру/ Ребро :=/ и ШкалаРёбер^) := 1. Когда вершина получает сообщение Вперёд повторно (Было = true), то это сообщение приходит по хорде. Вершина отмечает эту хорду в переменной ШкалаРёбер и в обратном направлении по хорде посылает сообщение ОткатПоХорде. Когда вершина получает сообщение Назад или ОткатПоХорде, она проверяет непройденность рёбер и, если нужно, посылает сообщение Назад или Вперёд как описано выше.

^ * Граф (корень обозначен *)

1\ ^¡/ъ Сообщения

1*2 Вперёд

Основной алгоритм.

Рёбра пронумерованы в порядке обхода.

Сообщения ОткатПоХорде

Сообщения Назад

12

Ю>

Модификация 1

(нет шкалы рёбер). б

Рёбра пронумерованы *.12! в порядке обхода. 5

7

'13 92

16

Модификация 2

(опрос рёбр). Рёбра пронумерованы в порядке обхода.

Модифнкащш 3

(остов построен заранее). -5 ^, Рёбра пронумерованы \4

в порядке обхода. V

Белым выделен г^'з

прямой остов

Вопросы

При оптимизации нет сообщений 14 и 15.

Рис. 4. Нумерация графа по алгоритму Тэрри. Fig. 4. Numbering of the graph by the Teny algorithm.

Для нумерации вершин достаточно, чтобы сообщение каждого из этих трёх типов содержало параметр Номер размера 0(logn), который должен быть присвоен очередной вершине. Нумерация начинается с того, что корень присваивает себе МойНомер := 0, и посылает сообщение Вперёд с параметром Номер = 1. Когда некорневая вершина получает сообщение Вперёд первый раз (Было = false), она получает свой номер из сообщения Вперёд: МойНомер := Номер, а Номер + 1 становится параметром посылаемого далее сообщения Вперёд или Назад. В остальных случаях параметр Номер из принятого сообщения без изменения переписывается в посылаемое сообщение. Оценка. М= O(logn). A = 0(logn+A). F=0(logn+A) = T<2m.

X < 1. поскольку алгоритм последовательный. Е = O(logn). Модификация 1. Можно сократить размер автомата за счёт увеличения времени работы. Достаточно просто отказаться от шкалы рёбер: номер ребра, по которому посылается сообщение Вперёд, - это следующий номер после Ребро, отличный от ОбраптоеРебро. По хорде остова сообщения будут проходить теперь не 2, а 4 раза: из каждого конца хорды туда и обратно. Оценка. М= O(logn), A = 0(lognA), F=0(lognA) = о„, >, \<>„ >,\. Время увеличится на удвоенное число хорд остова: Т< 4от-2/?+2. N < 1. Е = O(logn).

Модификация 2. Можно, наоборот, уменьшить время работы алгоритма, сохраняя шкалу рёбер и размер автомата 0(logn+A). Для этого корень вначале, а другая вершина при получении сообщения Вперёд выполняет опрос инцидентных рёбер, чтобы установить, какие из них являются хордами остова. Не считая опросов, выполняться будет обход остова, а не всего графа. В каждую некорневую вершину придёт ровно одно сообщение Вперёд. Переменная ШкалаРёбер хранит «0» для прямых выходящих рёбер и (до опроса) неопрошенных рёбер. С самого начала в корне ШкалаРёбер нулевая. Опрос распараллеливается, используя сообщения Вопрос и Ответ класса «Вопрос/Ответ». Вопрос посылается по всем рёбрам, для которых ШкалаРёбер содержит «0». Ответ содержит булевский параметр Хорда, показывающий, является ли ребро хордой остова или нет. Пусть вершина получает Вопрос по ребру х. Если Было =false, то вершина посылает Ответ с параметром Хорда = false и устанавливает Было := true, ОбратноеРебро := х, ШкалаРёбер инициализируется нулями, а потом ШкалаРёбер(х) := 1. В противном случае вершина посылает Ответ с параметром Хорда = true. Вершина, получающая по ребру у сообщение Ответ с параметром Хорда = true, устанавливает ШкалаРёбер(у) := 1. Сообщение Вперёд посылается после получения сообщений Ответ на все посланные сообщения Вопрос. Сообщение Вперёд теперь относится к классу «Рассылка по отмеченным рёбрам»: оно посылается только по выходящим прямым рёбрам, но, как и прежде, только по одному ребру - следующему после Ребро.

Параметр Номер имеется в каждом сообщении. При получении сообщения Вперёд МойНомер := Номер, а параметр Номер в посылаемом сообщении увеличивается на 1. В остальных случаях параметр Номер из принятого сообщения без изменения переписывается в посылаемое сообщение. Оценка. М= OQogri). А = 0(logn+A). F=0(logn+A) = от/п-^ш [о„-^«]. Обход остова занимает время не более 2(п-1). а в каждой из п вершин опрос рёбер занимает не более 2 тактов. Т < Ап-2. X < 1 ,Е = OQogri).

Оптимизация. Когда вершина первый раз получает сообщение Вопрос по ребру х, она отмечает это ребро как хорду: ШкалаРёбер(х) := 1. Эта вершина не будет опрашивать это ребро. В наихудшем случае время Т не уменьшится, а в общем случае опрос рёбер делают не все, a k = 1 ..п вершин, и Т = 2п+2к-2. Модификация 3. Если предварительно построен обратный остов с установкой счётчиков входящих обратных рёбер и отметкой прямых рёбер, то нумерацию естественно делать обходом не графа, а остова. Используются сообщение Вперёд класса «Рассылка по отмеченным рёбрам», которое, как и в модификации 2, посылается по одному выходящему прямому ребру, и сообщение Назад класса «Рассылка по отмеченным рёбрам» при возвращении по выходящему обратному ребру. Оба сообщения имеют дополнительный параметр Номер, а вершина имеет дополнительную переменную Ребро.

Оценка без учёта предварительного построения остова. М= O(logn). А = 0(logn+logA). F = O(lognA) = от^л Т< 2(;?-1). N< 1 .E=0(Iogn).

8.4. Нумерация через корень

Можно сократить время нумерации числами от 0 до п-1 за счёт распараллеливания так же, как в случае нумерации векторами. Для этого применяется модификация процедуры построения обратного остова с определением конца построения (см. Рис. 5).

Добавляются два новых сообщения: Дай Номер класса «Рассылка по отмеченным рёбрам» с г-накоплением размером ()(/)и1о^А). где отмеченными рёбрами считаются выходящие обратные рёбра, и сообщение уничтожается, когда доходит до корня, и БериНомер класса «Пересылка по запомненному маршруту» с длиной маршрута не более £>о и дополнительным параметром Номер размером 0(logn). В вершине имеются дополнительные переменные МойНомер размером 0(logn) и булевский НризнакНумерации, а в корне -переменная ТекущийНомер размером 0(logn).

Сообщения Вперёд. Сообщения ДайНомер. Сообщения Сообщения Назад.

Пунктиром показаны Обратные рёбра белые. БериНомер. Обратные рёбра белые, сообщения, повторно приходящие в вершину.

Модификация 1 (остов построен заранее)

<7 С^ С"

* * * *

Сообщения Вперёд. Сообщения ДайНомер. Сообщения Сообщения Назад.

Прямые рёбра белые. Обратные рёбра белые. БериНомер. Обратные рёбра белые.

Рис. 5. Нумерация через корень. Fig. 5. Numbering through the root.

Работа начинается с того, что корень присваивает себе номер 0, т.е. МойНомер := 0, инициализирует переменные НризнакНумерации := true и ТекущийНомер := 0, создаёт сообщение Вперёд и посылает его по всем инцидентным корню рёбрам.

Когда вершина v первый раз (переменная Было = false) получает сообщение Вперёд, инициализируется переменная НризнакНумерации :=false и создаётся сообщение ДайНомер. Это сообщение двигается по обратному пути до корня с накоплением r-вектора пути. Корень получает из принятого сообщения ДайНомер r-вектор <п...,г/> пройденного сообщением пути. Очевидно,

обратная последовательность <гк,...г{> - это /вектор пути от корня до вершины v. Получая сообщение ДайНомер, корень увеличивает ТекущийНомер на 1 и создаёт сообщение БериНомер класса «пересылка по запомненному маршруту», в котором запомненный маршрут - это /-вектор <г/.....г/> пути от корня до вершины v, и есть дополнительный параметр Номер размером O(logn), который устанавливается равным значению переменной ТекущийНомер. Когда сообщение БериНомер пройдёт запомненный в нём путь, конечная вершина этого пути, т.е. вершина v, запоминает значение параметра Номер в переменной МойНомер.

Также изменяется условие создания сообщения Назад: дополнительно требуется, чтобы вершина была уже пронумерована. Это означает, что сообщение Назад создаётся либо 1) при получении сообщения Вперёд или Назад, когда СчётчикРёбер становится равен нулю, а вершина уже пронумерована, т.е. ПризнакНумерации = true, либо 2) в момент нумерации вершины (ПризнакНумерации := true) при получении сообщения БериНомер, предназначенного этой вершине (в сообщении /вектор нулевой длины), если СчётчикРёбер = 0. В обоих случаях после создания сообщения Назад СчётчикРёбер := ЧислоРёбер для дальнейшего использования. Когда в корне переменная СчётчикРёбер станет равной нулю, нумерация закончена. Сообщение ДайНомер создаётся, когда сообщение Вперёд проходит путь от корня до вершины v за время не более с/,,. и само проходит этот путь в обратном направлении от вершины v до корня за время не более Do, после чего сообщение БериНомер проходит этот путь в прямом направлении от корня до вершины v за время не более Do, а после этого сообщение Назад двигается по тому же пути от вершины v в сторону корня за время не более Do. Тем самым, время Т < с/,+3!)<, при условии Do > 0. Если Do = 0, то в связном графе только одна вершина, а все рёбра - петли. В этом случае требуется время для прохождения петель: Т= 1.

СообщенияДяй//£ше/7 от всех вершин, кроме корня, т.е. от п-1 вершины, могут оказаться на одном ребре (а потом сообщения БериНомер для всех вершин, кроме корня, могут оказаться на одном ребре).

Оценка. М= 0(DologA+logn). А = 0(logA+logn). F = 0(DologA+logn) = om^« [Оя^м]. Т< max{clo+3Do,l}. N< max{n-1,1}. E = 0(n(DologA+logn)). Модификация 1. Эта модификация применяется тогда, когда уже построен обратный остов с установкой счётчиков входящих обратных рёбер и отметкой прямых рёбер. Сообщение Вперёд теперь будет относиться к классу «Рассылка по отмеченным рёбрам», где отмеченные рёбра - это прямые выходящие рёбра. Сообщение Назад теперь будет относиться к классу «Сбор по обратному дереву», где ЧислоРёбер понимается как число входящих обратных рёбер. В начале корень создаёт и рассылает по выходящим из корня прямым рёбрам сообщение Вперёд. Сообщения ДайНомер и БериНомер такие же, как в описанном выше алгоритме. Некорневая вершина получит сообщение Вперёд

один раз и создаст сообщение ДайНомер. Дополнительное условие посылки сообщения Назад такое же: вершина должна быть уже пронумерованной. Процедура заканчивается, когда в корне становится СчётчикРёбер = 0, после чего СчётчикРёбер := ЧислоРёбер для дальнейшего использования. Если п = 1, с самого начала в корне СчётчикРёбер = 0, поэтому сообщения не посылаются и процедура заканчивается после присвоения корню номера 0. Оценка без учёта предварительного построения остова. М= 0(DologA+logn). А = 0(logA+logn). F = 0(DologA+logn) = « [о„-^т]. Т < 4£>о, а если остов - это дерево кратчайших путей, то Т< Ас!,,. N< п-\. Е = ()(п(!)< JogA+logn)).

8.5. Быстрая нумерация вершин через корень

Можно уменьшить время нумерации через корень, меняя в оценке Dо на с/,. если применять модификацию быстрого построения остова (подраздел 5.5). Сообщения ДайНомер и БериНомер относятся к классу «Множественная рассылка», как и сообщение Назад. Сообщение ДайНомер создаётся, как и раньше, когда вершина первый раз получает сообщение Вперёд, и имеет только базовые параметры своего класса. Сообщение БериНомер создаётся, как и раньше, когда корень получит сообщение ДайНомер, и имеет дополнительный параметр Номер. Имеется дополнительное условие создания сообщения Назад: требуется, чтобы вершина была уже пронумерована.

Оценка. М= O(D0logA+logn). А = 0(nlogA+logn). F = 0(nlogA+logn) = om-^m со]. T < 4ö?o+1- N<п. Е= O(n(D0logA+logn)).

8.6. Быстрая нумерация вершин не через корень

Можно ещё уменьшить время быстрой нумерации, если заметить следующий факт. В алгоритме быстрого построения остова (подраздел 5.5) сообщение Назад, содержащее вектор инициатора и число входящих в него обратных рёбер, рассылается множественной рассылкой. Поэтому не только корень, но каждая вершина получает в переменной Инициаторы дерево инициаторов и может определить конец построения такого дерева. После этого вершина может сама вычислить свой номер, применяя один и тот же алгоритм обхода дерева в ширину. Сообщения ДайНомер и БериНомер не нужны. Мы возьмём за основу алгоритм быстрого построения остова, но только поменяем название сообщения Назад на Конец. Когда вершина определит конец построения дерева инициаторов по условию «векторной замкнутости», она вычисляет свой номер и посылает сообщение Назад класса «Множественная рассылка», сообщая как дополнительный параметр свой номер. Когда корень получит сообщения Назад от всех вершин, алгоритм заканчивается. Каждый инициатор посылает сообщение Конец через время не более <¿0+1, до каждой вершины оно идёт не более с/ тактов. Затем сообщение Назад от каждой вершины доходит до корня за время не более clo.

Оценка. M= 0(DologA+logn). A = 0(nlogA+logn). F = 0(nlogA+logn) = om^m \o„ >, |. T<do+d+do+\ < 4i/0+l. N<n.E= O{n{D0logA+logn)).

9. Сбор информации о графе в памяти автомата корня

В этом разделе мы предложим алгоритм сбора полной информации о графе в памяти неограниченного автомата корня. При этом автоматы остальных вершин будут полуроботами. Прежде всего, отметим, что если граф ненумерованный, то информация о графе может содержать только fr-вектора маршрутов. Однако множество таких /--векторов определяет граф не однозначно. Например, неразличимы графы, каждый из которых состоит из простого цикла рёбер длины к > 0 с нумерацией рёбер по циклу (1,2),(1,2),...(1,2) (см. Рис. 6).

О Множество /--векторов задаётся регулярным выражением (12)* (здесь знак «*» означает конечное число повторений выражения в скобках 0 или более раз) и не зависит от числа вершин в цикле.

Рис. 6. Множество fr-векторов не однозначно определяет граф. Fig. 6. The set of fr-vectors does not uniquely determine the graph.

Будем предполагать, что в нумерованном графе номера вершин линейно упорядочены. Алгоритмы нумерации из раздела 8 это гарантируют как для чисел от 0 до п-1, так и для векторов. Алгоритм сбора - это модификация алгоритмов построения обратного остова с определением конца построения или быстрого построения остова. Можно также совместить сбор информации с нумерацией графа по любому из алгоритмов раздела 8.

Информация о графе собирается в виде множества описаний рёбер формата (v/r,v ), где V и v' - номера вершин, инцидентных ребру,/- номер ребра в вершине v, г - номер ребра в вершине v'. Если вершины пронумерованы числами от 0 до п-1, то размер описания ребра 0(lognA), а если используются вектора вершин, то 0(DologA). Описание ребра посылается как параметр сообщения Ребро, которое должно дойти до корня. Вершина должна создать все нужные сообщения Ребро до того, как она создаст сообщение Назад, и все эти сообщения должны идти по одним и тем же путям от вершины до корня. Тогда корень получит все сообщения Ребро до того, как получит все сообщения Назад, по которым он определяет конец работы.

Заметим, что объединять в одном сообщении описания всех рёбер, инцидентных вершине, - плохая идея, так как это увеличивает порядок размера сообщения и, соответственно, полного размера автомата до AlognA или (для векторов) до ADf JogA. На классе всех графов с п вершинами и т рёбрами эти величины имеют порядок mlognm или (для векторов) до тп login. т.е. автомат является неограниченным.

9.1. Сбор по остову нумерованного графа

Сбор информации о нумерованном графе можно реализовать как модификацию алгоритма построения обратного остова с определением конца построения (подраздел 5.2, см. также Рис. 7). Сообщение Ребро имеет класс «Рассылка по отмеченным рёбрам», где отмеченное ребро - это выходящее обратное ребро; сообщение двигается по обратному пути до корня.

4*

Сообщения Вперёд. Пунктиром показаны сообщения, повторно приходящие в вершину.

Рис. 7. Сбор информации о графе в неограниченной памяти автомата корня. Fig. 7. Collect information about the graph in unlimited memory of the root automaton.

Описание ребра добавляется также в сообщение Вперёд. Когда это сообщение посылается из вершины v по ребру /. описание ребра в нём имеет формат (l'./.O.O). Когда первое сообщение Вперёд приходит в некорневую вершину v' по ребру г, создаётся сообщение Ребро с описанием ребра (v/r,v ). Если сообщение Вперёд повторное, то сообщение Ребро создаётся в том случае, когда v > v' в линейном порядке вершин. Сообщение Назад посылается из вершины после того, как она пошлёт все свои сообщения Ребро. При получении корнем сообщения Вперёд можно считать, что корень создаёт сообщение Ребро и сам же его принимает без реальной пересылки по рёбрам. В корень поступит одно описание каждого ребра. Так как все сообщения Ребро посылаются из вершины раньше, чем сообщение Назад, и эти сообщения двигаются по одному и тому же обратному пути, в момент определения конца построения остова все сообщения Ребро уже достигли корня, и корень получил полную информацию о графе.

В «худшем» случае на одном ребре могут оказаться все сообщения Ребро и одно сообщение Назад, суммарно ///+1.

Оценка. Размер сообщения и памяти некорневой вершины увеличивается на размер описания ребра. Т < c/u+M,+1. Y < m+1. Если номер вершины - это число от 0 до /7-1, то М= O(lognA), A = 0(lognA) и F = O(lognA) = om^m E= 0((m+\)lognA). Если номер вершины - это её вектор, то М= 0(DologA), А = O(D0IogA) и F= O(D0IogA) = от^л [o„^l Е = O((m+\)D0logA).

9.2. Быстрый сбор по нумерованному графу

Сбор информации о нумерованном графе можно реализовать как модификацию алгоритма быстрого построения обратного остова (подраздел 5.5). Аналогично

£

4*

4*

Сообщения Ребро. Сообщения Назад.

Обратные рёбра - белые. Хорды - пунктирЕые линии Описание ребра а—>Ь посылает вершина а. Показано число сообщений, проходящих по ребру.

алгоритму из предыдущего подраздела описание ребра добавляется в сообщение Вперёд. Когда это сообщение посылается из вершины V по ребру/ описание ребра в нём имеет формат (г/0.0). Когда первое сообщение Вперёд приходит в некорневую вершину V1 по ребру г, создаётся сообщение Ребро с описанием ребра (у/,г,у'). Если сообщение Вперёд повторное, то сообщение Ребро создаётся в том случае, когда у > V1 в линейном порядке вершин. Сообщение Назад посылается из вершины после того, как она пошлёт все свои сообщения Ребро. При получении корнем сообщения Вперёд можно считать, что корень создаёт сообщение Ребро и сам же его принимает без реальной пересылки по рёбрам.

Теперь сообщение Ребро, как и сообщение Назад, имеет класс «Множественная рассылка», когда только корень конечная вершина. На одном ребре могут оказаться одновременно сообщения Ребро для каждого ребра и сообщения Назад от каждой вершины, кроме корня, а также одно сообщение Вперёд или Остов', всего не более т+(п-1)+1 = т+п сообщений.

Но здесь есть проблема с инициаторами сообщений Ребро. Как сказано выше, это сообщение содержит описание только одного ребра, поэтому вершина посылает множество таких сообщений Ребро с описаниями инцидентных вершине рёбер, и все они должны дойти до корня. Поэтому инициатором сообщения Ребро с описанием ребра (у/,г,у ) следует считать не вершину у. создавшую это сообщение, а ребро, задаваемое парой (г,у ). Эта проблема решается немного по-разному в зависимости от того, пронумерованы вершины числами от 0 до п-1 или векторами.

Если номер вершины - это вектор, то переменная Инициаторы (подраздел 5.5) хранит дерево инициаторов-вершин как список описаний вершин в порядке обхода дерева в ширину, где описание вершины - это список выходящих из вершины прямых номеров рёбер дерева. Для добавления инициаторов-рёбер, достаточно в описание вершины добавить (через разделитель) битовую шкалу рёбер, инцидентных вершине. Инициатор-ребро, задаваемый парой (г,у ), отмечается «1» в г-м бите шкалы рёбер в описании вершины у\ Размер переменной Инициаторы увеличивается на 0(п+т) бит.

Оценка (номер вершины - её вектор). М= 0(DologA). Для некорневой вершины А = 0(n+m+nlogA) и Б = 0(n+m+nlogA) = От/гнж I<>п >>\- Т<2с1о+\. Ы<т+п. Е = 0((т+п)0(^А).

Если вершины пронумерованы числами от 0 до п-1, то нет смысла использовать алгоритм, основанный на векторах вершин. В переменной Инициаторы хранится список описаний вершин в порядке возрастания их номеров. Описание вершины содержит один бит для отметки вершины-инициатора и битовую шкалу рёбер, инцидентных вершине, для отметки рёбер-инициаторов. Размер переменной равен 0(п+т) бит.

Сообщение Вперёд посылается без /накопления. Также как описано выше, в сообщение Вперёд добавляется описание ребра (г/0.0). которое используется для создания сообщения Ребро с описанием ребра (у/,г,у ). Сообщение Назад 66

содержит номер (а не вектор) создавшего его инициатора и число входящих обратных рёбер инициатора как дополнительный параметр. Кроме того, меняется процедура определения конца работы, выполняемая в корне. В подразделе 5.5 эта процедура использовала дерево инициаторов с указанием числа входящих обратных рёбер для каждого инициатора. Теперь для описания дерева инициаторов достаточно в описаниях рёбер отметить рёбра остова. Для этого в описание ребра добавляется булевский признак остова, который равен true, если описание ребра создаётся при получении вершиной первого сообщения Вперёд, и равен false, если описание ребра создаётся при получении вершиной повторного сообщения Вперёд. Число входящих обратных рёбер, как и в подразделе 5.5, равно числу полученных вершиной сообщений Остов и передаётся корню в сообщении Назад. Вместо условия «векторной замкнутости» у нас будет аналогичное условие «числовой замкнутости»: 1) для каждого ребра остова (г./.г.г ) оба его конца v и v" должны быть вершинами-инициаторами, 2) для каждой вершины-инициатора v" (а также для корня) число рёбер остова вида (v.f.r.v ) должно быть равно числу обратных рёбер, входящих в вершину v\

Оценка (номер вершины - число от 0 до п-1). М= O(lognA). Для некорневой вершины А = 0(n+m+lognA) = 0(т) и F=0(m) = 0т/я->°° |о„ T<2do+1. N<m+n. Е = 0((m+n)lognA).

9.3. Сбор по остову с одновременной нумерацией графа

Алгоритм сбора может быть построен как модификация любого не быстрого алгоритма нумерации графа (подразделы 8.1, 8.3, 8.4). Размер сообщения и памяти некорневой вершины увеличивается на размер описания ребра. Идея алгоритма следующая. Получая номер, вершина опрашивает соседей с помощью сообщений класса «Вопрос/Ответ». Вопрос посылается из вершины v по ребру / и принимается вершиной v' по ребру г, а Ответ посылается обратно по тому же ребру. Оба сообщения содержат описание ребра: Вопрос -в формате (у/,0,0), Ответ - в формате (г./.0.0). если вершина г' ещё не имеет номера, или в формате (vf,r,v). если уже имеет. Сообщение Ребро с описанием ребра (vf,r,v ) создаёт либо вершина v при получении сообщения Вопрос, если вершина v" пронумерована и г > г' в линейном порядке вершин, либо вершина v при получении сообщения Ответ с параметром (v/r,v), если г < г". Сообщение Ребро имеет класс «Рассылка по отмеченным рёбрам», где отмеченное ребро - выходящее обратное ребро. Сообщение двигается по обратному пути до корня. Сообщение Назад создаётся после окончания опроса соседей и посылки всех нужных сообщений Ребро.

Опрос соседей занимает не более 2-х тактов. Опрос начинается, когда вершина получает номер, происходит параллельно в разных вершинах и не тормозит передачу других сообщений, кроме, быть может, сообщения Назад. Поэтому время Т увеличивается не более чем на 2 такта. Для некоторых алгоритмов

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

В алгоритме Тэрри нужно в сообщении Вперёд, посылаемом из вершины v по ребру/ дополнительно указать описание ребра в формате (г./.'0.0). В основном алгоритме сообщение Ребро создаётся при получении сообщения Вперёд. В модификации 1 нет шкалы рёбер, поэтому сообщение Ребро создаётся при получении вершиной v' сообщения Вперёд либо по ребру остова, либо по хорде при условии v' < v. В модификации 2 (без оптимизации) уже выполняется опрос соседей. Поэтому достаточно в сообщении Вопрос, посылаемом из вершины v по ребру / и принимаемом вершиной v по ребру г, указать описание ребра в формате (г./.О.О). а в сообщении Ответ с параметром Хорда = true указать описание ребра в формате (v.f.O.O). если вершина v' ещё не имеет номера, или в формате (yf,r,v\ если вершина г' уже пронумерована. Сообщение Ребро создаётся при получении вершиной v по ребру г либо сообщения Вперёд, либо сообщения Вопрос, если вершина v' уже пронумерована и г > г", либо при получении вершиной v сообщения Ответ с параметрами Хорда = true, г Ф 0 и v' > v. В модификации 3 предварительно построен остов с отметкой прямых рёбер и выполняется обход остова, а не графа. Для рёбер остова создаётся сообщение Ребро при получении сообщения Вперёд. Хорды (соседи на концах хорд) опрашиваются.

В основном алгоритме нумерации через корень и его модификации 1 нужно делать опрос соседей при получении сообщения БериНомер.

9.4. Быстрый сбор с одновременной нумерацией графа

Алгоритм сбора может быть построен как модификация любого быстрого алгоритма нумерации графа (подразделы 8.2, 8.5, 8.6). Размер сообщения и памяти некорневой вершины увеличивается на размер описания ребра. Как и в предыдущем подразделе используется опрос соседей, который увеличивает время Т не более чем на 2 такта. Иногда от этих 2-х тактов можно избавиться. При быстрой нумерации векторами Вопрос и Ответ не нужны. Сообщение Ребро создаётся при получении либо первичного сообщения Вперёд, либо повторного сообщения Вперёд от вершины с большим вектором.

В алгоритме быстрой нумерации через корень нужно делать опрос соседей при получении сообщения БериНомер.

В алгоритме быстрой нумерации не через корень опрашиваются только хорды (соседи на их концах). Каждая вершина сама определяет конец построения дерева инициаторов по условию его «векторной замкнутости» и вычисляет свой номер. Также она может вычислить номер nv любой вершины v по её вектору pv. Для прямого ребра а—>Ь вершина b знает его номер г в вершине b (выходящее из b обратное ребро) и свой вектор рь = ра-</>, где/- номер ребра в вершине а. Вершина b строит описание ребра a—>h в формате (па.(.г.пь) и создаёт сообщение Ребро. Также вершина b по своему вектору рь находит в дереве инициаторов своё описание, содержащее номера выходящих прямых рёбер. Тем самым, вершина b определяет номера хорд, которые опрашивает.

10. Поиск максимального пути

В этом разделе рассмотрим решение коллективом автоматов задачи поиска максимального пути в графе (Longest Path Problem). Как известно, эта задача относится к классу NP. Но в нашей модели, допускающей неограниченное число сообщений, она решается за линейное время. Граф предполагается нумерованным числами от 0 до n-1. Сначала рассмотрим задачу поиска и, если нужно, разметки максимального пути, начинающегося в корне графа, а потом общую задачу поиска и разметки максимального пути в графе.

10.1. Максимальный путь от корня

Идея алгоритма заключается в следующем. Рассмотрим все маршруты, начинающиеся в корне и имеющие вид В-<е> или С, где В - путь до вершины v, е - хорда пути В, инцидентная вершине v, С - путь, заканчивающийся в терминальной вершине. Максимальный путь от корня - это максимальный среди путей В и С. Используются два типа сообщения: Прямо класса «Рассылка до самопересечения» с г/г-накоплснисм размером 0(DolognA) и Обратно класса «Рассылка по отмеченным рёбрам», которыми считаются рёбра обратного остова (Рис. 8). Вершина содержит дополнительную булевскую переменную Было, которая равна false, если эта вершина ещё не получала сообщения Прямо', вначале Было = false.

В начале работы корень присваивает Было := true, создаёт сообщение Прямо и рассылает его по всем инцидентным рёбрам. Получая первое сообщение Прямо, вершина отмечает ребро, по которому принято сообщение, как выходящее обратное ребро. Так строится обратный остов графа. Сообщение Обратно создаётся при уничтожении сообщения Прямо, когда его маршрут самопересекается или заканчивается в терминальной вершине. В этот момент сообщение Прямо содержит vfr-вектор пути с ребром вида Рк-</к>, где Рк= <v\f\,ri,v2/2,r2,...vk>, vi корень, /к прямой номер ребра, по которому вершина vt посылала сообщение. Сообщение получает вершина \'к \ по ребру г к.

причём либо = V, для некоторого /-1..А", либо вершина г/.- 1 терминальная. Сообщение Обратно имеет дополнительный параметр Р = 1'к. если было самопересечение, или Р = Рк-</к.Гк^к+1>, если маршрут закончился в терминальной вершине.

I Граф • >■ Обратный остов (белые рёбра)'.

(корень обозначен *) обратное выходящее ребро

отмечается вершиной при приёме первого сообщения Прямо.

* Показана одна пара сообщений: & * Разметка - сплошная линия.

Прямо - сплошная линия, _Конец - пунктирная линия.

Обратно - пунктирная линия.

V

Рис. 8. Поиск максимального пути от корня и его разметка. Fig. 8. Search for the maximum path from the root and its markup.

В корне хранится ^-вектор Ртах, вначале пустой. Когда корень получает сообщение Обратно с параметром Р, он сравнивает длину Р из сообщения с длиной Ртах. Если Р длиннее, то запоминается Ртах '■= Р.

Конец работы определяется с помощью универсальной процедуры стопора (раздел 6) для типов сообщений Прямо и Обратно. Корень посылает вовне сообщение, содержащее как параметр Ртах = <v\.f\.r\.vk.fk.i'k....','kmin>. Сообщение Прямо проходит от корня путь с хордой, длиной не более Z?o+l, или путь, заканчивающийся в терминальной вершине, длиной не более Do. Затем сообщение Обратно проходит путь до корня длиной не более Do. Число сообщений на ребре экспоненциально, что и следовало ожидать, поскольку задача поиска максимального пути - класса NP. Оценка без учёта стопора. М= O(D0logjiA). А = O(D0logjiA). F= O(D0logjiA) = Ои-m \о„ Т < 21),,+1. \ и /•' экспоненциальны.

Модификация 1. Число сообщений Обратно можно сделать линейным (а не экспоненциальным), если в каждой вершине хранить максимальную длину ктах векторов Р из проходивших через вершину сообщений Обратно. Полученное вершиной сообщение Обратно, содержащее вектор Р длины к, посылается дальше только, если к > ктах. Поскольку к меняется в диапазоне от 0 до I). число сообщений Обратно на одном ребре не превосходит D+\. Модификация 2. Если нужно разметить найденный максимальный путь от корня, то после завершения поиска такого пути корень создаёт сообщение Разметка класса «Пересылка по запомненному маршруту», в котором параметр Маршрут равен </i./:....Д„кц-1> и имеет длину не более Do. Когда вершина v;, где /= 1. .kmax-1. посылает сообщение Разметка по ребру /¡. она отмечает выходящее ребро пути в переменной Fn \=fj размером O(logA). Когда вершина v;, где /=2. .kmax. принимает сообщение Разметка по ребру г,-.i, она

отмечает входящее ребро пути в переменной Rn := rh] размером O(logA). Когда сообщение Разметка дойдёт до конца запомненного пути, т.е. до вершины Vkmax? эта вершина создаёт сообщение Конец класса «Рассылка по отмеченным рёбрам», которыми считаются рёбра обратного остова. Разметка заканчивается, когда корень получает сообщение Конец.

Сообщение Разметка проходит путь от корня длиной не более Do, а сообщение

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

Оценка без учёта поиска максимального пути. М = 0(DolognA). А = 0(DolognA).

F = O(D0lognA) = от^ со \_Ofi—>со]. Т < 2D0. N<lnE= O(D0lognA).

Модификация 3. Если в графе построен обратный остов, при получении первого

сообщения Прямо не нужно отмечать выходящее обратное ребро. Выигрыш по

времени будет, если остов - дерево кратчайших путей.

Оценка. М= 0(DolognA). А = 0(DolognA). F= 0(DolognA) = om-^m [o„-^«]. При поиске пути без учёта стопора Т< Do+do+\. Для разметки Т < i.),,+d,. Заметим, что такой же выигрыш по времени можно получить и в том случае, когда дерево кратчайших путей не построено, если сообщения Обратно и Конец имеют класс «Множественная рассылка». Однако в этом случае память автомата больше: А = 0(nlognA), F = 0(nlognA) = от >, |о„ >, |.

10.2. Максимальный путь в графе

Идея поиска максимального пути в связном графе заключается в следующем. Рассмотрим все маршруты вида А-В-<е> или А-С, где А - путь от корня до некоторой вершины v, В - путь от вершины v до вершины ге - хорда пути В, инцидентная вершине v\ С - путь от вершины г", заканчивающийся в терминальной вершине. Вершину v назовём инициатором. Максимальный путь в графе - это максимальный среди путей В и С для всех инициаторов. Как и при поиске максимального пути от корня, используются два типа сообщения: Прямо класса «Рассылка до самопересечения» с v/r-накоплением и Обратно класса «Рассылка по отмеченным рёбрам», которыми считаются рёбра обратного остова (Рис. 9). Вершина содержит переменную Было. Сообщение Прямо может создаваться не только в корне, но и в любой вершине-инициаторе v, поэтому г/г-вектор имеет вид Рк-</к>, где

Рк = <1', 1./,' 1 J'/ 1. г, 2.fj 2____гр' и V/+1 = v. Вершина v становится инициатором,

когда получает первое (Было = false) сообщение Прямо с v/r-вектором Pj-<fj>, где Pj = <\>\.[\.г\.\>2.[2.г2...л'/>. Вершина v сначала рассылает дальше сообщение Прямо в соответствии с его классом, а потом создаёт новое сообщение Прямо, которое рассылается по всем инцидентным рёбрам. Новое сообщение Прямо, посылаемое по ребру fr \. содержит г/г-всктор <i;y i>-<//: i>. Создание и обработка сообщения Обратно и определение конца работы такие же как в случае поиска максимального пути от корня.

Граф

(корень обозначен *)

Обратный остов (белые рёбра)'. обратное выходящее ребро отмечается вершиной при приёме первого сообщения Прямо.

А

А

Прямо проходит пунктирный путь от корня (*) до инициатора (У) и сплошной путь от инициатора до самопересечения (О). Обратно проходит белый путь от самопересечения (О) до корня (*).

А

Разметка проходит пунктирный путь от корня (*) до инициатора (V) и сплошной путь от инициатора до конца размечаемого пути. Конец проходит белый путь от конца размеченного пути до корня (*).

А

Рис. 9. Поиск максимального пути в графе и его разметка. Fig. 9. Search for the maximum path in the graph and its markup.

Модификация 1 аналогична модификации 1 из подраздела 10.1. Число сообщений Обратно на ребре не больше .0+1.

Модификация 2 для разметки найденного максимального пути. В сообщение Прямо добавляется ещё один параметр Я, содержащий /-вектор пути от корня до инициатора. Когда инициатор - корень, Я пусто. Сообщение Прямо с инициатором в некорневой вершине V создаётся этой вершиной при получении первого сообщения Прямо (его инициатор - корень), содержащего г/г-вектор //</,>. где I', = <Г|./|Г|.г;./;Г;....г/>. Тогда К = </]..../,:>. Сообщение Обратно также имеет дополнительный параметр К, переписываемый из сообщения Прямо при создании сообщения Обратно.

Корень вместе с переменной Ртах = <г, , / , .г, ,. г, 2/ 2-П .... \'кт1Г> хранит соответствующую ей переменную = </1^2,.../>, в которую из сообщения Обратно переписывается параметр Я, когда параметр Р переписывается в переменную Ртах. Когда создаётся сообщение Разметка, оно имеет два параметра: Ятах и Ргтах = </,:1/ :..../„„.,-]> как подпоследовательность Ртих. являющаяся /вектором найденного пути. Сначала сообщение Разметка двигается по пути с /вектором Ктах от корня до начала найденного пути, а потом - по этому пути с /вектором /-"„„„.. размечая путь в переменных Л;? и Бп. Модификация 3 полностью аналогична модификации 3 в подразделе 10.1. Оценка. По сравнению с оценками в подразделе 10.1 увеличиваются размеры сообщения М и автомата . I за счёт того, что величина Бо меняется на /): М = А = /•' = ()(/)1о^пА) = от >/ | о„ > /1. Если используется множественная рассылка, то память ещё больше: А = Б = 0(nlognA) = от >/ |о„ Время работы (без учёта стопора) слагается из времени Л'прохождения пути от корня до инициатора, времени У прохождения максимального пути и времени 2 прохождения пути до корня. При поиске пути Л' < d^% У < !) и / < Д ,, а при разметке Л'< Д), У < ¡) и / < /Л,. Если используется ранее построенное дерево кратчайших путей или множественная рассылка, то 2 < do.

При наличии дерева кратчайших путей можно при разметке сделать Х< do. Для этого надо, чтобы вершина становилась инициатором при получении не первого сообщения Прямо, а того, которое прошло кратчайший путь по дереву от корня. Для этого сообщение Прямо имеет булевский признак Кратчайший, который равен true при создании сообщения в корне, а затем «сбрасывается» в false, когда сообщение проходит не остовное ребро (что отмечено в его конце) или когда оно создаётся в некорневом инициаторе.

Если используется множественная рассылка для передачи сообщения Разметка от корня до инициатора, то при разметке также Х< do. В этом случае в сообщениях не нужен параметр R, описывающий путь от корня до инициатора. Инициатор сам «ловит» адресованное ему сообщение Разметка, поскольку в нём есть vfr-вектор пути, начинающийся как раз в инициаторе. В целом получаем: при поиске пути Т < du+2I)+\. при разметке Т< d,,+2l). При использовании дерева кратчайших путей или множественной рассылки: при поиске пути Т < 2с/,,+/..)+1. при разметке Т < 2d,,+l). При поиске пути N и Е экспоненциальны, а при разметке N < 1 и Е= 0(DolognA).

11. Заключение

В статье предложен общий подход к решению задач на неориентированном упорядоченном связном корневом графе коллективом автоматов, расположенных в вершинах графа и обменивающихся сообщениями по рёбрам графа. Автоматы - полуроботы, т.е. размер их памяти может расти вместе с ростом числа вершин п и числа рёбер m графа, но описание графа, вообще говоря, не помещается в память автомата. Выбрана модель максимального распараллеливания: время срабатывания автомата нулевое, а ёмкость ребра (число сообщений на нём) не ограничена. Это позволяет получать нижние оценки сложности алгоритмов решения задач.

Предложены базовые процедуры обработки сообщений, из которых строятся алгоритмы решения задач на графах. Это продемонстрировано на примерах построения остова графа, универсального «стопора», определяющего конец работы любого алгоритма, построения дерева кратчайших путей и нумерации графа. Также предложен алгоритм сбора в неограниченной памяти автомата корня полной информации о графе полуроботами некорневых вершин. Все эти алгоритмы имеют линейную сложность от и и да, и не более чем линейное число сообщений, одновременно передаваемых по ребру. Также рассмотрена задача поиска максимального пути в графе класса NP. За счёт неограниченного (экспоненциального) числа сообщений алгоритм решения этой задачи имеет линейную сложность.

Полученные результаты позволяют надеяться, что предложенная методика может успешно применяться для решения других задач на графах. Мы намереваемся в дальнейшем рассмотреть такие задачи, как построение минимального остовного дерева во взвешенном графе, построение

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

Список литературы

[1]. И. Бурдонов, А. Косачев. Обход неизвестного графа коллективом автоматов. Труды ИСП РАН, том 26, вып. 2, 2014, стр. 43-86. DOI: 10.15514/ISPRAS-2014-26(2)-2

[2]. И. Бурдонов, А. Косачев. Исследование графа взаимодействующими автоматами. «Вестник Томского государственного университета. Управление, вычислительная техника и информатика», №3,2014, стр. 67-75.

[3]. И. Бурдонов, А. Косачев. Обход неизвестного графа коллективом автоматов. Недетерминированный случай. Труды ИСП, том 27, вып. 1, 2015, стр. 51-68. DOI: 10.15514ASPRAS-2015-27( 1 )-4

[4]. И.Б. Бурдонов, A.C. Косачев., В.В. Кулямин. Исследование графа набором автоматов. "Программирование", 2015, №6, стр. 3-8.

[5]. И.Б. Бурдонов, A.C. Косачев. Исследование графов коллективом двигающихся автоматов. "Программная инженерия", 2016, том 7, № 12, стр. 559-567.

[6]. И.Б.Бурдонов, A.C. Косачев. Построение прямого и обратного остовов автоматами на графе. Труды ИСП РАН, том 26, вып. 6,2014, стр. 57-62. DOI: 10.15514ASPRAS-2014-26(6)-4

[7]. И.Б.Бурдонов, А.С.Косачев, В.В.Кулямин. Параллельные вычисления автоматами на прямом и обратном остовах графа. Труды ИСП РАН, том 26, вып. 6, 2014, стр. 63-66. DOI: 10.15514/ISPRAS-2014-26(6)-5

[8]. И.Б. Бурдонов, A.C. Косачев, В.В. Кулямин. Параллельные вычисления на графе. "Программирование", 2015, №1, стр. 3-20.

[9]. И. Бурдонов, А. Косачев. Мониторинг динамически меняющегося графа. Труды ИСП РАН, том 27, вып. 1,2015, стр. 69-96. DOI: 10.15514/ISPRAS-2015-27(l)-5

[10]. И. Бурдонов, А. Косачев. Параллельные вычисления на динамически меняющемся графе. Труды ИСП РАН, том 27(2), 2015, стр. 189-220. DOI: 10.15514/ISPRAS-2015-27(2)-12

[11]. И.Б. Бурдонов, A.C. Косачев. Исследование ориентированного графа коллективом неподвижных автоматов. "Программная инженерия", 2017, том 8, № 1, стр. 16-25.

[12]. И.Б.Бурдонов, А.С.Косачев, В.В.Кулямин. Неизбыточные алгоритмы обхода ориентированных графов. Недетерминированный случай. // Программирование. — 2004. — №1,— С. 2-17.

[13]. И. Бурдонов, А. Косачев. Размер памяти для хранения упорядоченного корневого графа. Труды ИСП РАН, том 29, вып. 2, 2017, стр. хх-хх. DOI: 10.15514ASPRAS-2017-29(2)-1

[14]. И.Б. Бурдонов, A.C. Косачев. Исследование графа автоматом. "Программная инженерия", 2016, №11, стр. 498-508.

[15]. И.Б.Бурдонов. Обход неизвестного ориентированного графа конечным роботом. "Программирование", 2004, №4, стр. 11-34.

[16]. И.Б.Бурдонов. Проблема отката по дереву при обходе неизвестного ориентированного графа конечным роботом. "Программирование", 2004, №6, стр.6-29.

[17]. David Peleg. Distributed computing — A Locality-sensitive approach. SIAM Monographs on Discrete Mathematics and Applications. 2000, 359 pp.

[18]. Garey, Michael R.; Johnson, David S. (1979), Computers and Intractability: A Guide to the Theory of NP-Completeness, W. H. Freeman, ISBN 0-7167-1045-5.

A general approach to solving problems on graphs by collective automata

I.B. Burdonov <[email protected]> A.S. Kossatchev <[email protected]> Institute for System Programming of the Russian Academy of Sciences, 25, Alexander Solzhenitsyn st., Moscow, 109004, Russia

Abstract. We propose a general method to solve graph problems by a set of automata (computational agents) located in vertices of undirected ordered connected rooted graph and communicating by passing messages along graph edges. The automata are semi-robots, i.e., their internal memory size is sufficient to store values depending on the number of vertices and edges of the graph (n and m, correspondingly) but is too small to store the complete graph description. Section 2 presents classification of graph-based distributed computational models depending on internal memory size of vertex automaton, vertex automaton operation time, and edge capacity (the number of messages that are passing along an edge simultaneously). We choose for further use the model of maximum parallelism, having zero automaton operation time and unbounded edge capacity. It allows to obtain lower complexity bounds on distributed graph problems. Section 3 describes algorithm complexity assessment rules. Section 4 presents basic message processing procedures and message classification according to paths passed by them and methods of message processing by vertex automaton. We propose to construct algorithms solving graph problems on the base of the procedures considered, and present some examples in further sections. Sections 5-9 describe distributed algorithms for spanning tree construction, for task termination detection (based on detection of absence of messages used by the task), for shortest paths tree construction, for graph vertices enumeration, for collecting graph structure information in the root automaton memory (if it is unbounded). The algorithms proposed has linear time complexity in n and m, and use linear in n and m number of messages. Section 10 considers construction of maximum weight path in a weighted graph, which is the NP problem. We propose the algorithm that for the sake of using unbounded number of messages can solve this problem in linear time in n and m. The conclusion summarizes the paper and draws directions of further research: constructing algorithms for other graph problems and generalization of the approach to directed, non-deterministic and dynamic graphs.

Keywords: undirected graphs; graph problems; asynchronous distributed systems; distributed algorithms.

DOI: 10.15514/ISPRAS-2017-29(2)-2

For citation: Burdonov I.B., Kossatchev A.S. A general approach to solving problems on graphs by collective automata. Trudy ISP RAN/Proc. ISP RAS, vol. 29, issue 2, 2017, pp. 27-76. DOI: 10.15514/ISPRAS-2017-29(2)-2

References

[1]. I. Burdonov, A. Kosachev. Graph learning by a set of automata. Trudy ISP RAN/Proc. ISP RAS, vol. 26, issue 2, 2014, pp. 43-86 (in Russian). DOI: 10.15514/ISPRAS-2014-26(2)-2

[2]. I. Burdonov, A. Kosachev. Analysis of a Graph by a Set of Interacting Automata. «Vestnik Tomskogo gosudarstvennogo universiteta. Upravlenie, vychislitel'naja tehnika i informatika» [Tomsk State University. Journal of Control and Computer Science], №3, 2014, pp. 67-75. (in Russian).

[3]. I. Burdonov, A. Kosachev. Graph learning by a set of automata. The nondeterministic case. Trudy ISP RAN/Proc. ISP RAS, vol. 27, issue 1,2015, pp. 51-68, (in Russian). DOI: 10.15514/ISPRAS-2015-27(1 >4

[4]. I.B. Bourdonov, A.S. Kossatchev, V.V. Kulyamin. Analysis of a Graph by a Set of Automata. Programming and Computer Software, Vol. 41, No. 6,2015, pp. 307-310. DOI: 10.1134/S0361768815060031

[5]. I.B. Burdonov, A.S. Kosachev. Analysis of a Graph by a Set of Moving Automata. "Programmnaja inzhenerija" [Software Engineering], 2016, Vol. 7, № 12, pp. 559-567, (in Russian).

[6]. I.B.Burdonov, A.S. Kosachev. Building direct and back spanning trees by automata on a graph. Trudy ISP RAN/Proc. ISP RAS, vol. 26, issue 6, 2014, pp. 57-62, (in Russian). DOI: 10.15514/ISPRAS-2014-26(6)-4

[7]. I.B.Burdonov, A.S.Kosachev, V.V.Kuljamin. Parallel calculations by automata on direct and back spanning trees of a graph. Trudy ISP RAN/Proc. ISP RAS, vol. 26, issue 6,2014, pp. 63-66 (in Russian). DOI: 10.15514/ISPRAS-2014-26(6)-5

[8]. I.B. Bourdonov, A.S. Kossatchev, V.V. Kulyamin. Parallel Computations on a Graph. Programming and Computer Software, Vol. 41, No. 1, 2015, pp. 1-13. DOI: 10.1134/S0361768815010028

[9]. I. Burdonov, A. Kosachev. Monitoring of dynamically changed graph. Trudy ISP RAN/Proc. ISP RAS, vol. 27, issue 1, 2015, pp. 69-96 (in Russian). DOI: 10.15514/ISPRAS-2015-27(1 >5

[10]. I. Burdonov, A. Kosachev. Parallel Calculations on Dynamic Graph. Trudy ISP RAN/Proc. ISP RAS, vol. 27, issue 2, 2015, pp. 189-220 (in Russian). DOI: 10.15514/ISPRAS-2015-27(2)-12

[11]. I.B. Burdonov, A.S. Kosachev. Analysis of an Oriented Graph by a Set of Motionless Automata. "Programmnaja inzhenerija" [Software Engineering], 2017, Vol. 8, № 1, pp. 16-25, (in Russian).

[12]. I. B. Bourdonov, A.S. Kossatchev, V V. Kuliamin. Irredundant Algorithms for Traversing Directed Graphs: The Nondeterministic Case. Programming and Computer Software, Vol. 30, No. 1,2004, pp. 2-17. DOI: 10.1023/A:1025733107700

[13]. I. Burdonov, A. Kosachev. Size of the memory for storage of ordered rooted graph. Trudy ISP RAN/Proc. ISP RAS, vol. 29, issue 2, 2017, pp. xx-xx (in Russian). DOI: 10.15514/ISPRAS-2017-29(2)-l

[14]. I.B. Burdonov, A.S. KosachevAnalysis of a Graph by an Automaton. "Programmnaja inzhenerija" [Software Engineering], 2016, №11, pp. 498-508, (in Russian).

[15]. I.B. Bourdonov. Traversal of an Unknown Directed Graph by a Finite Robot. Programming and Computer Software, Vol. 30, No. 4, 2004, pp. 188-203. DOI: 10.1023/B:PACS.0000036417.58183.64

[16]. I. B. Bourdonov. Backtracking Problem in the Traversal of an Unknown Directed Graph by a Finite Robot. Programming and Computer Software, Vol. 30, No. 4, 2004, pp. 305-322. DOI: 10.1023/B:PACS.0000049509.66710.3a

[17]. David Peleg. Distributed computing — A Locality-sensitive approach. SIAM Monographs on Discrete Mathematics and Applications. 2000, 359 pp.

[18]. Garey, Michael R.; Johnson, David S. (1979), Computers and Intractability: A Guide to the Theory of NP-Completeness, W. H. Freeman, ISBN 0-7167-1045-5.