Часть 2 Фундаментальные алгоритмы 1 глава

 

6 Волновые алгоритмы и алгоритмы обхода

 

При разработке распределенных алгоритмов для различных приложений часто в качестве подзадач возникает несколько общих проблем для сетей процессов. Эти элементарные задачи включают в себя широковещательную рассылку информации - broadcasting (например, посылка начального или заключительного сообщения), достижение глобальной синхронизации между процессами, запуск выполнения некоторого события в каждом процессе, или вычисление функции, входные данные которой распределены между процессами. Эти задачи всегда решаются путем пересылки сообщений согласно некоторой, зависящей от топологии схеме, которая гарантирует участие всех процессов. Эти задачи настолько фундаментальны, что можно дать решения более сложных задач, таких как выбор (Глава 7), обнаружение завершения (Глава 8), или взаимное исключение, в которых связь между процессами осуществляется только через эти схемы передачи сообщений.

Важность схем передачи сообщений, называемых далее волновыми алгоритмами, оправдывает их рассмотрение отдельно от конкретного прикладного алгоритма, в который они могут быть включены. В этой главе формально определяются волновые алгоритмы (Подраздел 6.1.1) и доказываются некоторые общие результаты о них (Подраздел 6.1.2). Замечание о том, что те же самые алгоритмы могут использоваться для всех основных задач, изложенных выше, т.е. широковещание, синхронизация и вычисление глобальных функций, будет формализовано (Подразделы 6.1.3-5). В Разделе 6.2 представлены некоторые широко используемые волновые алгоритмы. В Разделе 6.3 рассматриваются алгоритмы обхода; это волновые алгоритмы, в которых все события вычисления алгоритма совершенно упорядочены каузальным отношением. В Разделе 6.4 представлены несколько алгоритмов для распределенного поиска в глубину.

Несмотря на то, что волновые алгоритмы обычно используются как подзадачи в более сложных алгоритмах, их полезно рассматривать отдельно. Во-первых, введение новых понятий облегчает последующее рассмотрение более сложных алгоритмов, т.к. свойства их подзадач уже изучены. Во-вторых, определенные задачи в распределенных вычислениях могут быть решены с помощью универсальных конструкций, в качестве параметров которых могут использоваться конкретные волновые алгоритмы. Тот же метод может использоваться для получения алгоритмов для различных сетевых топологий или для различных предположений о начальном знании процессов. Эта глава основана на [Tel91b, Раздел 4.2], где понятие волновых алгоритмов изучается под названием общие алгоритмы.

 

6.1 Определение и использование волновых алгоритмов

В пределах этой главы считается, если не указано обратное, что сетевая топология фиксирована (не происходит топологических перемен), не ориентирована (каждый канал передает сообщения в обоих направлениях) и связна (существует путь между любыми двумя процессами). Множество всех процессов обозначено через P, а множество каналов - через E. Как и в предыдущих главах, предполагается, что система использует асинхронную передачу сообщений и не существует понятия глобального или реального времени. Алгоритмы из этой главы также могут быть использованы в случае синхронной передачи сообщений (возможно с некоторыми изменениями во избежание тупиков) или с часами глобального времени, если они доступны. Однако некоторые более общие теоремы в этих случаях неверны; см. Упражнение 6.1.

 

6.1.1  Определение волновых алгоритмов

Как отмечалось в Главе 2, распределенные алгоритмы обычно допускают большой набор возможных вычислений благодаря недетерминированности как в процессах, так и в подсистеме передачи. Вычисление - это набор событий, частично упорядоченных отношением каузального (причинно-следственного) предшествования p; см. Определение 2.20. Количество событий в вычислении C обозначается через |C|, а подмножество событий, происходящих в процессе p, обозначается через C_p. Считается, что существует особый тип внутренних событий, называемый decide (принять решение); в алгоритмах этой главы такое событие представляется просто утверждением decide. Волновой алгоритм обменивается конечным числом сообщений и затем принимает решение, которое каузально зависит от некоторого события в каждом процессе.

Определение 6.1 Волновой алгоритм - это распределенный алгоритм, который удовлетворяет следующим трем требованиям:

a) Завершение. Каждое вычисление конечно:

                            " C: |C| < ¥

b) Принятие решения. Каждое вычисление содержит хотя бы одно событие decide:

                            " C: $ e Î C: e - событие decide.

c) Зависимость. В каждом вычислении каждому событию decideкаузально предшествует какое-либо событие в каждом процессе:

              " C: " e Î C: (e - событие decide Þ  " q Î P $ f Î C_q : f p e).

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

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

1) Централизация. Алгоритм называется централизованным, если в каждом вычислении должен быть ровно один инициатор, и децентрализованным, если алгоритм может быть запущен произвольным подмножеством процессов. Централизованные алгоритмы также называют алгоритмами одного источника, а децентрализованные - алгоритмами многих источников. Как видно из Таблицы 6.20, централизация существенно влияет на сложность волновых алгоритмов.

2) Топология. Алгоритм может быть разработан для конкретной топологии, такой как кольцо, дерево, клика и т.д.; см. Подраздел 2.4.1 и Раздел B.2.

3) Начальное знание. Алгоритм может предполагать доступность различных типов начального знания в процессах; см. Подраздел 2.4.4. Примеры требуемых заранее знаний:

(a) Идентификация процессов. Каждому процессу изначально известно свое собственное уникальное имя.

(b) Идентификация соседей. Каждому процессу изначально известны имена его соседей.

(c) Чувство направления (sense of direction). См. Раздел B.3.

4) Число решений. Во всех волновых алгоритмах этой главы в каждом процессе происходит не более одного решения. Количество процессов, которые выполняют событие decide, может быть различным; в некоторых алгоритмах решение принимает только один процесс, в других - все процессы. В древовидном алгоритме (Подраздел 6.2.2) решают ровно два процесса.

5) Сложность. Меры сложности, рассматриваемые в этой главе, это количество передаваемых сообщений (message complexity), количество передаваемых бит (bit complexity) и время, необходимое для одного вычисления (определено в Разделе 6.4). См. также Подраздел 2.4.5.

Каждый волновой алгоритм в этой главе будет дан вместе с используемыми переменными и, в случае необходимости, с информацией, передаваемой в сообщениях. Большинство этих алгоритмов посылают «пустые сообщения», без какой-либо реальной информации: сообщения передают причинную связь, а не информацию. Алгоритмы 6.9, 6.11, 6.12 и 6.18 используют сообщения для передачи нетривиальной информации. Алгоритмы 6.15 и 6.16/6.17 используют различные типы сообщений; при этом требуется, чтобы каждое сообщение содержало 1-2 бита для указания типа сообщения.

Обычно при применении волновых алгоритмов в сообщение могут быть включены дополнительные переменные и другая информация.[AK1] Многие приложения используют одновременное или последовательное распространение нескольких волн; в этом случае в сообщение должна быть включена информация о волне, которой оно принадлежит. Кроме того, процесс может хранить дополнительные переменные для управления волной, или волнами, в которых он в настоящее время активен.

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

 

6.1.2 Элементарные результаты о волновых алгоритмах

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

Структурные свойства волн. Во-первых, каждому событию в вычислении предшествует событие в инициаторе.

Лемма 6.2 Для любого события e Î C существует инициатор p и событие f в C_p такое, что f p e.

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

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

Лемма 6.3 Пусть C - волна с одним инициатором p; и пусть для каждого не-инициатора qfather_q - это сосед q, от которого q получает сообщение в своем первом событии. Тогда граф T = (P, E_T), где E_T = {qr: q ¹ p & r = father_q } - остовное дерево, направленное к p.

Доказательство. Т.к. количество вершин T превышает количество ребер на 1, достаточно показать, что T не содержит циклов. Это выполняется, т.к. если e_q - первое событие в q, из того, что qr Î E_T следует, что e_r p e_q, а p - отношение частичного порядка.

В качестве события f в пункте (3) Определения 6.1 может быть выбрано событие посылки сообщения всеми процессами q, кроме того, где происходит событие decide.

Лемма 6.4 Пусть C - волна, а d_p Î C - событие decide в процессе p. Тогда

                " q ¹ p: $ f Î C_q: (f p d_p & f - событие send)

Доказательство. Т.к. C - это волна, существует событие f ÎC_q, которое каузально предшествует d_p; выберем в качестве f последнее событие C_q, которое предшествует d_p. Чтобы показать, что f - событие send, отметим, что из определения каузальности (Определение 2.20) следует, что существует последовательность (каузальная цепочка)

f = e₀, e₁,..., e_k = d_p,

такая, что для любого i < k, e_i и e_i+1 - либо последовательные события в одном процессе, либо пара соответствующих событий send-receive. Т.к. f - последнее событие в q, которое предшествует d_p, e₁ происходит в процессе, отличном от q, следовательно f - событие send.

 

Рис.6.1 Включение процесса в неиспользуемый канал.

 

Нижние границы сложности волн. Из леммы 6.4 непосредственно следует, что нижняя граница количества сообщений, которые передаются в волне, равна N-1. Если событие decide происходит в единственном инициаторе волны (что выполняется всегда в случае алгоритмов обхода), граница равна N сообщениям, а волновые алгоритмы для сетей произвольной топологии используют не менее |E| сообщений.

Теорема 6.5 Пусть C - волна с одним инициатором p, причем событие decide d_p происходит в p. Тогда в C передается не менее N сообщений.

Доказательство. По лемме 6.2 каждому событию в C предшествует событие в p, и, используя каузальную последовательность, как в доказательстве леммы 6.4, нетрудно показать, что в p происходит хотя бы одно событие send. По лемме 6.4 событие send также происходит во всех других процессах, откуда количество посылаемых сообщений составляет не меньше N.

Теорема 6.6 Пусть A - волновой алгоритм для сетей произвольной топологии без начального знания об идентификации соседей. Тогда A передает не менее |E| сообщений в каждом вычислении.

Доказательство. Допустим, A содержит вычисление C, в котором передается менее |E| сообщений; тогда существует канал xy, по которому в C не передаются сообщения; см. Рис.6.1. Рассмотрим сеть G¢, полученную путем включения одного узла z в канал между x и y. Т.к. узлы не имеют знания о соседях, начальное состояние x и y в G¢ совпадает с их начальным состоянием в G. Это верно и для всех остальных узлов G. Следовательно, все события C могут быть применены в том же порядке, начиная с исходной конфигурации G¢, но теперь событию decide не предшествует событие в z.

В Главе 7 будет доказана улучшенная нижняя граница количества сообщений децентрализованных волновых алгоритмов для колец и сетей произвольной топологии без знания о соседях; см. Заключение 7.14 и 7.16.

 

6.1.3 Распространение информации с обратной связью

В этом подразделе будет продемонстрировано применение волновых алгоритмов для случая, когда некоторая информация должна быть передана всем процессам и определенные процессы должны быть оповещены о завершении передачи. Эта задача распространения информации с обратной связью (PIF - propagation of information with feedback) формулируется следующим образом [Seg83]. Формируется подмножество процессов из тех, кому известно сообщение M (одно и то же для всех процессов), которое должно быть распространено, т.е. все процессы должны принять M. Определенные процессы должны быть оповещены о завершении передачи; т.е. должно быть выполнено специальное событие notify, причем оно может быть выполнено только когда все процессы уже получили сообщение M. Алгоритм должен использовать конечное количество сообщений.

Оповещение в PIF-алгоритме можно рассматривать как событие decide.

Теорема 6.7 Каждый PIF- алгоритм является волновым алгоритмом.

Доказательство. Пусть P - PIF-алгоритм. Из формулировки задачи каждое вычисление P должно быть конечным и в каждом вычислении должно происходить событие оповещения (decide). Если в некотором вычислении P происходит оповещение d_p, которому не предшествует никакое событие в процессе q, тогда из Теоремы 2.21 и Аксиомы 2.23 следует, что существует выполнение P, в котором оповещение происходит до того, как q принимает какое-либо сообщение, что противоречит требованиям.

Мы должны иметь в виду, что теорема 2.21 выполняется только для систем с асинхронной передачей сообщений; см. Упражнение 6.1.

Теорема 6.8 Любой волновой алгоритм может использоваться как PIF- алгоритм.

Доказательство. Пусть A - волновой алгоритм. Чтобы использовать A как PIF-алгоритм, возьмем в качестве процессов, изначально знающих M, стартеры (инициаторы) A. Информация M добавляется к каждому сообщению A. Это возможно, поскольку по построению стартеры A знают M изначально, а последователи не посылают сообщений, пока не получат хотя бы одно сообщение, т.е. пока не получат M. Событию decide в волне предшествуют события в каждом процессе; следовательно, когда оно происходит, каждый процесс знает M, и событие decide можно считать требуемым событием notify в PIF-алгоритме.

Построенный PIF-алгоритм имеет такую же сложность сообщений, как и алгоритм A и обладает всеми другими качествами A, описанными в Подразделе 6.1.1, кроме битовой сложности. Битовая сложность может быть уменьшена путем добавления M только к первому сообщению, пересылаемому через каждый канал. Если w - количество бит в M, битовая сложность полученного алгоритма превышает битовую сложность A на w*|E|.

 

6.1.4 Синхронизация

В этом разделе будет рассмотрено применение волновых алгоритмов для случаев, когда должна быть достигнута глобальная синхронизация процессов. Задача синхронизации (SYN) формулируется следующим образом [Fin79]. В каждом процессе q должно быть выполнено событие a_q, и в некоторых процессах должны быть выполнены события b_p, причем все события a_q должны быть выполнены по времени раньше, чем будет выполнено какое-либо событие b_p. Алгоритм должен использовать конечное количество сообщений.

В SYN-алгоритмах события b_p будут рассматриваться как события decide.

Теорема 6.9 Каждый SYN- алгоритм является волновым алгоритмом.

Доказательство. Пусть S - SYN-алгоритм. Из формулировки задачи каждое вычисление S должно быть конечным и в каждом вычислении должно происходить событие b_p (decide). Если в некотором вычислении S происходит событие b_p, которому каузально не предшествует a_q, тогда (по Теореме 2.21 и Аксиоме 2.23) существует выполнение S, в котором b_p происходит ранее a_q.

Теорема 6.10 Любой волновой алгоритм может использоваться как SYN- алгоритм.

Доказательство. Пусть A - волновой алгоритм. Чтобы преобразовать A в SYN-алгоритм, потребуем, чтобы каждый процесс q выполнял a_q до того, как q пошлет сообщение в A или примет решение в A. Событие b_p происходит после события decide в p. Из леммы 6.4, каждому событию decide каузально предшествует a_q для любого q.

Построенный SYN-алгоритм имеет такую же сложность сообщений, как и A, и обладает всеми другими свойствами A, описанными в Подразделе 6.1.1.

 

6.1.5 Вычисление функций инфимума

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

Если (X, £) - частичный порядок, то c называют инфимумом a и b, если c £ a, c £ b, и " d: (d £ a & d £ b Þ d £ c). Допустим, что X таково, что инфимум всегда существует; в этом случае инфимум является единственным и обозначается как a Ù b. Т.к. Ù - бинарный оператор, коммутативный (a Ù b = b Ù a) и ассоциативный (т.е. a Ù (b Ù c) = (a Ù b) Ù c), операция может быть обобщена на конечные множества:

inf { j₁,..., j _k} = j₁ Ù... Ù j _k .

Задача вычисления инфимума формулируется следующим образом. Каждый процесс q содержит вход j_q, являющийся элементом частично упорядоченного множества X. Потребуем, чтобы определенные процессы вычисляли значение inf {j_q : q Î P} и чтобы эти процессы знали, когда вычисление завершается. Они записывают результат вычисления в переменную out и после этого не могут изменять ее значение.

Событие write, которое заносит значение в out, рассматривается в INF-алгоритме как событие decide.

Теорема 6.11 Каждый INF- алгоритм является волновым алгоритмом.

Доказательство. Пусть I - INF-алгоритм. Предположим, что существует вычисление C алгоритма I с начальной конфигурацией ¡, в котором p записывает значение J в out_p и этому событию write не предшествует никакое событие в q. Рассмотрим начальную конфигурацию ¡¢, которая аналогична ¡ за исключением того, что q имеет другой вход j_q¢, выбранный так, что j_q¢ < J. Так как никакое применение входа q не предшествует каузально событию write процесса p в C, все события C, предшествующие событию write, применимы в том же порядке, начиная с ¡¢. В полученном вычислении p записывает ошибочный результат J, так же как в C.

Теорема 6.12 Любой волновой алгоритм может быть использован для вычисления инфимума.

Доказательство. Допустим, что дан волновой алгоритм A. Назначим каждому процессу q дополнительную переменную v_q, которой придадим начальное значение j_q. Во время волны эти переменные переприсваиваются следующим образом. Всякий раз, когда процесс q посылает сообщение, текущее значение v_q включается в сообщение. Всякий раз, когда процесс q получает сообщение со значением v, v_q присваивается значение v_q Ù v. Когда в процессе p происходит событие decide, текущее значение v_p заносится в out_p.

Теперь нужно показать, что в результат заносится правильное значение. Обозначим правильный ответ через J, т.е. J = inf { j_q: q Î P}. Для события a в процессе q обозначим через v^(a) значение v_q сразу после выполнения a. Т.к. начальное значение v_q равно j_q, и в течение волны оно только уменьшается, неравенство v^(a) £ j_q сохраняется для каждого события a в q. Из присваивания v следует, что для событий a и b, a p b Þ v^(a) ³ v^(b). Кроме того, т.к. v всегда вычисляется как инфимум двух уже существующих величин, неравенство J £ v выполняется для всех величин в течение волны. Таким образом, если d - событие decide в p, значение v^(d) удовлетворяет неравенству J £ v^(d) и, т.к. событию d предшествует хотя бы одно событие в каждом процессе q, v^(d) £ j_q для всех q. Отсюда следует, что J = v^(d).

Построенный INF-алгоритм обладает всеми свойствами A, кроме битовой сложности, поскольку к каждому сообщению A добавляется элемент X. Понятие функции инфимума может показаться довольно абстрактным, но фактически многие функции могут быть выражены через функцию инфимума, как показано в [Tel91b, Теорема 4.1.1.2].

Аксиома 6.13 (Теорема об инфимуме) Если * - бинарный оператор на множестве X, причем он:

(1) коммутативен, т.е. a * b = b * a,

(2) ассоциативен, т.е. (a * b) * c = a * (b * c), и

(3) идемпотентен, т.е. a * a = a

то существует отношение частичного порядка £ на X такое, что * - функция инфимума.

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

Заключение 6.14 &, Ú, min, max, НОД, НОК, Ç и È величин, локальных по отношению к процессам, могут быть вычислены за одну волну.

Вычисление операторов, которые являются коммутативными и ассоциативными, но не идемпотентны, рассматривается в Подразделе 6.5.2.

 

 

6.2 Волновые алгоритмы

В следующих трех разделах будет представлено несколько волновых алгоритмов и алгоритмов обхода. Все тексты алгоритмов даны для процесса p.

6.2.1 Кольцевой алгоритм

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

Алгоритм является централизованным; инициатор посылает сообщение < tok > (называемое маркером) вдоль цикла, каждый процесс передает его дальше и когда оно возвращается к инициатору, инициатор принимает решение; см. Алгоритм 6.2.

 

Для инициатора:

     begin send < tok > to Next_p; receive < tok >; decide end

Для не-инициатора:

     begin receive < tok >; send < tok > to Next_p end

 

Алгоритм 6.2 Кольцевой алгоритм.

 

Теорема 6.15 Кольцевой алгоритм (Алгоритм 6.2) является волновым алгоритмом.

Доказательство. Обозначим инициатор через p₀. Так как каждый процесс посылает не более одного сообщения, алгоритм передает в целом не больше N сообщений.

За ограниченное количество шагов алгоритм достигает заключительной конфигурации. В этой конфигурации p₀ уже переслал маркер, т.е. выполнил оператор send в своей программе. Кроме того, ни одно сообщение < tok > не передается ни по одному каналу, иначе оно может быть получено и конфигурация не будет заключительной. Также, ни один процесс, кроме p₀, не «задерживает» маркер (т.е. получил, но не передал дальше < tok >), иначе процесс может послать < tok > и конфигурация не будет конечной. Следовательно, (1) p₀ отправил маркер, (2) для любого p, пославшего маркер, Next_p получил маркер, и (3) каждый p ¹ p₀, получивший маркер, отправил маркер. Из этого и свойства Next следует, что каждый процесс отправил и получил маркер. Т.к. p₀ получил маркер и конфигурация конечна, p₀ выполнил оператор decide.

Получение и отправка < tok > каждым процессом p ¹ p₀ предшествует получению маркера процессом p₀, следовательно, условие зависимости выполнено.

 

6.2.2 Древовидный алгоритм

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

 

var rec_p[q] for each q Î Neigh_p: boolean init false;

  (* rec_p[q] = true, если p получил сообщение от q *)

 

begin while # {q: rec_p[q] is false } > 1 do

       begin receive < tok > from q; rec_p[q]:= true end;

       (* Теперь остался один q₀, для которого rec_p[q₀] = false *)

       send < tok > to q₀ with rec_p[q₀] is false;

  x: receive < tok > from q₀; rec_p[q₀]:= true;

       decide

       (* Сообщить другим процессам о решении:

       forall q Î Neigh_p, q ¹ q₀ do send < tok > to q *)

End

 

Алгоритм 6.3 Древовидный алгоритм.

Чтобы показать, что этот алгоритм является волновым, введем некоторые обозначения. Пусть f_pq - событие, где p посылает сообщение q, а g_pq - событие, где q получает сообщение от p. Через T_pq обозначим подмножество процессов, которые достижимы из p без прохождения по дуге pq (процессы на стороне p дуги pq); см. Рис.6.4.

Предыдущая45678910111213141516171819Следующая

Поделиться:

Воспользуйтесь поиском по сайту: