Викиконспекты - Вклад участника [ru]

Алгоритмы взаимного исключения

2018-10-07T18:31:44Z

188.227.78.184: fix typo

==Определения==
{{Определение
|definition=
'''Взаимное исключение''' (англ. ''mutual exclusion'') — свойство построения параллельных программ, которое используется в целях предотвращения состояния гонки (англ. ''race condition''); Оно требует, чтобы один поток исполнения никогда не входил в критическую секцию одновременно с тем, как другой параллельный поток выполнения вошел в свою критическую секцию.
}}
То есть критические секции не могут выполняться параллельно: <tex>\forall i,j:i \neq j \Rightarrow CS_i \rightarrow CS_j \vee CS_j \rightarrow CS_i </tex>. Это значит, что выполнение критических секций будет линеаризуемо. Это требование корректности протокола взаимной блокировки.

{{Определение
|definition=
'''Критическая секция''' (англ. ''critical section'') — участок исполняемого кода программы, в котором производится доступ к общему ресурсу (данным или устройству), который не должен быть одновременно использован более чем одним потоком исполнения.
}}
==Проблема==
Проблема, с которой связаны взаимные исключения, является проблемой совместного использования ресурсов: как можно управлять доступом нескольких процессов к общему ресурсу, когда каждый процесс нуждается в исключительном контроле над этим ресурсом при выполнении своей работы? Решение — делать доступным общий ресурс только тогда, когда процесс находится в определенном сегменте кода, называемом критической секцией. И контролировать доступ к общему ресурсу, контролируя каждое взаимное выполнение той части программы, в которой будет использоваться ресурс.

Успешное решение этой проблемы должно иметь по крайней мере три свойства:

Условие корректности:
#'''Взаимное исключение''' (англ. ''mutual exclusion''): только один поток может быть в критической секции.
Условия прогресса:
#'''Отсутствие взаимоблокировок''' (англ. ''deadlocks''): если несколько потоков пытаются войти в критическую секцию, то хотя бы один из них должен войти в критическую секцию за конечное время.
#'''Отсутствие голодания''' (англ. ''starvation-freedom''): если какой-то поток пытается войти в критическую секцию, то он войдет в критическую секцию за конечное время. Может быть последовательно усиленно, превращаясь в условие честности (англ. ''fairness'').
#*Квадратичное ожидание (англ. ''quadratic wait'') — <tex>O(n^2)</tex> операций.
#*Линейное ожидание (англ. ''linear wait'') — <tex>O(n)</tex> операций.
#*Первый пришел, первый обслужен (англ. ''first come first served'')

Требование <tex>First Come First Served (FCFS)</tex> формализуется так:
#Метод <tex>lock</tex> должен состоять из двух последовательных секций.
'''def''' lock():
'''doorway'''
'''waiting'''
#Секция <tex>doorway</tex> должны быть <tex>wait free</tex>, то есть выполняться за конечное число шагов, независимо от других потоков.
#Секция <tex>waiting</tex> должна выполнять условие: Если <tex>DW_i \Rightarrow DW_j</tex>, то <tex>res(WT_i) \Rightarrow res(WT_j)</tex>.

Каждая программа может быть разделена на четыре секции, что приводит к четырем состояниям. [[Файл: State_graph2.png|thumb|right|Порядок перехода между состояниями]]
;Non-Critical Section: Операция находится вне критической секции; этот процесс не использует или не запрашивает общий ресурс.
;Trying: Процесс пытается войти в критический раздел.
;Critical Section: В этом разделе разрешен доступ к общему ресурсу.
;Exit :Процесс выходит из критического раздела и делает доступный общий ресурс другим процессам.

Если процесс хочет войти в критический раздел, он должен сначала выполнить раздел <tex>try</tex> и подождать, пока он не получит доступ к критическому разделу. После того, как процесс выполнил свой критический раздел и завершился с общими ресурсами, ему необходимо выполнить раздел выхода, чтобы освободить их для использования другими процессами. Затем процесс возвращается в некритический раздел.

==Алгоритмы взаимного исключения==

===Алгоритм Петерсона для <tex>2</tex> потоков===
Простейший алгоритм параллельного программирования для взаимного исключения потоков исполнения кода, разработанный Гарри Петерсоном в <tex>1981</tex> г.<ref name="original">G. L. Peterson: "Myths About the Mutual Exclusion Problem", ''Information Processing Letters'' 12(3) 1981, 115–116</ref> While Peterson's original formulation worked with only two processes, the algorithm can be generalized for more than two.</ref> Хотя изначально был сформулирован для 2-поточного случая, алгоритм может быть обобщён для произвольного количества потоков. Гарантирует взаимное исключение, отсутствие взаимной блокировки и отсутствие голодания.

Принцип работы: перед тем как начать исполнение критической секции кода, поток должен вызвать процедуру <tex>lock()</tex> со своим номером в качестве параметра. Она должна организовать ожидание потоком своей очереди входа в критическую секцию. После исполнения критической секции и выхода из неё поток вызывает другую процедуру <tex>unlock()</tex>, после чего уже другие потоки смогут войти в критическую область. Рассмотрим реализацию этого принципа алгоритмом Петерсона для двух потоков.

'''threadlocal int''' id // 0 or 1
'''shared int''' want[2]
'''shared int''' victim
'''def''' lock:
want[id] = true
victim = id
'''while''' want[1-id] '''and'''
victim == id:
'''pass'''

'''def''' unlock:
want[id] = false

===Корректность алгоритма===
=====Взаимное исключение=====
Потоки <tex>0</tex> и <tex>1</tex> никогда не могут попасть в критическую секцию в один момент времени: если <tex>0</tex> вошёл в секцию, он установил <tex>want[0]</tex> в <tex>true</tex>. Тогда либо <tex>want[1] = false</tex> (тогда поток <tex>1</tex> не в критической секции), либо <tex>waiting = 1</tex> (тогда поток <tex>1</tex> пытается войти в критическую секцию и крутится в цикле), либо поток <tex>1</tex> пытается войти в критическую секцию после установки <tex>want[1] = true</tex>, но до установки <tex>waiting</tex> и цикла. Таким образом, если оба процесса находятся в критической секции, должно быть <tex> want[0] \space and \space want[1] \space and \space waiting = 0 \space and \space waiting = 1 </tex>, но такого не может быть одновременно и мы пришли к противоречию.

=====Отсутствие взаимной блокировки=====
Для того, чтобы оба процесса находились в ожидании, необходимы противоположные значения переменной <tex>waiting</tex>, что невозможно.
=====Отсутствие голодания=====
Возможна ситуация, когда один процесс будет несколько раз подряд захватывать себе критическую секцию, а другой, изъявивший желание попасть туда, будет ждать. В алгоритме Петерсона процесс не будет ждать дольше, чем один вход в критическую секцию: после выполнения <tex>unlock()</tex> и повторного захода в <tex>lock()</tex> процесс установит себя как ждущего и попадёт в цикл, который не завершится, пока не отработает другой процесс.

===Алгоритм Петерсона для <tex>N</tex> потоков===
Обобщение Алгоритм Петерсона для <tex>N</tex> потоков. Гарантирует взаимное исключение, отсутствие блокировки и отсутствие голодания. Но алгоритм не очень честный. "Невезучий" поток может ждать пока другие потоки <tex>O(N^2)</tex> раз войдут в критическую секцию (квадратичное ожидание).

'''threadlocal int''' id // 0 to N-1
'''shared int''' level[N]
'''shared int''' victim[N]
'''def''' lock:
'''for''' j = 1..N-1: //Для входа в CS надо пройти на N-1 уровней
level[id] = j //Обобщаем want на уровень j: level[id] >= j
victim[j] = id //Своя жертва на каждом уровне
'''while''' '''exist''' k: k != id '''and''' //Для прохода на следующий уровень соревнуемся со всеми другими потоками
level[k] >= j '''and'''
victim[j] == id:
'''pass'''

'''def''' unlock:
level[id] = 0

===Алгоритм Лампорта (вариант <tex>1</tex>)===
Алгоритм Лампорта – алгоритм разделения общих ресурсов между несколькими потоками обладающий взаимным исключением. Опубликован Лесли Лампортом в 1974 году. <ref>[http://lamport.azurewebsites.net/pubs/bakery.pdf? A New Solution of Dijkstra's Concurrent Programming Problem]</ref> Гарантирует взаимное
исключение, отсутствие блокировки и линейное ожидание.
=====Аналогия=====
Алгоритм реализует идею пекарни с устройством, выдающим номерки у входа. Каждому входящему покупателю выдаётся номерок на единицу больше предыдущего. Общий счётчик показывает номер обслуживаемого в данный момент клиента. Все остальные покупатели ждут, пока не закончат обслуживать текущего клиента и табло покажет следующий номер. После того как клиент сделает покупку и сдаст свой номерок, служащий увеличивает на единицу допустимые для выдачи устройством у входа номера. Если совершивший покупку клиент захочет снова что-нибудь купить, он должен будет снова взять номерок у входа и встать в общую очередь.

Пусть покупатели это потоки, получившие номера <tex>i</tex>.

=====Критическая секция=====
Когда поток хочет войти в критическую секцию, он должен проверить номера <tex>n</tex>, полученные другими потоками, и убедиться, что у него меньший номер. В случае совпадения <tex>n</tex> у двух или нескольких потоков, в критическую секцию входит поток с наименьшим номером потока <tex>i</tex>.
(na, ia) < (nb, ib),
что эквивалентно:
(na < nb) or ((na == nb) and (ia < ib))
Когда поток заканчивает работу в критической секции, он освобождает номер ''n'' и выходит из критической секции.

=====Псевдокод=====

'''threadlocal int''' id // 0 to N-1
'''shared boolean''' want[N] '''init''' false
'''shared int''' label[N] '''init''' 0
'''def''' lock:
want[id] = true
label[id] = '''max'''(label) + 1
'''while''' '''exists''' k: k != id '''and'''
want[k] '''and'''
(label[k], k) < (label[id], id) :
'''pass'''
'''def''' unlock:
want[id] = false

Обладает свойством первый пришел, первый обслужен (<tex>FCFS</tex>), за счет того, что поток <tex>P</tex> выполнивший <tex>doorway (DW)</tex> до потока <tex>Q</tex>, имеет более ранний номер в очереди. Но метки должны быть бесконечными (их можно заменить на конечные метки).

=====Взаимное исключение=====
Допустим, что два потока одновременно в <tex>CS</tex>. Значит поток <tex>id</tex> зашел в <tex>CS</tex> последним, в то время как другой поток <tex>k != id</tex> уже был в <tex>CS</tex>. Но зайти в <tex>CS</tex> можно если <tex>want[k] == false</tex> или <tex>(label[k], k) > (label[id], id)</tex>.

'''Случай 1:''' <tex>want[k] == false</tex>
*Противоречие.

'''Случай 2:''' <tex>(label[k], k) >= (label[id], id)</tex>
*Но значит другой поток зашел по <tex>want[id] == false</tex> выполнив свой <tex>doorway</tex> до потока <tex>id</tex> - противоречие.

===Алгоритм Лампорта (вариант <tex>2</tex>)===
Еще одна реализация алгоритма Лампорта. Метки тоже могут быть бесконечными, несмотря на то, что мы их и сбрасываем при выходе из критической секции.

'''threadlocal int''' id // 0 to N-1
'''shared boolean''' want[N] '''init''' false
'''shared int''' label[N] '''init''' 0
'''def''' lock:
want[id] = true
label[id] = '''max'''(label!='''inf''') + 1
want[id] = false
'''while''' '''exists''' k: k != id '''and'''
(want[k] '''or'''
(label[k], k) < (label[id], id)) :
'''pass'''
'''def''' unlock:
label[id] = '''inf'''

==См. также==
* [[Стек_Трайбера]]

== Источники информации ==
* [https://en.wikipedia.org/wiki/Mutual_exclusion Mutual exclusion]
* [https://en.wikipedia.org/wiki/Lamport%27s_bakery_algorithm Lamports bakery algorithm]
* [http://lamport.azurewebsites.net/pubs/bakery.pdf Original lamports bakery algorithm]
* [https://en.wikipedia.org/wiki/Peterson%27s_algorithm Petersons algorithm]

[[Категория: Параллельное программирование]]

Машина Тьюринга

2018-06-25T07:07:04Z

188.227.78.184: /* Многоленточная машина Тьюринга */

__TOC__

'''Машина Тьюринга''' (англ. ''Turing machine'') — модель абстрактного вычислителя, предложенная британским математиком Аланом Тьюрингом в 1936 году. Эта модель позволила Тьюрингу доказать два утверждения. Первое — проблема останова неразрешима, т.е. не существует такой машины Тьюринга, которая способна определить, что другая произвольная машина Тьюринга на её ленте зациклится или прекратит работу. Второе — не существует такой машины Тьюринга, которая способна определить, что другая произвольная машина Тьюринга на её ленте когда-нибудь напечатает заданный символ. В этом же году был высказан тезис Чёрча-Тьюринга, который терминах теории рекурсии формулируется как точное описание интуитивного понятия вычислимости классом общерекурсивных функций. В этой формулировке часто упоминается как просто тезис Чёрча. В терминах вычислимости по Тьюрингу тезис гласит, что для любой алгоритмически вычислимой функции существует вычисляющая её значения машина Тьюринга. В виду того, что классы частично вычислимых по Тьюрингу и частично рекурсивных функций совпадают, утверждение объединяют в единый тезис Чёрча — Тьюринга.

Неформально машина Тьюринга определяется как устройство, состоящее из двух частей:
* бесконечной одномерной ленты, разделённой на ячейки,
* головки, которая представляет собой [[Детерминированные конечные автоматы|детерминированный конечный автомат]].

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

== Определение ==
=== Определение машины ===
{{Определение
|definition=
Формально '''машина Тьюринга''' (англ. ''Turing machine'') определяется как кортеж из восьми элементов <tex>\langle \Sigma, \Pi, B, Q, Y, N, S, \delta \rangle</tex>, где
* <tex>\Sigma</tex> — алфавит, из букв которого могут состоять входные слова,
* <tex>\Pi \supset \Sigma</tex> — символы, которые могут быть записаны на ленту в процессе работы машины,
* <tex>B \in \Pi \setminus \Sigma</tex> — пробельный символ (от слова ''blank''),
* <tex>Q</tex> — множество состояний управляющего автомата,
* <tex>Y \in Q</tex> — допускающее состояние автомата,
* <tex>N \in Q</tex> — отвергающее состояние автомата,
* <tex>S \in Q</tex> — стартовое состояние автомата,
* <tex>\delta : Q \times \Pi \to Q \times \Pi \times \{ \leftarrow, \rightarrow, \downarrow \}</tex> — всюду определённая функция перехода автомата.
}}
Отметим, что существуют различные вариации данного выше определения (например, без отвергающего состояния или с множеством допускающих состояний), которые не влияют на вычислительные способности машины Тьюринга.

=== Определение процесса работы ===
Кроме формального определения самой машины требуется также формально описать процесс её работы. В определении для простоты будем предполагать, что головка в процессе работы не записывает на ленту символ <tex>B</tex>. Это не ограничивает вычислительной мощности машин Тьюринга, поскольку для каждой машины можно сопоставить аналогичную ей, но не пищущую <tex>B</tex> на ленту.
{{Определение
|id=conf
|definition=
Назовём '''конфигурацией''' машины Тьюринга тройку <tex>\langle w, q, v \rangle</tex>, где
* <tex>q \in Q</tex> — текущее состояние автомата,
* <tex>w, v \in (\Pi \setminus \{B\})^*</tex> — строки слева и справа от головки до первого пробельного символа соответственно.
}}
В данной записи головка находится над ячейкой, на которой написана первая буква <tex>v</tex> (или <tex>B</tex>, если <tex>v = \varepsilon</tex>).

В дальнейшем используются следующие обозначения: <tex>x, y, z \in \Pi</tex>, <tex>w, v \in \Pi^*</tex>
{{Определение
|definition=
Определим на конфигурациях отношение перехода <tex>\langle w_1, q_1, v_1 \rangle \vdash \langle w_2, q_2, v_2 \rangle</tex>:
* если <tex>\delta(q, x) = \langle p, y, \leftarrow \rangle</tex>, то <tex>\langle wz, q, xv \rangle \vdash \langle w, p, zyv \rangle</tex>,
* если <tex>\delta(q, x) = \langle p, y, \rightarrow \rangle</tex>, то <tex>\langle w, q, xv \rangle \vdash \langle wy, p, v \rangle</tex>,
* если <tex>\delta(q, x) = \langle p, y, \downarrow \rangle</tex>, то <tex>\langle w, q, xv \rangle \vdash \langle w, p, yv \rangle</tex>.

Особо следует рассмотреть случай переходов по пробельному символу:
* если <tex>\delta(q, B) = \langle p, y, \leftarrow \rangle</tex>, то <tex>\langle wz, q, \varepsilon \rangle \vdash \langle w, p, zy \rangle</tex>,
* если <tex>\delta(q, B) = \langle p, y, \rightarrow \rangle</tex>, то <tex>\langle w, q, \varepsilon \rangle \vdash \langle wy, p, \varepsilon \rangle</tex>,
* если <tex>\delta(q, B) = \langle p, y, \downarrow \rangle</tex>, то <tex>\langle w, q, \varepsilon \rangle \vdash \langle w, p, y \rangle</tex>.
}}
Очевидно, что определённое отношение является функциональным: для каждой конфигурации <tex>C</tex> существует не более одной конфигурации <tex>C'</tex>, для которой <tex>C \vdash C'</tex>.

Для машины Тьюринга, которая пишет символ <tex>B</tex> на ленту также можно дать аналогичное формальное определение. Оно будет отличаться тем, что символы в строчках конфигурации могут содержать пробелы, и для того, чтобы эти строчки имекли конечную длину, нужно аккуратно учесть наличие пробелов при записи правил перехода.

=== Результат работы ===
Машину Тьюринга можно рассматривать как распознаватель слов [[Основные определения: алфавит, слово, язык, конкатенация, свободный моноид слов; операции над языками|формального языка]]. Пусть <tex>M</tex> — машина Тьюринга, распознаваемый ей язык определяется как <tex>\mathcal L(M) = \{ x \in \Sigma^* \mid \exists y, z \in \Pi^*: \langle \varepsilon, S, x \rangle \vdash^* \langle y, Y, z \rangle \}</tex>.

Также можно рассматривать машины Тьюринга как преобразователь входных данных в выходные. Машина <tex>M</tex> задаёт [[Вычислимые функции|вычислимую функцию]] <tex>f</tex>, причём <tex>f(x) = y \Leftrightarrow \exists z \in \Pi^* : \langle \varepsilon, S, x \rangle \vdash^* \langle z, Y, y \rangle</tex>. Переход автомата в состояние <tex>N</tex> можно интерпретировать как аварийное завершение программы (например, при некорретном входе).

Примеры машин-распознавателей и машин-преобразователей будут даны ниже.

== Примеры машин Тьюринга ==
=== Прибавление единицы ===
Для начала приведём пример машины-преобразователя, которая прибавляет единицу к числу, записанному на ленте в двоичной записи от младшего бита к старшему. Алгоритм следующий:
* в стартовом состоянии головка идёт вправо от младшего бита к старшему, заменяя все единицы на нули,
* встретив нуль или пробельный символ головка записывает единицу, после чего переходит в состояние <tex>R</tex>,
* в состоянии <tex>R</tex> головка идёт влево от старшего бита к младшему, не изменяя символы 0 и 1 на ленте,
* встретив в состоянии <tex>R</tex> пробельный символ, головка перемещается на один символ вправо и переходит в состояние <tex>Y</tex>, завершая работу.

Формально: <tex>\Sigma = \{0, 1 \}</tex>, <tex>\Pi = \{0, 1, B\}</tex>, <tex>Q = \{S, R, Y, N \}</tex>. Таблица функции <tex>\delta</tex> приведена ниже:

{| border="0" cellspacing="5"
|-
|width="30"|
|width="100"| <tex>0</tex>
|width="100"| <tex>1</tex>
|width="100"| <tex>B</tex>
|-
| <tex>S</tex>
| <tex>\langle R, 1, \downarrow \rangle</tex>
| <tex>\langle S, 0, \rightarrow \rangle</tex>
| <tex>\langle R, B, \leftarrow \rangle</tex>
|-
| <tex>R</tex>
| <tex>\langle R, 0, \leftarrow \rangle</tex>
| <tex>\langle R, 1, \leftarrow \rangle</tex>
| <tex>\langle Y, B, \rightarrow \rangle</tex>
|}

=== Проверка того, является ли слово палиндромом ===
В качестве примера машины-распознавателя приведём машину, распознающую палиндромы над алфавитом <tex>\{0, 1\}</tex>. Алгоритм следующий:
* если строка на ленте — пустая, то перейти в допускающее состояние
* надо запомнить первый символ слова в состоянии автомата,
* стереть его,
* перейти в конец ленты:
** если оставшаяся строка на ленте — пустая, то перейти в допускающее состояние
** если последний символ совпадает с запомненным, стереть его, перейти в начало ленты и повторить с первого шага
** в случае несовпадения перейти в отвергающее состояние

Формально: <tex>\Sigma = \{0, 1\}</tex>, <tex>\Pi = \{0, 1, B\}</tex>, <tex>Q = \{S, F_0, F_1, B_0, B_1, R \}</tex>. Таблица функции <tex>\delta</tex> приведена ниже:
{| border="0" cellspacing="5"
|-
|width="30"|
|width="100"| <tex>0</tex>
|width="100"| <tex>1</tex>
|width="100"| <tex>B</tex>
|-
| <tex>S</tex>
| <tex>\langle F_0, B, \rightarrow \rangle</tex>
| <tex>\langle F_1, B, \rightarrow \rangle</tex>
| <tex>\langle Y, B, \downarrow \rangle</tex>
|-
| <tex>F_0</tex>
| <tex>\langle F_0, 0, \rightarrow \rangle</tex>
| <tex>\langle F_0, 1, \rightarrow \rangle</tex>
| <tex>\langle B_0, B, \leftarrow \rangle</tex>
|-
| <tex>F_1</tex>
| <tex>\langle F_1, 0, \rightarrow \rangle</tex>
| <tex>\langle F_1, 1, \rightarrow \rangle</tex>
| <tex>\langle B_1, B, \leftarrow \rangle</tex>
|-
| <tex>B_0</tex>
| <tex>\langle R, B, \leftarrow \rangle</tex>
| <tex>\langle N, 1, \downarrow \rangle</tex>
| <tex>\langle Y, B, \downarrow \rangle</tex>
|-
| <tex>B_1</tex>
| <tex>\langle N, 0, \downarrow \rangle</tex>
| <tex>\langle R, B, \leftarrow \rangle</tex>
| <tex>\langle Y, B, \downarrow \rangle</tex>
|-
| <tex>R</tex>
| <tex>\langle R, 0, \leftarrow \rangle</tex>
| <tex>\langle R, 1, \leftarrow \rangle</tex>
| <tex>\langle S, B, \rightarrow \rangle</tex>
|}

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

=== Многодорожечная машина Тьюринга ===
Машиной Тьюринга с <tex>n</tex> дорожками называется вычислитель, аналогичный машине Тьюринга, лишь с тем отличием, что лента состоит из <tex>n</tex> дорожек, на каждой из которых записаны символы ленточного алфавита. У многодорожечной машины одна головка, которая за один шаг переходит в одном направлении на всех дорожках одновременно. Соответственно, функция перехода имеет тип <tex>\delta : Q \times \Pi^n \to Q \times \Pi^n \times \{\leftarrow, \rightarrow, \downarrow\}</tex>. Многодорожечная машина Тьюринга тривиально эквивалентна обычной с ленточным алфавитом <tex>\Pi' = \Pi^n</tex>.

=== Машина Тьюринга с полубесконечной лентой ===
Заменив у машины Тьюринга бесконечную в обе стороны ленту на бесконечную в одну сторону, мы не теряем в вычислительной мощности. По произвольной машине Тьюринга строится двухдорожечная машина с полубесконечной лентой.
{{Теорема
|author=
|statement=Для любой машины Тьюринга существует эквивалентная машина Тьюринга, работающая на полубесконечной ленте.
|proof=Существует алгоритм, по которому для любой машины Тьюринга может быть построена эквивалентная машина Тьюринга с объявленным свойством. Сначала занумеруем ячейки рабочей ленты машины Тьюринга с ''бесконечной лентой'' следующим образом:

[[Файл:Mt1.png]]

Затем перенумеруем ячейки, и запишем символ <tex>c \in \Pi \setminus \Sigma, B</tex> в начало ленты, который будет означать границу рабочей зоны:

[[Файл:Mt2.png]]

Наконец, изменим машину Тьюринга, удвоив число её состояний, и изменим сдвиг головки так, чтобы в одной группе состояний работа машины была бы эквивалентна её работе в заштрихованной зоне, а в другой группе состояний машина работала бы так, как исходная машина работает в незаштрихованной зоне. Если при работе машины Тьюринга встретится символ <tex>c</tex>, значит головка достигла границы рабочей зоны:

[[Файл:Mt3.png]]

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

=== Многоленточная машина Тьюринга ===
В отличие от многодорожечной машины Тьюринга, ленты не зависят друг от друга и головки во время одного шага могут перемещаться по-разному. То есть, функция перехода теперь имеет тип <tex>\delta : Q \times \Pi^n \to Q \times \Pi^n \times \{\leftarrow, \rightarrow, \downarrow\}^n</tex>.

Многоленточная машина с <tex>n</tex> дорожками эмулируется многодорожечной машиной с <tex>2n</tex> дорожками следующим образом: каждая нечётная дорожка соответствует ленте исходной машины, а на каждой чётной дорожке отмечены специальным символом <tex>*</tex> позиция головки на ленте выше (считаем, что ленты нумеруются сверху вниз).

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

Аланом Тьюрингом было сформулировано следующее утверждение:
{{Утверждение
|about=Тезис Чёрча-Тьюринга
|statement=
Класс перечислимых языков совпадает с классом языков, перечислимых с помощью машин Тьюринга
}}
Иными словами, тезис говорит о том, что любой алгоритм можно запрограммировать на машине Тьюринга.

== Универсальная машина Тьюринга ==

Существует машина Тьюринга, которая принимает на вход закодированное описание произвольной машины и входную строку и эмулирует работу закодированной машины на заданном входном слове. Иными словами, [[Разрешимые (рекурсивные) языки#Пример неразрешимого множества|универсальный язык]] перечислим с помощью машины Тьюринга. Ссылки на явные конструкции универсальных машин Тьюринга приведены ниже.

== См. также ==
* [[Стековые машины, эквивалентность двухстековой машины МТ|Стековые машины]]
* [[Счетчиковые машины, эквивалентность двухсчетчиковой машины МТ|Счётчиковые машины]]
* [[Линейный клеточный автомат, эквивалентность МТ|Клеточные автоматы]]
* [[Возможность порождения формальной грамматикой произвольного перечислимого языка|Произвольные формальные грамматики]]
* [[Лямбда-исчисление|Нетипизированное лямбда-исчисление]]

== Источники информации ==
* [http://www.cs.virginia.edu/~robins/Turing_Paper_1936.pdf Alan Turing {{---}} On computable numbers, with an application to the Entscheidungsproblem.]
* [http://www.ccs.neu.edu/home/viola/classes/papers/HennieStearns66.pdf F. C. Hennie, R. E. Stearn {{---}} Two-tape simulation of multitape Turing machines.]
* [http://www.cs.princeton.edu/theory/index.php/Compbook/Draft Sanjeev Arora, Boaz Barak {{---}} Computational Complexity: A Modern Approach.]
* [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.145.8958 Turlough Neary, Damien Woods {{---}} Four Small Universal Turing Machines.]
* [http://www.jflap.org/ JFLAP {{---}} ПО для изучения формальных языков, включает в себя эмулятор одноленточных и многоленточных машин Тьюринга с визуальным редактором.]

[[Категория: Теория формальных языков]]
[[Категория: Теория вычислимости]]
[[Категория: Вычислительные формализмы]]

Link-Cut Tree

2018-05-12T22:03:10Z

188.227.78.184: /* cut(v) */

'''Динамические деревья''' (англ.''dynamic tree'') используются в двух областях: [[Определение сети, потока|потоки]] и динамические графы.
В первом случае динамические деревья позволяют построить эффективные алгоритмы для задачи о поиске максимального потока.
В динамическом графе периодически происходят изменения: появляются и исчезают ребра, меняются их веса. Нужно быстро обрабатывать изменения, а также уметь [[Отношение связности, компоненты связности | проверять связность]], [[Алгоритмы на деревьях|искать диаметр]]. Динамические деревья являются инструментом, который позволяет легко решать эти задачи. Динамические деревья особенно эффективны, когда нужно работать с большими деревьями и большим количеством запросов '''link''' и '''cut'''.

'''Link-cut tree''' {{---}} это структура данных, которая хранит [[Дерево, эквивалентные определения |лес деревьев]] и позволяет выполнять следующие операции:
* '''<tex>\mathrm{min(v)}</tex>''' {{---}} искать минимум на пути от вершины до корня,
* '''<tex>\mathrm{add(v, c)}</tex>''' {{---}} прибавлять константу на пути от вершины до корня,
* '''<tex>\mathrm{link(u, w)}</tex>''' {{---}} подвешивать одно дерево на другое,
* '''<tex>\mathrm{cut(v)}</tex>''' {{---}} отрезать дерево с корнем в вершине <tex>\mathrm{v}</tex>.
Среднее время выполнения каждой операции {{---}} <tex>O(\log n)</tex>. Эта структура данных была придумана Робертом Тарьяном и Даниелем Слейтером в 1982 году.

==Решение задачи в частном случае==
Сначала рассмотрим частный случай, в котором все деревья {{---}} это пути, и мы хотим уметь:

[[Файл:Path_to_tree.png|250px|thumb|right|Пример построения дерева для пути]]
* '''<tex>\mathrm{add(v, c)}</tex>''' и '''<tex>\mathrm{min(v)}</tex>''' {{---}} прибавлять константу и искать минимум на некотором суффиксе (то есть на пути от вершины до корня),
* '''<tex>\mathrm{cut(v)}</tex>''' {{---}} разбить один путь на два,
* '''<tex>\mathrm{link(v, u)}</tex>''' {{---}} подвешивать голову одного пути к хвосту другого.

Если бы не последние две операции, то можно было бы применить [[Несогласованные поддеревья. Реализация массового обновления|дерево отрезков]], сложив в него вершины в том порядке в котором они идут в пути. Но непонятно, как сливать или разрезать деревья отрезков. Эту задачу можно решить при помощи [[Декартово дерево по неявному ключу|декартового дерева по неявному ключу]]. Также, если использовать какие-нибудь сливаемые деревья, то <tex>\mathrm{link}</tex> и <tex> \mathrm{cut}</tex> реализуются просто. Осталось научиться искать минимум и прибавлять константу на пути. Для этого, как и в деревьях отрезков, будем хранить дополнительные значения в вершинах.
В качестве сливаемых деревьев выберем [[Splay-дерево|splay-деревья]], в которых ключи выбираются равными глубине вершины.

Тогда операции <tex>\mathrm{cut}</tex> будет соответствовать <tex>\mathrm{split}</tex>.

<tex>\mathrm{link(path1, path2)}</tex> соединяет голову первого пути с хвостом второго. Используем функцию <tex>\mathrm{merge(path2, path1)}</tex>, которая вызовет <tex>\mathrm{splay}</tex> от хвоста второго пути и сделает первый путь правым ребенком корня <tex>\mathrm{path2}</tex>, то есть теперь <tex>\mathrm{path1}</tex> находится ниже, чем <tex>\mathrm{path2}</tex>.

Чтобы прибавлять заданное число на пути от вершины до корня, будем в каждой вершине хранить величину <tex>\Delta w</tex>, которая равна разнице между весом вершины и весом её родителя. Для корня это значение равно весу самого корня. Поэтому вес вершины определятся следующим образом:

<tex>w(u) = \displaystyle \sum_v^{} \Delta w(v)</tex>, где <tex> v </tex> {{---}} все предки вершины <tex> u </tex>.

При прибавлении <tex>\alpha</tex> на пути от вершины <tex>v</tex> до корня, сначала вызывается <tex>\mathrm{splay(v)}</tex>, после чего в левом поддереве находятся вершины, которые лежат на пути к корню. Затем надо прибавить <tex>\alpha</tex> к <tex>\Delta w(v)</tex> и, чтобы сохранить веса вершин, которые находятся ниже в пути, вычесть <tex>\alpha</tex> от <tex>\Delta w(right(v))</tex>.

Для реализации <tex>\min</tex> будем хранить минимум уже для всего поддерева. Чтобы искать минимум от вершины <tex>v</tex>, надо вызвать <tex>\mathrm{splay(v)}</tex> и сравнить её вес с минимумом левого поддерева, в котором теперь находятся все вершины пути кроме <tex>v</tex>. Определим <tex>\Delta \min (v)</tex> таким образом, чтобы сохранялся следующий инвариант: <tex>\min (v) = \Delta \min (v) + w(v) </tex>. Пусть <tex>l</tex> и <tex>r</tex> дети <tex>v</tex>, тогда

<tex>\min (v) = \min \{w(v), \min(l), \min(r)\}</tex>

<tex>\Delta \min(v) = \min(v) - w(v) \\
= \min\{w(v) - w(v), \min(l) - w(v), \min(r) - w(v)\} \\
= \min\{0, \ (\Delta \min(l) + w(l)) - w(v), \ (\Delta \min(r) + w(r)) - w(v)\} \\
= \min\{0, \ \Delta \min(l) + \Delta w(l), \ \Delta \min(r) + \Delta w(r)\}</tex>

[[Файл:Linkcut_weights.png|500px]]

==Link-cut tree==
Чтобы обобщить, разобьем дерево на множество непересекающихся путей. Каждое ребро обозначим либо сплошным, либо пунктирным. Все пути в link-cut дереве хранятся в виде splay-деревьев. Корень каждого splay-дерева хранит указатель на вершину-родителя. В дальнейшем будем называть этот указатель <tex>pathparent</tex>.
[[Файл:Linkcut_paths.png|500px||center|Разбиение дерева на пути]]

===expose(u)===
Ключевая операция в link-cut-деревьях {{---}} <tex>\mathrm{expose(u)}</tex>. После её выполнения <tex>u</tex> лежит на одном пути с корнем link-cut дерева и при этом становится корнем в splay-дереве получившегося пути. Для этого она поднимается вверх по link-cut дереву, и если какой-нибудь путь пересекает путь от <tex>u</tex> до корня, то она его отрезает, разъединяя splay-дерево и делая соответствующее сплошное ребро пунктирным ребром.
[[Файл:Linkcut_expose.png|500px||center|Разбиение дерева на пути]]

'''function''' expose(u: '''tree'''):
splay(u)
v <tex>=</tex> u
'''while''' v <tex> \ne </tex> root
p <tex>=</tex> pathparent(v) //получаем указатель на ближайшую вершину пути, пересекающего путь от u до корня
splay(p) //теперь в правом поддереве p находятся вершины пути, которые находятся ниже чем p в link-cut-дереве,
parent(right(p)) <tex>=</tex> null //поэтому правое поддерево p делаем новым путем
pathparent(right(p)) <tex>=</tex> p
right(p) <tex>=</tex> v //объединяем оставшийся и построенный пути
<tex>\vartriangle</tex>w(v) -= <tex>\vartriangle</tex>w(p)
<tex>\vartriangle</tex>min(p) <tex>=</tex> min{0, <tex>\vartriangle</tex>min(left(p)) + <tex>\vartriangle</tex>w(left(p)), <tex>\vartriangle</tex>min(right(p)) + <tex>\vartriangle</tex>w(right(p))}
pathparent(v) <tex>=</tex> null
v <tex>=</tex> p
splay(u)

===add(v, c)===
Чтобы прибавить константу на пути от <tex>v</tex> до корня link-cut-дерева вызовем <tex>\mathrm{expose(v)}</tex>, что построит запрашиваемый путь в виде splay-дерева, в котором <tex>v</tex> {{---}} корень, и в левом поддереве находятся вершины, которые находятся выше чем <tex>v</tex> в link-cut-дереве (то есть все вершины пути без <tex>v</tex>), а в правом {{---}} те, что ниже. Тогда прибавим <tex>c</tex> к <tex>\Delta w(v)</tex> и вычтем константу от правого ребенка <tex>v</tex>, чтобы скомпенсировать разницу и сохранить инвариант.

'''function''' add(v: '''tree''', c: '''int'''):
expose(v)
<tex>\vartriangle</tex>w(v) += c
<tex>\vartriangle</tex>w(right(v)) -= c

===min(v)===
Построим splay-дерево для пути и сравним вес корня <tex>v</tex> c минимумом в левом поддереве:
'''function''' min(v: '''tree'''): '''int'''
expose(v)
'''if''' <tex>\vartriangle</tex>min(left(v)) + <tex>\vartriangle</tex>w(left(v)) < <tex>\vartriangle</tex>w(v)
'''return''' <tex>\vartriangle</tex>min(left(v)) + <tex>\vartriangle</tex>w(left(v))
'''else'''
'''return''' <tex>\vartriangle</tex>w(v)

===link(v, u)===
Если <tex>v</tex> {{---}} корень, а <tex>u</tex> {{---}} вершина в другом дереве, то <tex>\mathrm{link(v, u)}</tex> соединяет два дерева добавлением ребра <tex>(v, u)</tex>, причем <tex>u</tex> становится родителем <tex>v</tex>.

'''function''' link(v: '''tree''', u: '''tree'''): '''tree'''
expose(v) //теперь v {{---}} корень в splay-дереве пути и не имеет левого ребенка(так как ключ равен глубине в link-cut дереве)
expose(u)
<tex>\vartriangle</tex>w(u) -= <tex>\vartriangle</tex>w(v) //чтобы сделать u родителем v в link-cut дереве 1. делаем путь, содержащий u, левым ребенком v в splay-дереве
parent(u) <tex>=</tex> v // 2. обновляем <tex>\vartriangle</tex>w, <tex>\vartriangle</tex>min
left(v) <tex>=</tex> u
<tex>\vartriangle</tex>min(v) <tex>=</tex> min{0, <tex>\vartriangle</tex>min(u) + <tex>\vartriangle</tex>w(u), <tex>\vartriangle</tex>min(right(v)) + <tex>\vartriangle</tex>w((right(v)))}
'''return''' v

===cut(v)===
Отрезает дерево с корнем <tex>v</tex>. После вызова <tex>\mathrm{expose(v)}</tex> вершина <tex>v</tex> станет корнем splay-дерева, и в правом поддереве будут содержатся все вершины, которые были ниже <tex>v</tex> в link-cut дереве, а в левом {{---}} те что выше. Обнулив указатель на левого ребенка <tex>v</tex> и на родителя в левом поддереве, получим требуемое.

'''function''' cut(v: '''tree'''):
expose(v)
<tex>\vartriangle</tex>w(left(v)) += <tex>\vartriangle</tex>w(v)
<tex>\vartriangle</tex>min(v) <tex>=</tex> min{0, <tex>\vartriangle</tex>min(right(v)) + <tex>\vartriangle</tex>w(right(v))}
parent(left(v)) <tex>=</tex> null
left(v) <tex>=</tex> null

==Оценка времени работы==
Назовем ребро из <tex>u</tex> в её родителя <tex>v</tex> тяжелым, если количество детей <tex>u</tex> равное <tex>d(u) > \dfrac{1}{2} d(v)</tex>.
{{Лемма
|id = Lemma1
|statement= На пути от вершины до корня не больше <tex>\log n</tex> легких ребер.

|proof = Пусть <tex>m</tex> {{---}} количество вершин в дереве с корнем в вершине, в которой мы сейчас находимся. Поднимаясь по легкому ребру, <tex>m</tex> увеличивается в два раза, поэтому, пройдя больше <tex>\log n</tex> легких ребер, получим <tex>m > n</tex>. Значит, в дереве не больше <tex>\log n</tex> легких ребер.
}}

Операция <tex>u</tex> осуществляется с помощью последовательности преобразований пунктирного ребра в сплошное ребро и другого сплошного ребра в пунктирное ребро. Обозначим количество таких преобразований за <tex>M</tex>. Найдем количество преобразований сделанных в течение <tex>\mathrm{expose(u)}</tex>. Пусть <tex>H</tex> {{---}} множество всех тяжелых ребер, <tex>L</tex> {{---}} все легкие ребра, <tex>S \rightarrow D</tex> {{---}} множество сплошных ребер, преобразованных в пунктирные в течение одного <tex>\mathrm{expose}</tex>, <tex>D \rightarrow S</tex> {{---}} множество пунктирных ребер, преобразованных в сплошные.

<tex>M = |\{D \rightarrow S\}| = |\{L \cap D \rightarrow S\}| + |\{H \cap D \rightarrow S\}|</tex>

По лемме, количество легких пунктирных ребер, преобразованных в сплошные, будет не больше, чем <tex>\log n</tex>.

Обозначим за <tex>F</tex> лес деревьев, в которых каждое ребро либо сплошное, либо пунктирное, a <tex>F'</tex> {{---}} лес, получившийся из <tex>F</tex> после одного вызова <tex>\mathrm{expose}</tex>. Определим потенциал <tex>\Phi _{a}(F) = n - 1 - |\{H \cap solid-edges\}|</tex>, <tex>\Delta \Phi _{a}</tex> {{---}} увеличение <tex>\Phi _{a}</tex> после одной операции <tex>\mathrm{expose}</tex>.

{{Лемма
|id = Lemma2
|statement= <tex>V = M + \Delta \Phi _{a} \leqslant 1 + 2\log n </tex>

|proof=

<tex>V = M + \Delta \Phi _{a}\\
= M + |H \cap S \rightarrow D| - |H \cap D \rightarrow S| \\
\leqslant M + |L \cap D \rightarrow S| - |H \cap D \rightarrow S| \\
= 2 \cdot |L \cap D \rightarrow S| \\
=2 \cdot \log n
</tex>
}}

Теперь проанализируем <tex>M</tex>. Используя тот факт, что начальное значение <tex>\Phi _{a}</tex> не превосходит <tex>n - 1</tex>, приходим к тому, что для деревьев с <tex>n</tex> вершинами, по крайней мере за <tex>n - 1</tex> операцию <tex>\mathrm{expose}</tex>, среднее <tex>M</tex> на одну операцию будет не больше, чем <tex>1 + 2\log n</tex>.

Докажем, что [[Амортизационный анализ|амортизационная стоимость операции]] <tex>\mathrm{expose}</tex> равна <tex>O(\log n)</tex>.

Пусть <tex>s(v)</tex> {{---}} количество вершин в поддеревьях <tex>v</tex> ( здесь имеется в виду splay-дерево пути, котоый строится в ходе выполнения <tex>\mathrm{expose}</tex>), <tex>r(v) = \log s(v)</tex>. По [[Splay-дерево#Lemma1|лемме]] стоимость ''i''-той операции <tex>\mathrm{splay}</tex> не превосходит <tex>1 + 3 \cdot (r(t) - r(v))</tex>. Это приводит к тому, что амортизационная стоимость <tex>\mathrm{expose}</tex> ограничена следующим значением:

<tex>3 \cdot \log n - 3 \cdot \log (s(v)) + M</tex>

Здесь <tex>M = O(\log n)</tex>, поэтому амортизационная стоимость <tex>\mathrm{expose}</tex> равна <tex>O(\log n)</tex>.

==Применение==
===LCA===
C помощью link-cut-дерева можно найти наименьшего общего предка:
'''function''' lca(u: '''tree''', v: '''tree'''): '''tree'''
expose(u)
expose(v)
'''return''' pathparent(splay(u))

Первый вызов <tex>\mathrm{expose}</tex> построит путь от <tex>u</tex> до корня. Второй пересечет этот путь в наименьшем общем предке, поэтому в splay-дереве, которому принадлежит <tex>u</tex>, хранится указатель <tex>pathparent</tex> на <tex>\mathrm{lca}</tex>, после <tex>\mathrm{splay}(u)</tex> он будет находиться в <tex>u</tex>.

==См. также==
* [[Метод двоичного подъема]]
* [[Алгоритм Тарьяна поиска LCA за O(1) в оффлайн]]
* [[Алгоритм Шибера-Вишкина]]

==Источники информации==
* [http://www.lektorium.tv/lecture/14464 А.С. Станкевич, "Дополнительные главы алгоритмов"]
* [https://sites.google.com/site/indy256/algo/link-cut-tree-lca Реализация LCA на link-cut дереве]
* [http://www.cs.cmu.edu/~sleator/papers/dynamic-trees.pdf D. Sleator and R. Tarjan, "A Data Structure for Dynamic Trees"]
* [http://compgeom.cs.uiuc.edu/~jeffe/teaching/datastructures/2006/notes/07-linkcut.pdf Jeff Erickson. Lecture 7. Link-Cut Trees]
* [http://planarity.org/Klein_splay_trees_and_link-cut_trees.pdf Optimization Algorithms for Planar Graphs. Splay trees and link-cut trees]
* [http://en.wikipedia.org/wiki/Link/cut_tree Wikipedia {{---}} Link/cut tree]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Алгоритм отмены цикла минимального среднего веса

2018-03-30T04:27:55Z

188.227.78.184: /* Псевдокод */

В статье описывается один из сильно полиномиальных алгоритмов решения [[Поток минимальной стоимости #Задача о потоке минимальной стоимости|задачи о поиске потока минимальной стоимости]].
==Алгоритм==
Приведенный алгоритм основан на идее [[Поток минимальной стоимости #Метод устранения отрицательных циклов в остаточной сети|алгоритма Клейна отмены цикла отрицательного веса]]. Выбор цикла минимального среднего веса вместо случайного делает алгоритм сильно полиномиальным.
{{Определение
|definition='''Сильно полиномиальными''' (англ. ''strongly polynomial'') в контексте данной задачи называются алгоритмы, чья сложность полиномиально зависит от <tex>V</tex> и <tex>E</tex>.}}
===Описание===
Обозначим как <tex>c_{f}(C)</tex> остаточную [[Определение сети, потока|пропускную способность]] цикла <tex>C</tex> при протекании в сети потока <tex>f</tex>.
Cтоимость цикла <tex>C</tex> обозначим за <tex>p(C)</tex>, а длину (число входящих в него ребер) {{---}} за <tex>\texttt{len}(C)</tex>.
{{Определение
|definition='''Средним весом''' (англ. ''mean weight'') цикла будем называть отношение его стоимости к его длине <tex>\mu (C)=\dfrac{p(C)}{\texttt{len}(C)}</tex>}}
Данный алгоритм заключается в последовательной отмене циклов минимального среднего веса в [[Дополняющая сеть, дополняющий путь|остаточной сети]] посредством их насыщения. Алгоритм работает до тех пор, пока минимальный средний вес циклов не окажется положительным, что будет означать, что поток минимальной стоимости найден.

Более формально:
* '''Шаг <tex>1</tex>'''. Рассмотрим некоторый поток <tex>f</tex>.
* '''Шаг <tex>2</tex>'''. Найдем цикл <tex>C</tex>, обладающий наименьшим средним весом. Если <tex>\mu (C) \geqslant 0</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости и алгоритм завершается.
* '''Шаг <tex>3</tex>'''. Отменим цикл <tex>C</tex>, пустив по нему максимально возможный поток: <tex>f = f + c_{f}(C)\cdot f_{C}</tex>. Перейдем к '''шагу <tex>1</tex>'''.

===Сложность===
Для сетей с целочисленными стоимостями на ребрах <tex>O(VE\cdot VE\log{CV})</tex>, с вещественными {{---}} <tex>O(VE\cdot VE^{2}\log{V})</tex>.
В обоих случаях <tex>O(VE)</tex> времени тратится на поиск цикла минимального среднего веса.

===Псевдокод===
'''func''' findMin:
'''while''' <tex>f</tex>
<tex>C</tex> = <tex>c</tex> : <tex>\mu(C) </tex>= <tex>\min\limits_c\mu(c)</tex> // <tex>\mu(C)</tex> {{---}} вес минимального цикла
'''if''' <tex>\mu (C) \geqslant 0</tex>
'''return''' <tex>f</tex> // тогда мы нашли f {{---}} поток минимальной стоимости, алгоритм завершается
'''else'''
<tex>f</tex> += <tex>c_{f}(C)\cdot f_{C}</tex> // иначе отменим цикл

===Корректность===
Пусть <tex>f</tex> {{---}} поток минимальной стоимости. Введём на нашей сети функцию [[Алгоритм Джонсона|потенциалов]] <tex>\varphi</tex>.
{{Определение
|definition='''Приведённой стоимостью''' (англ. ''reduced cost'') ребра назовем следующую величину: <tex>p_{\varphi}(uv)=\varphi(u) + p(uv) - \varphi(v)</tex>.}}
Иными словами, приведённая стоимость {{---}} это сколько нужно потратить денег, чтобы перевезти единицу жидкости из <tex>u</tex> в <tex>v</tex> (её нужно купить в <tex>u</tex>, перевезти из <tex>u</tex> в <tex>v</tex> и продать в <tex>v</tex>).

{{Лемма
|id=lemma1
|about=<tex>1</tex>
|statement=Если <tex>f</tex> {{---}} поток минимальной стоимости, то <tex>\exists \varphi</tex> такое, что <tex>\forall uv: \; c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant 0</tex>.
|proof=
:Рассмотрим остаточную сеть {{---}} граф <tex>G_{f}</tex>. В нем нет отрицательных циклов, так как <tex>f</tex> {{---}} поток минимальной стоимости<ref>[[Лемма об эквивалентности свойства потока быть минимальной стоимости и отсутствии отрицательных циклов в остаточной сети]]</ref>.

:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость минимального пути из <tex>a</tex> в <tex>u</tex>.

:Рассмотрим теперь некоторое ребро <tex>uv</tex>. Понятно, что <tex>\varphi(v) \leqslant \varphi(u) + p(uv)</tex>. (Здесь сравниваются минимальный путь <tex>a \rightsquigarrow v</tex> и путь <tex>a \rightsquigarrow u \rightarrow v</tex>). Перенеся <tex>\varphi(v)</tex> в другую часть неравенства, получаем <tex>0 \leqslant \varphi(u) + p(uv) - \varphi(v)</tex> или <tex>0 \leqslant p_{\varphi}(uv)</tex>.}}

{{Определение
|definition=Будем говорить, что поток <tex>f</tex> {{---}} '''<tex>\varepsilon</tex>-оптимальный''' (англ. ''<tex>\varepsilon</tex>-optimal''), если <tex>\exists \varphi</tex> такая, что <tex>\forall uv: c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant -\varepsilon</tex>.}}

{{Лемма
|id=lemma2
|about=<tex>2</tex>
|statement=Если стоимости целочисленны и поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный, где <tex>\varepsilon < \dfrac{1}{V}</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости.
|proof=
:Рассмотрим цикл в остаточной сети <tex>C</tex>. Заметим, что <tex>p(C)=p_{\varphi}(C)</tex> (для доказательства этого факта достаточно расписать <tex>p_{\varphi}(C)</tex> по определению).

:Возьмем <tex>\varphi</tex> такое, что стоимости всех ребер в <tex>C</tex> не меньше <tex>-\varepsilon</tex>. Тогда стоимость всего цикла <tex>p_{\varphi}(C)\geqslant -V\cdot \varepsilon</tex> (в цикле не больше <tex>V</tex> ребер). Таким образом, <tex>p_{\varphi}(C) > -1</tex>, то есть <tex>p(C) > -1</tex>. Но исходные пропускные способности были целочисленными, поэтому <tex>p(C) \geqslant 0</tex>, а это означает, что в остаточной сети нет отрицательных циклов, и, соответственно, <tex>f</tex> {{---}} поток минимальной стоимости.}}

Обозначим за <tex>\mu^{*}</tex> минимальную величину среди средних весов циклов для потока <tex>f</tex>, а за <tex>\varepsilon^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный.
{{Лемма
|id=lemma3
|about=<tex>3</tex>
|statement=Если <tex>f</tex> {{---}} поток не минимальной стоимости, то <tex>\varepsilon^{*}=-\mu^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса в остаточной сети.
*Покажем, что <tex>\mu^{*} \geqslant -\varepsilon^{*}</tex>.
:Поскольку поток <tex>f</tex> является <tex>\varepsilon^{*}</tex>-оптимальным, верно следующее: <tex>p(C) = p_{\varphi}(C) \geqslant -\texttt{len}(C) \cdot \varepsilon^{*}</tex> или <tex>\dfrac{p(C)}{\texttt{len}(C)} \geqslant -\varepsilon^{*} </tex>, то есть <tex>\mu(C)=\mu^{*} \geqslant -\varepsilon^{*}</tex>.

*Теперь покажем, что <tex>\mu^{*} \leqslant -\varepsilon^{*}</tex>.
:Пусть <tex>p'(uv)=p(uv)-\mu^{*}</tex> для любого <tex>uv \in E_{f}</tex>. Логичным будет также обозначить для некоторого цикла <tex>C</tex> за <tex>\mu'(C)</tex> величину <tex>\dfrac{p'(C)}{\texttt{len}(C)}</tex>. Таким образом, для любого цикла <tex>C</tex>, <tex>\mu'(C)=\mu(C)-\mu^{*}\geqslant 0</tex>.
:Далее проведем рассуждения, аналогичные доказательству [[#lemma1|леммы <tex>1</tex>]].
:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость (считая стоимостью функцию <tex>p'</tex>) минимального пути из <tex>a</tex> в <tex>u</tex>.
:Таким образом, <tex>\varphi(v) \leqslant \varphi(u) + p'(uv) = \varphi(u) + p(uv) - \mu^{*}</tex>. Отсюда получаем, что <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex> для любого ребра <tex>uv</tex> из остаточной сети <tex>E_{f}</tex>, что означает, что <tex>f</tex> {{---}} <tex>(-\mu^{*})</tex>-оптимальный, и, по определению <tex>\varepsilon^{*}</tex>, <tex>\varepsilon^{*} \leqslant -\mu^{*}</tex>.
}}

{{Лемма
|id=lemma4
|about=<tex>4</tex>
|statement=Отмена цикла минимального среднего веса не увеличивает <tex>\varepsilon^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса, который мы хотим отменить на текущем шаге нашего алгоритма. Перед тем, как мы отменим этот цикл, любое ребро в остаточной сети, в том числе, любое входящее в цикл <tex>C</tex> ребро <tex>uv</tex> удовлетворяет свойству <tex>\varepsilon^{*}</tex>-оптимальности: <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>.
:По [[#lemma3|лемме <tex>3</tex>]], <tex>\varepsilon^{*}=-\mu^{*}</tex>, то есть <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex>. Но поскольку <tex>\mu^{*}</tex> {{---}} средний вес цикла, то <tex>p_{\varphi}(uv) = \mu^{*} = -\varepsilon^{*}</tex>.
:По [[Поток минимальной стоимости #Свойства стоимости|свойству антисимметричности потока]], после отмены цикла <tex>C</tex>, в остаточной сети появятся ребра стоимости <tex>\varepsilon</tex>. Таким образом, свойство <tex>p_{\varphi}(uv) \geqslant -\varepsilon</tex> все еще выполняется.
}}

{{Определение
|definition='''Допустимым графом''' (англ. ''admissible graph'') будем называть такой подграф остаточной сети, что он включает только ребра отрицательной приведенной стоимости. <tex>H=\{uv \in E_{f}\;|\; p_{\varphi}(uv) < 0\}</tex>
}}

{{Лемма
|id=lemma5
|about=<tex>5</tex>
|statement=Пусть <tex>f</tex> {{---}} некоторый поток, а <tex>f'</tex> {{---}} поток после <tex>E</tex> отмен циклов минимального среднего веса. Тогда <tex>\varepsilon'^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, где <tex>\varepsilon'^{*}</tex> {{---}} минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный.
|proof=
:Изначально любое ребро <tex>uv</tex> удовлетворяет свойству <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>. Отмена цикла добавляет в остаточную сеть <tex>G_{f}</tex> только ребра положительной приведенной стоимости (см. [[#lemma4|лемму <tex>4</tex>]]) и удаляет из сети <tex>G</tex> как минимум одно ребро. Рассмотрим два случая:
:#Ни один из отмененных циклов не содержал ребер, обладающих неотрицательной приведенной стоимостью. Тогда каждая отмена цикла уменьшает размер допустимого графа <tex>H</tex> и после <tex>E</tex> отмен граф <tex>H</tex> пуст, что означает, что <tex>f'</tex> {{---}} оптимальный поток, то есть <tex>\varepsilon'^{*}=0</tex>.
:#Некоторые из отмененных циклов содержали ребра неотрицательной приведенной стоимости. Пусть впервые такое случилось на <tex>i</tex>-ой итерации, и, соответственно, <tex>C_{i}</tex> {{---}} первый из таких циклов. Для <tex>C_{i}</tex> имеем, что каждое его ребро обладает приведенной стоимостью как минимум <tex>-\varepsilon_{i}^{*}</tex> (при этом <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} \leqslant \varepsilon^{*}</tex> по [[#lemma4|лемме <tex>4</tex>]]), хотя бы одно из ребер <tex>C_{i}</tex> обладает неотрицательной приведенной стоимостью и количество ребер в <tex>C_{i}</tex> не превышает <tex>V</tex>. Тогда средний вес этого цикла <tex>\mu(C_{i}) = \mu_{i}^{*} \geqslant -\left(1-\dfrac{1}{V}\right)\varepsilon_{i}^{*} \geqslant - \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, и <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} = -\mu_{i}^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>.}}

{{Определение
|definition='''<tex>\varepsilon</tex>-фиксированным''' (англ. ''<tex>\varepsilon</tex>-fixed'') будем называть ребро, поток через которое неизменен для любых <tex>\varepsilon</tex>-оптимальных потоков в сети.}}

{{Теорема
|id=theorem1
|statement=Пусть поток <tex>f</tex> является <tex>\varepsilon</tex>-оптимальным с функцией потенциалов <tex>\varphi</tex>. Также пусть для некоторого ребра <tex>uv \; \left|p_{\varphi}(uv)\right| \geqslant 2V\varepsilon</tex>. Тогда ребро <tex>uv</tex> <tex>\varepsilon</tex>-фиксировано.
|proof=
:По свойству антисимметричности, достаточно будет доказать теорему для случая <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon</tex>.

:Рассмотрим такой поток <tex>f'</tex>, что <tex>f'(uv) \neq f(uv)</tex>. Поскольку <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon > \varepsilon</tex>, поток по ребру <tex>uv</tex> должен быть как можно меньше, то есть <tex>f(uv) = -c(uv)</tex>, и тогда раз <tex>f'(uv) \neq f(uv)</tex>, то <tex>f'(uv) > f(uv)</tex>.

:Покажем теперь, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимальный.
:Обозначим за <tex>G_{>}</tex> подграф <tex>G</tex> такой, что <tex>G_{>}=(V, \{uv \in E \;|\; f'(uv) > f(uv) \})</tex>. Рассмотрим некоторое ребро <tex>uv</tex> в <tex>G_{>}</tex>. Поскольку <tex>f</tex> и <tex>f'</tex> являются циркуляциями, в <tex>G_{>}</tex> должен содержаться простой цикл <tex>C</tex>, проходящий через <tex>uv</tex>. Поскольку все ребра в <tex>C</tex> {{---}} остаточные, стоимость <tex>C</tex> не меньше <tex>p_{\varphi}(uv) - (\texttt{len}(C)-1)\varepsilon \geqslant 2V\varepsilon - (V-1)\varepsilon > V\varepsilon</tex>.
:Теперь рассмотрим цикл <tex>\overline{C}</tex>, который получен из <tex>C</tex> разворотом всех его ребер. Заметим, что <tex>\overline{C}</tex> является циклом в <tex>G_{<}=(V,\{uv \in E \;|\; f'(uv) < f(uv)\})</tex> и, соответственно, циклом в <tex>G_{f}</tex>. По свойству антисимметричности, стоимость <tex>\overline{C}</tex> меньше, чем <tex>-V\varepsilon</tex> и, таким образом, <tex>\mu(\overline{C}) < -\varepsilon</tex>. Откуда по [[#lemma3|лемме <tex>3</tex>]] имеем, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимален.
}}

{{Лемма
|about=доказательство оценки времени работы алгоритма в случае вещественных стоимостей
|statement=Пусть <tex>k=VE(\lceil \log V + 1 \rceil)</tex>. Разобьем работу алгоритма на группы по <tex>k</tex> последовательных итераций. Утверждается, что каждая группа фиксирует поток на независимом ребре <tex>uv</tex>, то есть итерации из другой группы не меняют величину <tex>f(uv)</tex>.
|proof=
:Оценка времени работы следует непосредственно из этого утверждения.
:Чтобы доказать его, рассмотрим некоторую группу итераций. Пусть <tex>f</tex> {{---}} поток до первой итерации, а <tex>f'</tex> {{---}} после последней итерации этой группы. Обозначим за <tex>\varepsilon'^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный, а за <tex>\varphi'</tex> {{---}} функцию потенциалов такую, что <tex>f'</tex> удовлетворяет свойству <tex>\varepsilon'^{*}</tex>-оптимальности. Выбор <tex>k</tex> и [[#lemma5|лемма <tex>5</tex>]] дают нам следующее неравенство: <tex>\varepsilon'^{*} \leqslant \varepsilon^{*} \left(1-\dfrac{1}{V} \right)^{V(\log V + 1)} \leqslant \dfrac{\varepsilon^{*}}{2V}</tex>.
:Рассмотрим цикл <tex>C</tex>, отмененный на первой итерации рассматриваемой группы. Поскольку средний вес цикла <tex>C</tex> равен <tex>-\varepsilon^{*}</tex> (см. [[#lemma3|лемму <tex>3</tex>]]), некоторое ребро <tex>uv</tex> цикла <tex>C</tex> должно иметь приведенную стоимость <tex>p_{\varphi'}(uv) \leqslant -\varepsilon^{*} \leqslant -2V\varepsilon'^{*}</tex>. Таким образом, поток на ребре <tex>uv</tex> не изменится при итерациях, происходящих после этой группы. Таким образом, по [[#theorem1|теореме]] каждая группа фиксирует поток на независимом ребре.}}

==Алгоритм поиска цикла минимального среднего веса==
===Наивный способ===
Устроим [[Вещественный двоичный поиск |двоичный поиск]].
Установим нижнюю и верхнюю границы величины среднего веса цикла <tex>l</tex> и <tex>r</tex> соответственно, вычислим серединное значение <tex>m</tex> и отнимем полученную величину <tex>m</tex> от всех ребер сети. Если теперь в нашей сети есть отрицательный цикл (этот факт можно проверить при помощи [[Алгоритм Форда-Беллмана #Нахождение отрицательного цикла|алгоритма Форда-Беллмана]]), значит существует цикл с меньшим средним весом, чем <tex>m</tex>. Тогда продолжим поиск среди значений в диапазоне от <tex>l</tex> до <tex>m</tex>, иначе {{---}} от <tex>m</tex> до <tex>r</tex>.

Тогда, если <tex>C_{max}</tex> и <tex>C_{min}</tex> {{---}} максимальная и минимальная возможные величины среднего веса цикла соответственно, такой алгоритм для вещественных значений весов ребер будет работать за <tex>O\left(\log \dfrac{C_{max}-C_{min}}{\varepsilon} \cdot EV\right)</tex>, где <tex>\varepsilon</tex> {{---}} точность выбора среднего веса цикла.
При этом для целочисленных значений на ребрах точность выбора величины среднего веса цикла не может превысить <tex>\dfrac{1}{V}</tex>, что дает нам оценку <tex>O\left(\log (V(C_{max}-C_{min})) \cdot EV\right)</tex>.

====Псевдокод====

'''func''' findMinCycleBinarySearch (l, r):
m = (l + r) / <tex>2</tex>
'''for''' e : edges
e.weight -= m
'''if''' <tex>\exists C</tex> : <tex>\mu (C) < 0</tex>
findMinCycleBinarySearch (l, m)
'''else'''
findMinCycleBinarySearch (m, r)

===Продвинутый алгоритм===
Добавим к нашему графу вершину <tex>s</tex> и ребра из нее во все остальные вершины.
Запустим [[алгоритм Форда-Беллмана]] и попросим его построить нам квадратную матрицу со следующим условием: <tex>d[i][u]</tex> {{---}} длина минимального пути от <tex>s</tex> до <tex>u</tex> ровно из <tex>i</tex> ребер.
Тогда длина оптимального цикла <tex>\mu^{*}</tex> минимального среднего веса вычисляется как <tex>\min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>.

Достаточно будет доказать это правило для <tex>\mu^{*}=0</tex>, так как для других <tex>\mu^{*}</tex> можно просто отнять эту величину от всех ребер и получить снова случай с <tex>\mu^{*}=0</tex>.

Чтобы найти цикл после построения матрицы <tex>d[k][u]</tex>, запомним, при каких <tex>u</tex> и <tex>k</tex> достигается оптимальное значение <tex>\mu^{*}</tex>, и, используя <tex>d[n][u]</tex>, поднимемся по указателям предков. Как только мы попадем в уже посещенную вершину {{---}} мы нашли цикл минимального среднего веса.

Этот алгоритм работает за <tex>O(VE)</tex> <ref>[[Алгоритм Форда-Беллмана #Сложность| Сложность алгоритма Форда-Беллмана]]</ref>.

====Псевдокод====
'''func''' findMinCycle:
'''Node''' s
'''Edge''' e
insert(s) // добавляем мнимую вершину <tex>s</tex> и проводим рёбра нулевого веса в каждую вершину графа
'''for''' u '''in''' <tex>G</tex>
e.begin = s
e.end = u
e.weight = <tex>0</tex>
fordBellman(s)
<tex>\mu^{*} = \min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>

==См. также==
* [[Использование потенциалов Джонсона при поиске потока минимальной стоимости]]
* [[Сведение задачи о назначениях к задаче о потоке минимальной стоимости]]

==Примечания==
<references/>

==Источники информации==
* [https://youtu.be/bykbw7HovSo?t=4287 Лекция 14 | Дополнительные главы алгоритмов | Андрей Станкевич | CSC | Лекториум]
* [http://sirius.cs.put.poznan.pl/~inf84789/acm/p873-goldberg.pdf A.V.Goldberg and R.E.Tarjan {{---}} Finding Minimum-Cost Circulations by Cancelling Negative Cycles (Journal of the Association for Computing Machinery. Vol. 36, No. 4. October 1989. pp. 873-886.)]
*[https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-854j-advanced-algorithms-fall-2008/lecture-notes/lec4.pdf Lecture by M.X.Goemans on Goldberg-Tarjan Min-Cost Circulation Algorithm]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о потоке минимальной стоимости]]

Алгоритм отмены цикла минимального среднего веса

2018-03-30T04:26:32Z

188.227.78.184: /* Псевдокод */

В статье описывается один из сильно полиномиальных алгоритмов решения [[Поток минимальной стоимости #Задача о потоке минимальной стоимости|задачи о поиске потока минимальной стоимости]].
==Алгоритм==
Приведенный алгоритм основан на идее [[Поток минимальной стоимости #Метод устранения отрицательных циклов в остаточной сети|алгоритма Клейна отмены цикла отрицательного веса]]. Выбор цикла минимального среднего веса вместо случайного делает алгоритм сильно полиномиальным.
{{Определение
|definition='''Сильно полиномиальными''' (англ. ''strongly polynomial'') в контексте данной задачи называются алгоритмы, чья сложность полиномиально зависит от <tex>V</tex> и <tex>E</tex>.}}
===Описание===
Обозначим как <tex>c_{f}(C)</tex> остаточную [[Определение сети, потока|пропускную способность]] цикла <tex>C</tex> при протекании в сети потока <tex>f</tex>.
Cтоимость цикла <tex>C</tex> обозначим за <tex>p(C)</tex>, а длину (число входящих в него ребер) {{---}} за <tex>\texttt{len}(C)</tex>.
{{Определение
|definition='''Средним весом''' (англ. ''mean weight'') цикла будем называть отношение его стоимости к его длине <tex>\mu (C)=\dfrac{p(C)}{\texttt{len}(C)}</tex>}}
Данный алгоритм заключается в последовательной отмене циклов минимального среднего веса в [[Дополняющая сеть, дополняющий путь|остаточной сети]] посредством их насыщения. Алгоритм работает до тех пор, пока минимальный средний вес циклов не окажется положительным, что будет означать, что поток минимальной стоимости найден.

Более формально:
* '''Шаг <tex>1</tex>'''. Рассмотрим некоторый поток <tex>f</tex>.
* '''Шаг <tex>2</tex>'''. Найдем цикл <tex>C</tex>, обладающий наименьшим средним весом. Если <tex>\mu (C) \geqslant 0</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости и алгоритм завершается.
* '''Шаг <tex>3</tex>'''. Отменим цикл <tex>C</tex>, пустив по нему максимально возможный поток: <tex>f = f + c_{f}(C)\cdot f_{C}</tex>. Перейдем к '''шагу <tex>1</tex>'''.

===Сложность===
Для сетей с целочисленными стоимостями на ребрах <tex>O(VE\cdot VE\log{CV})</tex>, с вещественными {{---}} <tex>O(VE\cdot VE^{2}\log{V})</tex>.
В обоих случаях <tex>O(VE)</tex> времени тратится на поиск цикла минимального среднего веса.

===Псевдокод===
'''func''' findMin:
'''while''' <tex>f</tex>
<tex>C</tex> = <tex>c</tex> : <tex>\mu(C) </tex>= <tex>\mathrm{min}\mu(c)</tex> // <tex>\mu(C)</tex> {{---}} вес минимального цикла
'''if''' <tex>\mu (C) \geqslant 0</tex>
'''return''' <tex>f</tex> // тогда мы нашли f {{---}} поток минимальной стоимости, алгоритм завершается
'''else'''
<tex>f</tex> += <tex>c_{f}(C)\cdot f_{C}</tex> // иначе отменим цикл

===Корректность===
Пусть <tex>f</tex> {{---}} поток минимальной стоимости. Введём на нашей сети функцию [[Алгоритм Джонсона|потенциалов]] <tex>\varphi</tex>.
{{Определение
|definition='''Приведённой стоимостью''' (англ. ''reduced cost'') ребра назовем следующую величину: <tex>p_{\varphi}(uv)=\varphi(u) + p(uv) - \varphi(v)</tex>.}}
Иными словами, приведённая стоимость {{---}} это сколько нужно потратить денег, чтобы перевезти единицу жидкости из <tex>u</tex> в <tex>v</tex> (её нужно купить в <tex>u</tex>, перевезти из <tex>u</tex> в <tex>v</tex> и продать в <tex>v</tex>).

{{Лемма
|id=lemma1
|about=<tex>1</tex>
|statement=Если <tex>f</tex> {{---}} поток минимальной стоимости, то <tex>\exists \varphi</tex> такое, что <tex>\forall uv: \; c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant 0</tex>.
|proof=
:Рассмотрим остаточную сеть {{---}} граф <tex>G_{f}</tex>. В нем нет отрицательных циклов, так как <tex>f</tex> {{---}} поток минимальной стоимости<ref>[[Лемма об эквивалентности свойства потока быть минимальной стоимости и отсутствии отрицательных циклов в остаточной сети]]</ref>.

:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость минимального пути из <tex>a</tex> в <tex>u</tex>.

:Рассмотрим теперь некоторое ребро <tex>uv</tex>. Понятно, что <tex>\varphi(v) \leqslant \varphi(u) + p(uv)</tex>. (Здесь сравниваются минимальный путь <tex>a \rightsquigarrow v</tex> и путь <tex>a \rightsquigarrow u \rightarrow v</tex>). Перенеся <tex>\varphi(v)</tex> в другую часть неравенства, получаем <tex>0 \leqslant \varphi(u) + p(uv) - \varphi(v)</tex> или <tex>0 \leqslant p_{\varphi}(uv)</tex>.}}

{{Определение
|definition=Будем говорить, что поток <tex>f</tex> {{---}} '''<tex>\varepsilon</tex>-оптимальный''' (англ. ''<tex>\varepsilon</tex>-optimal''), если <tex>\exists \varphi</tex> такая, что <tex>\forall uv: c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant -\varepsilon</tex>.}}

{{Лемма
|id=lemma2
|about=<tex>2</tex>
|statement=Если стоимости целочисленны и поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный, где <tex>\varepsilon < \dfrac{1}{V}</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости.
|proof=
:Рассмотрим цикл в остаточной сети <tex>C</tex>. Заметим, что <tex>p(C)=p_{\varphi}(C)</tex> (для доказательства этого факта достаточно расписать <tex>p_{\varphi}(C)</tex> по определению).

:Возьмем <tex>\varphi</tex> такое, что стоимости всех ребер в <tex>C</tex> не меньше <tex>-\varepsilon</tex>. Тогда стоимость всего цикла <tex>p_{\varphi}(C)\geqslant -V\cdot \varepsilon</tex> (в цикле не больше <tex>V</tex> ребер). Таким образом, <tex>p_{\varphi}(C) > -1</tex>, то есть <tex>p(C) > -1</tex>. Но исходные пропускные способности были целочисленными, поэтому <tex>p(C) \geqslant 0</tex>, а это означает, что в остаточной сети нет отрицательных циклов, и, соответственно, <tex>f</tex> {{---}} поток минимальной стоимости.}}

Обозначим за <tex>\mu^{*}</tex> минимальную величину среди средних весов циклов для потока <tex>f</tex>, а за <tex>\varepsilon^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный.
{{Лемма
|id=lemma3
|about=<tex>3</tex>
|statement=Если <tex>f</tex> {{---}} поток не минимальной стоимости, то <tex>\varepsilon^{*}=-\mu^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса в остаточной сети.
*Покажем, что <tex>\mu^{*} \geqslant -\varepsilon^{*}</tex>.
:Поскольку поток <tex>f</tex> является <tex>\varepsilon^{*}</tex>-оптимальным, верно следующее: <tex>p(C) = p_{\varphi}(C) \geqslant -\texttt{len}(C) \cdot \varepsilon^{*}</tex> или <tex>\dfrac{p(C)}{\texttt{len}(C)} \geqslant -\varepsilon^{*} </tex>, то есть <tex>\mu(C)=\mu^{*} \geqslant -\varepsilon^{*}</tex>.

*Теперь покажем, что <tex>\mu^{*} \leqslant -\varepsilon^{*}</tex>.
:Пусть <tex>p'(uv)=p(uv)-\mu^{*}</tex> для любого <tex>uv \in E_{f}</tex>. Логичным будет также обозначить для некоторого цикла <tex>C</tex> за <tex>\mu'(C)</tex> величину <tex>\dfrac{p'(C)}{\texttt{len}(C)}</tex>. Таким образом, для любого цикла <tex>C</tex>, <tex>\mu'(C)=\mu(C)-\mu^{*}\geqslant 0</tex>.
:Далее проведем рассуждения, аналогичные доказательству [[#lemma1|леммы <tex>1</tex>]].
:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость (считая стоимостью функцию <tex>p'</tex>) минимального пути из <tex>a</tex> в <tex>u</tex>.
:Таким образом, <tex>\varphi(v) \leqslant \varphi(u) + p'(uv) = \varphi(u) + p(uv) - \mu^{*}</tex>. Отсюда получаем, что <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex> для любого ребра <tex>uv</tex> из остаточной сети <tex>E_{f}</tex>, что означает, что <tex>f</tex> {{---}} <tex>(-\mu^{*})</tex>-оптимальный, и, по определению <tex>\varepsilon^{*}</tex>, <tex>\varepsilon^{*} \leqslant -\mu^{*}</tex>.
}}

{{Лемма
|id=lemma4
|about=<tex>4</tex>
|statement=Отмена цикла минимального среднего веса не увеличивает <tex>\varepsilon^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса, который мы хотим отменить на текущем шаге нашего алгоритма. Перед тем, как мы отменим этот цикл, любое ребро в остаточной сети, в том числе, любое входящее в цикл <tex>C</tex> ребро <tex>uv</tex> удовлетворяет свойству <tex>\varepsilon^{*}</tex>-оптимальности: <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>.
:По [[#lemma3|лемме <tex>3</tex>]], <tex>\varepsilon^{*}=-\mu^{*}</tex>, то есть <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex>. Но поскольку <tex>\mu^{*}</tex> {{---}} средний вес цикла, то <tex>p_{\varphi}(uv) = \mu^{*} = -\varepsilon^{*}</tex>.
:По [[Поток минимальной стоимости #Свойства стоимости|свойству антисимметричности потока]], после отмены цикла <tex>C</tex>, в остаточной сети появятся ребра стоимости <tex>\varepsilon</tex>. Таким образом, свойство <tex>p_{\varphi}(uv) \geqslant -\varepsilon</tex> все еще выполняется.
}}

{{Определение
|definition='''Допустимым графом''' (англ. ''admissible graph'') будем называть такой подграф остаточной сети, что он включает только ребра отрицательной приведенной стоимости. <tex>H=\{uv \in E_{f}\;|\; p_{\varphi}(uv) < 0\}</tex>
}}

{{Лемма
|id=lemma5
|about=<tex>5</tex>
|statement=Пусть <tex>f</tex> {{---}} некоторый поток, а <tex>f'</tex> {{---}} поток после <tex>E</tex> отмен циклов минимального среднего веса. Тогда <tex>\varepsilon'^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, где <tex>\varepsilon'^{*}</tex> {{---}} минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный.
|proof=
:Изначально любое ребро <tex>uv</tex> удовлетворяет свойству <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>. Отмена цикла добавляет в остаточную сеть <tex>G_{f}</tex> только ребра положительной приведенной стоимости (см. [[#lemma4|лемму <tex>4</tex>]]) и удаляет из сети <tex>G</tex> как минимум одно ребро. Рассмотрим два случая:
:#Ни один из отмененных циклов не содержал ребер, обладающих неотрицательной приведенной стоимостью. Тогда каждая отмена цикла уменьшает размер допустимого графа <tex>H</tex> и после <tex>E</tex> отмен граф <tex>H</tex> пуст, что означает, что <tex>f'</tex> {{---}} оптимальный поток, то есть <tex>\varepsilon'^{*}=0</tex>.
:#Некоторые из отмененных циклов содержали ребра неотрицательной приведенной стоимости. Пусть впервые такое случилось на <tex>i</tex>-ой итерации, и, соответственно, <tex>C_{i}</tex> {{---}} первый из таких циклов. Для <tex>C_{i}</tex> имеем, что каждое его ребро обладает приведенной стоимостью как минимум <tex>-\varepsilon_{i}^{*}</tex> (при этом <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} \leqslant \varepsilon^{*}</tex> по [[#lemma4|лемме <tex>4</tex>]]), хотя бы одно из ребер <tex>C_{i}</tex> обладает неотрицательной приведенной стоимостью и количество ребер в <tex>C_{i}</tex> не превышает <tex>V</tex>. Тогда средний вес этого цикла <tex>\mu(C_{i}) = \mu_{i}^{*} \geqslant -\left(1-\dfrac{1}{V}\right)\varepsilon_{i}^{*} \geqslant - \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, и <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} = -\mu_{i}^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>.}}

{{Определение
|definition='''<tex>\varepsilon</tex>-фиксированным''' (англ. ''<tex>\varepsilon</tex>-fixed'') будем называть ребро, поток через которое неизменен для любых <tex>\varepsilon</tex>-оптимальных потоков в сети.}}

{{Теорема
|id=theorem1
|statement=Пусть поток <tex>f</tex> является <tex>\varepsilon</tex>-оптимальным с функцией потенциалов <tex>\varphi</tex>. Также пусть для некоторого ребра <tex>uv \; \left|p_{\varphi}(uv)\right| \geqslant 2V\varepsilon</tex>. Тогда ребро <tex>uv</tex> <tex>\varepsilon</tex>-фиксировано.
|proof=
:По свойству антисимметричности, достаточно будет доказать теорему для случая <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon</tex>.

:Рассмотрим такой поток <tex>f'</tex>, что <tex>f'(uv) \neq f(uv)</tex>. Поскольку <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon > \varepsilon</tex>, поток по ребру <tex>uv</tex> должен быть как можно меньше, то есть <tex>f(uv) = -c(uv)</tex>, и тогда раз <tex>f'(uv) \neq f(uv)</tex>, то <tex>f'(uv) > f(uv)</tex>.

:Покажем теперь, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимальный.
:Обозначим за <tex>G_{>}</tex> подграф <tex>G</tex> такой, что <tex>G_{>}=(V, \{uv \in E \;|\; f'(uv) > f(uv) \})</tex>. Рассмотрим некоторое ребро <tex>uv</tex> в <tex>G_{>}</tex>. Поскольку <tex>f</tex> и <tex>f'</tex> являются циркуляциями, в <tex>G_{>}</tex> должен содержаться простой цикл <tex>C</tex>, проходящий через <tex>uv</tex>. Поскольку все ребра в <tex>C</tex> {{---}} остаточные, стоимость <tex>C</tex> не меньше <tex>p_{\varphi}(uv) - (\texttt{len}(C)-1)\varepsilon \geqslant 2V\varepsilon - (V-1)\varepsilon > V\varepsilon</tex>.
:Теперь рассмотрим цикл <tex>\overline{C}</tex>, который получен из <tex>C</tex> разворотом всех его ребер. Заметим, что <tex>\overline{C}</tex> является циклом в <tex>G_{<}=(V,\{uv \in E \;|\; f'(uv) < f(uv)\})</tex> и, соответственно, циклом в <tex>G_{f}</tex>. По свойству антисимметричности, стоимость <tex>\overline{C}</tex> меньше, чем <tex>-V\varepsilon</tex> и, таким образом, <tex>\mu(\overline{C}) < -\varepsilon</tex>. Откуда по [[#lemma3|лемме <tex>3</tex>]] имеем, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимален.
}}

{{Лемма
|about=доказательство оценки времени работы алгоритма в случае вещественных стоимостей
|statement=Пусть <tex>k=VE(\lceil \log V + 1 \rceil)</tex>. Разобьем работу алгоритма на группы по <tex>k</tex> последовательных итераций. Утверждается, что каждая группа фиксирует поток на независимом ребре <tex>uv</tex>, то есть итерации из другой группы не меняют величину <tex>f(uv)</tex>.
|proof=
:Оценка времени работы следует непосредственно из этого утверждения.
:Чтобы доказать его, рассмотрим некоторую группу итераций. Пусть <tex>f</tex> {{---}} поток до первой итерации, а <tex>f'</tex> {{---}} после последней итерации этой группы. Обозначим за <tex>\varepsilon'^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный, а за <tex>\varphi'</tex> {{---}} функцию потенциалов такую, что <tex>f'</tex> удовлетворяет свойству <tex>\varepsilon'^{*}</tex>-оптимальности. Выбор <tex>k</tex> и [[#lemma5|лемма <tex>5</tex>]] дают нам следующее неравенство: <tex>\varepsilon'^{*} \leqslant \varepsilon^{*} \left(1-\dfrac{1}{V} \right)^{V(\log V + 1)} \leqslant \dfrac{\varepsilon^{*}}{2V}</tex>.
:Рассмотрим цикл <tex>C</tex>, отмененный на первой итерации рассматриваемой группы. Поскольку средний вес цикла <tex>C</tex> равен <tex>-\varepsilon^{*}</tex> (см. [[#lemma3|лемму <tex>3</tex>]]), некоторое ребро <tex>uv</tex> цикла <tex>C</tex> должно иметь приведенную стоимость <tex>p_{\varphi'}(uv) \leqslant -\varepsilon^{*} \leqslant -2V\varepsilon'^{*}</tex>. Таким образом, поток на ребре <tex>uv</tex> не изменится при итерациях, происходящих после этой группы. Таким образом, по [[#theorem1|теореме]] каждая группа фиксирует поток на независимом ребре.}}

==Алгоритм поиска цикла минимального среднего веса==
===Наивный способ===
Устроим [[Вещественный двоичный поиск |двоичный поиск]].
Установим нижнюю и верхнюю границы величины среднего веса цикла <tex>l</tex> и <tex>r</tex> соответственно, вычислим серединное значение <tex>m</tex> и отнимем полученную величину <tex>m</tex> от всех ребер сети. Если теперь в нашей сети есть отрицательный цикл (этот факт можно проверить при помощи [[Алгоритм Форда-Беллмана #Нахождение отрицательного цикла|алгоритма Форда-Беллмана]]), значит существует цикл с меньшим средним весом, чем <tex>m</tex>. Тогда продолжим поиск среди значений в диапазоне от <tex>l</tex> до <tex>m</tex>, иначе {{---}} от <tex>m</tex> до <tex>r</tex>.

Тогда, если <tex>C_{max}</tex> и <tex>C_{min}</tex> {{---}} максимальная и минимальная возможные величины среднего веса цикла соответственно, такой алгоритм для вещественных значений весов ребер будет работать за <tex>O\left(\log \dfrac{C_{max}-C_{min}}{\varepsilon} \cdot EV\right)</tex>, где <tex>\varepsilon</tex> {{---}} точность выбора среднего веса цикла.
При этом для целочисленных значений на ребрах точность выбора величины среднего веса цикла не может превысить <tex>\dfrac{1}{V}</tex>, что дает нам оценку <tex>O\left(\log (V(C_{max}-C_{min})) \cdot EV\right)</tex>.

====Псевдокод====

'''func''' findMinCycleBinarySearch (l, r):
m = (l + r) / <tex>2</tex>
'''for''' e : edges
e.weight -= m
'''if''' <tex>\exists C</tex> : <tex>\mu (C) < 0</tex>
findMinCycleBinarySearch (l, m)
'''else'''
findMinCycleBinarySearch (m, r)

===Продвинутый алгоритм===
Добавим к нашему графу вершину <tex>s</tex> и ребра из нее во все остальные вершины.
Запустим [[алгоритм Форда-Беллмана]] и попросим его построить нам квадратную матрицу со следующим условием: <tex>d[i][u]</tex> {{---}} длина минимального пути от <tex>s</tex> до <tex>u</tex> ровно из <tex>i</tex> ребер.
Тогда длина оптимального цикла <tex>\mu^{*}</tex> минимального среднего веса вычисляется как <tex>\min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>.

Достаточно будет доказать это правило для <tex>\mu^{*}=0</tex>, так как для других <tex>\mu^{*}</tex> можно просто отнять эту величину от всех ребер и получить снова случай с <tex>\mu^{*}=0</tex>.

Чтобы найти цикл после построения матрицы <tex>d[k][u]</tex>, запомним, при каких <tex>u</tex> и <tex>k</tex> достигается оптимальное значение <tex>\mu^{*}</tex>, и, используя <tex>d[n][u]</tex>, поднимемся по указателям предков. Как только мы попадем в уже посещенную вершину {{---}} мы нашли цикл минимального среднего веса.

Этот алгоритм работает за <tex>O(VE)</tex> <ref>[[Алгоритм Форда-Беллмана #Сложность| Сложность алгоритма Форда-Беллмана]]</ref>.

====Псевдокод====
'''func''' findMinCycle:
'''Node''' s
'''Edge''' e
insert(s) // добавляем мнимую вершину <tex>s</tex> и проводим рёбра нулевого веса в каждую вершину графа
'''for''' u '''in''' <tex>G</tex>
e.begin = s
e.end = u
e.weight = <tex>0</tex>
fordBellman(s)
<tex>\mu^{*} = \min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>

==См. также==
* [[Использование потенциалов Джонсона при поиске потока минимальной стоимости]]
* [[Сведение задачи о назначениях к задаче о потоке минимальной стоимости]]

==Примечания==
<references/>

==Источники информации==
* [https://youtu.be/bykbw7HovSo?t=4287 Лекция 14 | Дополнительные главы алгоритмов | Андрей Станкевич | CSC | Лекториум]
* [http://sirius.cs.put.poznan.pl/~inf84789/acm/p873-goldberg.pdf A.V.Goldberg and R.E.Tarjan {{---}} Finding Minimum-Cost Circulations by Cancelling Negative Cycles (Journal of the Association for Computing Machinery. Vol. 36, No. 4. October 1989. pp. 873-886.)]
*[https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-854j-advanced-algorithms-fall-2008/lecture-notes/lec4.pdf Lecture by M.X.Goemans on Goldberg-Tarjan Min-Cost Circulation Algorithm]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о потоке минимальной стоимости]]

Алгоритм отмены цикла минимального среднего веса

2018-03-30T04:25:33Z

188.227.78.184: /* Псевдокод */

В статье описывается один из сильно полиномиальных алгоритмов решения [[Поток минимальной стоимости #Задача о потоке минимальной стоимости|задачи о поиске потока минимальной стоимости]].
==Алгоритм==
Приведенный алгоритм основан на идее [[Поток минимальной стоимости #Метод устранения отрицательных циклов в остаточной сети|алгоритма Клейна отмены цикла отрицательного веса]]. Выбор цикла минимального среднего веса вместо случайного делает алгоритм сильно полиномиальным.
{{Определение
|definition='''Сильно полиномиальными''' (англ. ''strongly polynomial'') в контексте данной задачи называются алгоритмы, чья сложность полиномиально зависит от <tex>V</tex> и <tex>E</tex>.}}
===Описание===
Обозначим как <tex>c_{f}(C)</tex> остаточную [[Определение сети, потока|пропускную способность]] цикла <tex>C</tex> при протекании в сети потока <tex>f</tex>.
Cтоимость цикла <tex>C</tex> обозначим за <tex>p(C)</tex>, а длину (число входящих в него ребер) {{---}} за <tex>\texttt{len}(C)</tex>.
{{Определение
|definition='''Средним весом''' (англ. ''mean weight'') цикла будем называть отношение его стоимости к его длине <tex>\mu (C)=\dfrac{p(C)}{\texttt{len}(C)}</tex>}}
Данный алгоритм заключается в последовательной отмене циклов минимального среднего веса в [[Дополняющая сеть, дополняющий путь|остаточной сети]] посредством их насыщения. Алгоритм работает до тех пор, пока минимальный средний вес циклов не окажется положительным, что будет означать, что поток минимальной стоимости найден.

Более формально:
* '''Шаг <tex>1</tex>'''. Рассмотрим некоторый поток <tex>f</tex>.
* '''Шаг <tex>2</tex>'''. Найдем цикл <tex>C</tex>, обладающий наименьшим средним весом. Если <tex>\mu (C) \geqslant 0</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости и алгоритм завершается.
* '''Шаг <tex>3</tex>'''. Отменим цикл <tex>C</tex>, пустив по нему максимально возможный поток: <tex>f = f + c_{f}(C)\cdot f_{C}</tex>. Перейдем к '''шагу <tex>1</tex>'''.

===Сложность===
Для сетей с целочисленными стоимостями на ребрах <tex>O(VE\cdot VE\log{CV})</tex>, с вещественными {{---}} <tex>O(VE\cdot VE^{2}\log{V})</tex>.
В обоих случаях <tex>O(VE)</tex> времени тратится на поиск цикла минимального среднего веса.

===Псевдокод===
'''func''' findMin:
'''while''' <tex>f</tex>
<tex>C</tex> = <tex>c</tex> : <tex>\mu(C) </tex>= <tex>\mathrm{min}\limits_c \mu(c)</tex> // <tex>\mu(C)</tex> {{---}} вес минимального цикла
'''if''' <tex>\mu (C) \geqslant 0</tex>
'''return''' <tex>f</tex> // тогда мы нашли f {{---}} поток минимальной стоимости, алгоритм завершается
'''else'''
<tex>f</tex> += <tex>c_{f}(C)\cdot f_{C}</tex> // иначе отменим цикл

===Корректность===
Пусть <tex>f</tex> {{---}} поток минимальной стоимости. Введём на нашей сети функцию [[Алгоритм Джонсона|потенциалов]] <tex>\varphi</tex>.
{{Определение
|definition='''Приведённой стоимостью''' (англ. ''reduced cost'') ребра назовем следующую величину: <tex>p_{\varphi}(uv)=\varphi(u) + p(uv) - \varphi(v)</tex>.}}
Иными словами, приведённая стоимость {{---}} это сколько нужно потратить денег, чтобы перевезти единицу жидкости из <tex>u</tex> в <tex>v</tex> (её нужно купить в <tex>u</tex>, перевезти из <tex>u</tex> в <tex>v</tex> и продать в <tex>v</tex>).

{{Лемма
|id=lemma1
|about=<tex>1</tex>
|statement=Если <tex>f</tex> {{---}} поток минимальной стоимости, то <tex>\exists \varphi</tex> такое, что <tex>\forall uv: \; c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant 0</tex>.
|proof=
:Рассмотрим остаточную сеть {{---}} граф <tex>G_{f}</tex>. В нем нет отрицательных циклов, так как <tex>f</tex> {{---}} поток минимальной стоимости<ref>[[Лемма об эквивалентности свойства потока быть минимальной стоимости и отсутствии отрицательных циклов в остаточной сети]]</ref>.

:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость минимального пути из <tex>a</tex> в <tex>u</tex>.

:Рассмотрим теперь некоторое ребро <tex>uv</tex>. Понятно, что <tex>\varphi(v) \leqslant \varphi(u) + p(uv)</tex>. (Здесь сравниваются минимальный путь <tex>a \rightsquigarrow v</tex> и путь <tex>a \rightsquigarrow u \rightarrow v</tex>). Перенеся <tex>\varphi(v)</tex> в другую часть неравенства, получаем <tex>0 \leqslant \varphi(u) + p(uv) - \varphi(v)</tex> или <tex>0 \leqslant p_{\varphi}(uv)</tex>.}}

{{Определение
|definition=Будем говорить, что поток <tex>f</tex> {{---}} '''<tex>\varepsilon</tex>-оптимальный''' (англ. ''<tex>\varepsilon</tex>-optimal''), если <tex>\exists \varphi</tex> такая, что <tex>\forall uv: c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant -\varepsilon</tex>.}}

{{Лемма
|id=lemma2
|about=<tex>2</tex>
|statement=Если стоимости целочисленны и поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный, где <tex>\varepsilon < \dfrac{1}{V}</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости.
|proof=
:Рассмотрим цикл в остаточной сети <tex>C</tex>. Заметим, что <tex>p(C)=p_{\varphi}(C)</tex> (для доказательства этого факта достаточно расписать <tex>p_{\varphi}(C)</tex> по определению).

:Возьмем <tex>\varphi</tex> такое, что стоимости всех ребер в <tex>C</tex> не меньше <tex>-\varepsilon</tex>. Тогда стоимость всего цикла <tex>p_{\varphi}(C)\geqslant -V\cdot \varepsilon</tex> (в цикле не больше <tex>V</tex> ребер). Таким образом, <tex>p_{\varphi}(C) > -1</tex>, то есть <tex>p(C) > -1</tex>. Но исходные пропускные способности были целочисленными, поэтому <tex>p(C) \geqslant 0</tex>, а это означает, что в остаточной сети нет отрицательных циклов, и, соответственно, <tex>f</tex> {{---}} поток минимальной стоимости.}}

Обозначим за <tex>\mu^{*}</tex> минимальную величину среди средних весов циклов для потока <tex>f</tex>, а за <tex>\varepsilon^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный.
{{Лемма
|id=lemma3
|about=<tex>3</tex>
|statement=Если <tex>f</tex> {{---}} поток не минимальной стоимости, то <tex>\varepsilon^{*}=-\mu^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса в остаточной сети.
*Покажем, что <tex>\mu^{*} \geqslant -\varepsilon^{*}</tex>.
:Поскольку поток <tex>f</tex> является <tex>\varepsilon^{*}</tex>-оптимальным, верно следующее: <tex>p(C) = p_{\varphi}(C) \geqslant -\texttt{len}(C) \cdot \varepsilon^{*}</tex> или <tex>\dfrac{p(C)}{\texttt{len}(C)} \geqslant -\varepsilon^{*} </tex>, то есть <tex>\mu(C)=\mu^{*} \geqslant -\varepsilon^{*}</tex>.

*Теперь покажем, что <tex>\mu^{*} \leqslant -\varepsilon^{*}</tex>.
:Пусть <tex>p'(uv)=p(uv)-\mu^{*}</tex> для любого <tex>uv \in E_{f}</tex>. Логичным будет также обозначить для некоторого цикла <tex>C</tex> за <tex>\mu'(C)</tex> величину <tex>\dfrac{p'(C)}{\texttt{len}(C)}</tex>. Таким образом, для любого цикла <tex>C</tex>, <tex>\mu'(C)=\mu(C)-\mu^{*}\geqslant 0</tex>.
:Далее проведем рассуждения, аналогичные доказательству [[#lemma1|леммы <tex>1</tex>]].
:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость (считая стоимостью функцию <tex>p'</tex>) минимального пути из <tex>a</tex> в <tex>u</tex>.
:Таким образом, <tex>\varphi(v) \leqslant \varphi(u) + p'(uv) = \varphi(u) + p(uv) - \mu^{*}</tex>. Отсюда получаем, что <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex> для любого ребра <tex>uv</tex> из остаточной сети <tex>E_{f}</tex>, что означает, что <tex>f</tex> {{---}} <tex>(-\mu^{*})</tex>-оптимальный, и, по определению <tex>\varepsilon^{*}</tex>, <tex>\varepsilon^{*} \leqslant -\mu^{*}</tex>.
}}

{{Лемма
|id=lemma4
|about=<tex>4</tex>
|statement=Отмена цикла минимального среднего веса не увеличивает <tex>\varepsilon^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса, который мы хотим отменить на текущем шаге нашего алгоритма. Перед тем, как мы отменим этот цикл, любое ребро в остаточной сети, в том числе, любое входящее в цикл <tex>C</tex> ребро <tex>uv</tex> удовлетворяет свойству <tex>\varepsilon^{*}</tex>-оптимальности: <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>.
:По [[#lemma3|лемме <tex>3</tex>]], <tex>\varepsilon^{*}=-\mu^{*}</tex>, то есть <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex>. Но поскольку <tex>\mu^{*}</tex> {{---}} средний вес цикла, то <tex>p_{\varphi}(uv) = \mu^{*} = -\varepsilon^{*}</tex>.
:По [[Поток минимальной стоимости #Свойства стоимости|свойству антисимметричности потока]], после отмены цикла <tex>C</tex>, в остаточной сети появятся ребра стоимости <tex>\varepsilon</tex>. Таким образом, свойство <tex>p_{\varphi}(uv) \geqslant -\varepsilon</tex> все еще выполняется.
}}

{{Определение
|definition='''Допустимым графом''' (англ. ''admissible graph'') будем называть такой подграф остаточной сети, что он включает только ребра отрицательной приведенной стоимости. <tex>H=\{uv \in E_{f}\;|\; p_{\varphi}(uv) < 0\}</tex>
}}

{{Лемма
|id=lemma5
|about=<tex>5</tex>
|statement=Пусть <tex>f</tex> {{---}} некоторый поток, а <tex>f'</tex> {{---}} поток после <tex>E</tex> отмен циклов минимального среднего веса. Тогда <tex>\varepsilon'^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, где <tex>\varepsilon'^{*}</tex> {{---}} минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный.
|proof=
:Изначально любое ребро <tex>uv</tex> удовлетворяет свойству <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>. Отмена цикла добавляет в остаточную сеть <tex>G_{f}</tex> только ребра положительной приведенной стоимости (см. [[#lemma4|лемму <tex>4</tex>]]) и удаляет из сети <tex>G</tex> как минимум одно ребро. Рассмотрим два случая:
:#Ни один из отмененных циклов не содержал ребер, обладающих неотрицательной приведенной стоимостью. Тогда каждая отмена цикла уменьшает размер допустимого графа <tex>H</tex> и после <tex>E</tex> отмен граф <tex>H</tex> пуст, что означает, что <tex>f'</tex> {{---}} оптимальный поток, то есть <tex>\varepsilon'^{*}=0</tex>.
:#Некоторые из отмененных циклов содержали ребра неотрицательной приведенной стоимости. Пусть впервые такое случилось на <tex>i</tex>-ой итерации, и, соответственно, <tex>C_{i}</tex> {{---}} первый из таких циклов. Для <tex>C_{i}</tex> имеем, что каждое его ребро обладает приведенной стоимостью как минимум <tex>-\varepsilon_{i}^{*}</tex> (при этом <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} \leqslant \varepsilon^{*}</tex> по [[#lemma4|лемме <tex>4</tex>]]), хотя бы одно из ребер <tex>C_{i}</tex> обладает неотрицательной приведенной стоимостью и количество ребер в <tex>C_{i}</tex> не превышает <tex>V</tex>. Тогда средний вес этого цикла <tex>\mu(C_{i}) = \mu_{i}^{*} \geqslant -\left(1-\dfrac{1}{V}\right)\varepsilon_{i}^{*} \geqslant - \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, и <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} = -\mu_{i}^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>.}}

{{Определение
|definition='''<tex>\varepsilon</tex>-фиксированным''' (англ. ''<tex>\varepsilon</tex>-fixed'') будем называть ребро, поток через которое неизменен для любых <tex>\varepsilon</tex>-оптимальных потоков в сети.}}

{{Теорема
|id=theorem1
|statement=Пусть поток <tex>f</tex> является <tex>\varepsilon</tex>-оптимальным с функцией потенциалов <tex>\varphi</tex>. Также пусть для некоторого ребра <tex>uv \; \left|p_{\varphi}(uv)\right| \geqslant 2V\varepsilon</tex>. Тогда ребро <tex>uv</tex> <tex>\varepsilon</tex>-фиксировано.
|proof=
:По свойству антисимметричности, достаточно будет доказать теорему для случая <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon</tex>.

:Рассмотрим такой поток <tex>f'</tex>, что <tex>f'(uv) \neq f(uv)</tex>. Поскольку <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon > \varepsilon</tex>, поток по ребру <tex>uv</tex> должен быть как можно меньше, то есть <tex>f(uv) = -c(uv)</tex>, и тогда раз <tex>f'(uv) \neq f(uv)</tex>, то <tex>f'(uv) > f(uv)</tex>.

:Покажем теперь, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимальный.
:Обозначим за <tex>G_{>}</tex> подграф <tex>G</tex> такой, что <tex>G_{>}=(V, \{uv \in E \;|\; f'(uv) > f(uv) \})</tex>. Рассмотрим некоторое ребро <tex>uv</tex> в <tex>G_{>}</tex>. Поскольку <tex>f</tex> и <tex>f'</tex> являются циркуляциями, в <tex>G_{>}</tex> должен содержаться простой цикл <tex>C</tex>, проходящий через <tex>uv</tex>. Поскольку все ребра в <tex>C</tex> {{---}} остаточные, стоимость <tex>C</tex> не меньше <tex>p_{\varphi}(uv) - (\texttt{len}(C)-1)\varepsilon \geqslant 2V\varepsilon - (V-1)\varepsilon > V\varepsilon</tex>.
:Теперь рассмотрим цикл <tex>\overline{C}</tex>, который получен из <tex>C</tex> разворотом всех его ребер. Заметим, что <tex>\overline{C}</tex> является циклом в <tex>G_{<}=(V,\{uv \in E \;|\; f'(uv) < f(uv)\})</tex> и, соответственно, циклом в <tex>G_{f}</tex>. По свойству антисимметричности, стоимость <tex>\overline{C}</tex> меньше, чем <tex>-V\varepsilon</tex> и, таким образом, <tex>\mu(\overline{C}) < -\varepsilon</tex>. Откуда по [[#lemma3|лемме <tex>3</tex>]] имеем, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимален.
}}

{{Лемма
|about=доказательство оценки времени работы алгоритма в случае вещественных стоимостей
|statement=Пусть <tex>k=VE(\lceil \log V + 1 \rceil)</tex>. Разобьем работу алгоритма на группы по <tex>k</tex> последовательных итераций. Утверждается, что каждая группа фиксирует поток на независимом ребре <tex>uv</tex>, то есть итерации из другой группы не меняют величину <tex>f(uv)</tex>.
|proof=
:Оценка времени работы следует непосредственно из этого утверждения.
:Чтобы доказать его, рассмотрим некоторую группу итераций. Пусть <tex>f</tex> {{---}} поток до первой итерации, а <tex>f'</tex> {{---}} после последней итерации этой группы. Обозначим за <tex>\varepsilon'^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный, а за <tex>\varphi'</tex> {{---}} функцию потенциалов такую, что <tex>f'</tex> удовлетворяет свойству <tex>\varepsilon'^{*}</tex>-оптимальности. Выбор <tex>k</tex> и [[#lemma5|лемма <tex>5</tex>]] дают нам следующее неравенство: <tex>\varepsilon'^{*} \leqslant \varepsilon^{*} \left(1-\dfrac{1}{V} \right)^{V(\log V + 1)} \leqslant \dfrac{\varepsilon^{*}}{2V}</tex>.
:Рассмотрим цикл <tex>C</tex>, отмененный на первой итерации рассматриваемой группы. Поскольку средний вес цикла <tex>C</tex> равен <tex>-\varepsilon^{*}</tex> (см. [[#lemma3|лемму <tex>3</tex>]]), некоторое ребро <tex>uv</tex> цикла <tex>C</tex> должно иметь приведенную стоимость <tex>p_{\varphi'}(uv) \leqslant -\varepsilon^{*} \leqslant -2V\varepsilon'^{*}</tex>. Таким образом, поток на ребре <tex>uv</tex> не изменится при итерациях, происходящих после этой группы. Таким образом, по [[#theorem1|теореме]] каждая группа фиксирует поток на независимом ребре.}}

==Алгоритм поиска цикла минимального среднего веса==
===Наивный способ===
Устроим [[Вещественный двоичный поиск |двоичный поиск]].
Установим нижнюю и верхнюю границы величины среднего веса цикла <tex>l</tex> и <tex>r</tex> соответственно, вычислим серединное значение <tex>m</tex> и отнимем полученную величину <tex>m</tex> от всех ребер сети. Если теперь в нашей сети есть отрицательный цикл (этот факт можно проверить при помощи [[Алгоритм Форда-Беллмана #Нахождение отрицательного цикла|алгоритма Форда-Беллмана]]), значит существует цикл с меньшим средним весом, чем <tex>m</tex>. Тогда продолжим поиск среди значений в диапазоне от <tex>l</tex> до <tex>m</tex>, иначе {{---}} от <tex>m</tex> до <tex>r</tex>.

Тогда, если <tex>C_{max}</tex> и <tex>C_{min}</tex> {{---}} максимальная и минимальная возможные величины среднего веса цикла соответственно, такой алгоритм для вещественных значений весов ребер будет работать за <tex>O\left(\log \dfrac{C_{max}-C_{min}}{\varepsilon} \cdot EV\right)</tex>, где <tex>\varepsilon</tex> {{---}} точность выбора среднего веса цикла.
При этом для целочисленных значений на ребрах точность выбора величины среднего веса цикла не может превысить <tex>\dfrac{1}{V}</tex>, что дает нам оценку <tex>O\left(\log (V(C_{max}-C_{min})) \cdot EV\right)</tex>.

====Псевдокод====

'''func''' findMinCycleBinarySearch (l, r):
m = (l + r) / <tex>2</tex>
'''for''' e : edges
e.weight -= m
'''if''' <tex>\exists C</tex> : <tex>\mu (C) < 0</tex>
findMinCycleBinarySearch (l, m)
'''else'''
findMinCycleBinarySearch (m, r)

===Продвинутый алгоритм===
Добавим к нашему графу вершину <tex>s</tex> и ребра из нее во все остальные вершины.
Запустим [[алгоритм Форда-Беллмана]] и попросим его построить нам квадратную матрицу со следующим условием: <tex>d[i][u]</tex> {{---}} длина минимального пути от <tex>s</tex> до <tex>u</tex> ровно из <tex>i</tex> ребер.
Тогда длина оптимального цикла <tex>\mu^{*}</tex> минимального среднего веса вычисляется как <tex>\min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>.

Достаточно будет доказать это правило для <tex>\mu^{*}=0</tex>, так как для других <tex>\mu^{*}</tex> можно просто отнять эту величину от всех ребер и получить снова случай с <tex>\mu^{*}=0</tex>.

Чтобы найти цикл после построения матрицы <tex>d[k][u]</tex>, запомним, при каких <tex>u</tex> и <tex>k</tex> достигается оптимальное значение <tex>\mu^{*}</tex>, и, используя <tex>d[n][u]</tex>, поднимемся по указателям предков. Как только мы попадем в уже посещенную вершину {{---}} мы нашли цикл минимального среднего веса.

Этот алгоритм работает за <tex>O(VE)</tex> <ref>[[Алгоритм Форда-Беллмана #Сложность| Сложность алгоритма Форда-Беллмана]]</ref>.

====Псевдокод====
'''func''' findMinCycle:
'''Node''' s
'''Edge''' e
insert(s) // добавляем мнимую вершину <tex>s</tex> и проводим рёбра нулевого веса в каждую вершину графа
'''for''' u '''in''' <tex>G</tex>
e.begin = s
e.end = u
e.weight = <tex>0</tex>
fordBellman(s)
<tex>\mu^{*} = \min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>

==См. также==
* [[Использование потенциалов Джонсона при поиске потока минимальной стоимости]]
* [[Сведение задачи о назначениях к задаче о потоке минимальной стоимости]]

==Примечания==
<references/>

==Источники информации==
* [https://youtu.be/bykbw7HovSo?t=4287 Лекция 14 | Дополнительные главы алгоритмов | Андрей Станкевич | CSC | Лекториум]
* [http://sirius.cs.put.poznan.pl/~inf84789/acm/p873-goldberg.pdf A.V.Goldberg and R.E.Tarjan {{---}} Finding Minimum-Cost Circulations by Cancelling Negative Cycles (Journal of the Association for Computing Machinery. Vol. 36, No. 4. October 1989. pp. 873-886.)]
*[https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-854j-advanced-algorithms-fall-2008/lecture-notes/lec4.pdf Lecture by M.X.Goemans on Goldberg-Tarjan Min-Cost Circulation Algorithm]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о потоке минимальной стоимости]]

Алгоритм отмены цикла минимального среднего веса

2018-03-30T04:24:05Z

188.227.78.184: /* Псевдокод */

В статье описывается один из сильно полиномиальных алгоритмов решения [[Поток минимальной стоимости #Задача о потоке минимальной стоимости|задачи о поиске потока минимальной стоимости]].
==Алгоритм==
Приведенный алгоритм основан на идее [[Поток минимальной стоимости #Метод устранения отрицательных циклов в остаточной сети|алгоритма Клейна отмены цикла отрицательного веса]]. Выбор цикла минимального среднего веса вместо случайного делает алгоритм сильно полиномиальным.
{{Определение
|definition='''Сильно полиномиальными''' (англ. ''strongly polynomial'') в контексте данной задачи называются алгоритмы, чья сложность полиномиально зависит от <tex>V</tex> и <tex>E</tex>.}}
===Описание===
Обозначим как <tex>c_{f}(C)</tex> остаточную [[Определение сети, потока|пропускную способность]] цикла <tex>C</tex> при протекании в сети потока <tex>f</tex>.
Cтоимость цикла <tex>C</tex> обозначим за <tex>p(C)</tex>, а длину (число входящих в него ребер) {{---}} за <tex>\texttt{len}(C)</tex>.
{{Определение
|definition='''Средним весом''' (англ. ''mean weight'') цикла будем называть отношение его стоимости к его длине <tex>\mu (C)=\dfrac{p(C)}{\texttt{len}(C)}</tex>}}
Данный алгоритм заключается в последовательной отмене циклов минимального среднего веса в [[Дополняющая сеть, дополняющий путь|остаточной сети]] посредством их насыщения. Алгоритм работает до тех пор, пока минимальный средний вес циклов не окажется положительным, что будет означать, что поток минимальной стоимости найден.

Более формально:
* '''Шаг <tex>1</tex>'''. Рассмотрим некоторый поток <tex>f</tex>.
* '''Шаг <tex>2</tex>'''. Найдем цикл <tex>C</tex>, обладающий наименьшим средним весом. Если <tex>\mu (C) \geqslant 0</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости и алгоритм завершается.
* '''Шаг <tex>3</tex>'''. Отменим цикл <tex>C</tex>, пустив по нему максимально возможный поток: <tex>f = f + c_{f}(C)\cdot f_{C}</tex>. Перейдем к '''шагу <tex>1</tex>'''.

===Сложность===
Для сетей с целочисленными стоимостями на ребрах <tex>O(VE\cdot VE\log{CV})</tex>, с вещественными {{---}} <tex>O(VE\cdot VE^{2}\log{V})</tex>.
В обоих случаях <tex>O(VE)</tex> времени тратится на поиск цикла минимального среднего веса.

===Псевдокод===
'''func''' findMin:
'''while''' <tex>f</tex>
<tex>C</tex> = <tex>c</tex> : <tex>\mu(C) =\mathrm{min}\limits_c \mu(c)</tex> // <tex>\mu(C)</tex> {{---}} вес минимального цикла
'''if''' <tex>\mu (C) \geqslant 0</tex>
'''return''' <tex>f</tex> // тогда мы нашли f {{---}} поток минимальной стоимости, алгоритм завершается
'''else'''
<tex>f</tex> += <tex>c_{f}(C)\cdot f_{C}</tex> // иначе отменим цикл

===Корректность===
Пусть <tex>f</tex> {{---}} поток минимальной стоимости. Введём на нашей сети функцию [[Алгоритм Джонсона|потенциалов]] <tex>\varphi</tex>.
{{Определение
|definition='''Приведённой стоимостью''' (англ. ''reduced cost'') ребра назовем следующую величину: <tex>p_{\varphi}(uv)=\varphi(u) + p(uv) - \varphi(v)</tex>.}}
Иными словами, приведённая стоимость {{---}} это сколько нужно потратить денег, чтобы перевезти единицу жидкости из <tex>u</tex> в <tex>v</tex> (её нужно купить в <tex>u</tex>, перевезти из <tex>u</tex> в <tex>v</tex> и продать в <tex>v</tex>).

{{Лемма
|id=lemma1
|about=<tex>1</tex>
|statement=Если <tex>f</tex> {{---}} поток минимальной стоимости, то <tex>\exists \varphi</tex> такое, что <tex>\forall uv: \; c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant 0</tex>.
|proof=
:Рассмотрим остаточную сеть {{---}} граф <tex>G_{f}</tex>. В нем нет отрицательных циклов, так как <tex>f</tex> {{---}} поток минимальной стоимости<ref>[[Лемма об эквивалентности свойства потока быть минимальной стоимости и отсутствии отрицательных циклов в остаточной сети]]</ref>.

:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость минимального пути из <tex>a</tex> в <tex>u</tex>.

:Рассмотрим теперь некоторое ребро <tex>uv</tex>. Понятно, что <tex>\varphi(v) \leqslant \varphi(u) + p(uv)</tex>. (Здесь сравниваются минимальный путь <tex>a \rightsquigarrow v</tex> и путь <tex>a \rightsquigarrow u \rightarrow v</tex>). Перенеся <tex>\varphi(v)</tex> в другую часть неравенства, получаем <tex>0 \leqslant \varphi(u) + p(uv) - \varphi(v)</tex> или <tex>0 \leqslant p_{\varphi}(uv)</tex>.}}

{{Определение
|definition=Будем говорить, что поток <tex>f</tex> {{---}} '''<tex>\varepsilon</tex>-оптимальный''' (англ. ''<tex>\varepsilon</tex>-optimal''), если <tex>\exists \varphi</tex> такая, что <tex>\forall uv: c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant -\varepsilon</tex>.}}

{{Лемма
|id=lemma2
|about=<tex>2</tex>
|statement=Если стоимости целочисленны и поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный, где <tex>\varepsilon < \dfrac{1}{V}</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости.
|proof=
:Рассмотрим цикл в остаточной сети <tex>C</tex>. Заметим, что <tex>p(C)=p_{\varphi}(C)</tex> (для доказательства этого факта достаточно расписать <tex>p_{\varphi}(C)</tex> по определению).

:Возьмем <tex>\varphi</tex> такое, что стоимости всех ребер в <tex>C</tex> не меньше <tex>-\varepsilon</tex>. Тогда стоимость всего цикла <tex>p_{\varphi}(C)\geqslant -V\cdot \varepsilon</tex> (в цикле не больше <tex>V</tex> ребер). Таким образом, <tex>p_{\varphi}(C) > -1</tex>, то есть <tex>p(C) > -1</tex>. Но исходные пропускные способности были целочисленными, поэтому <tex>p(C) \geqslant 0</tex>, а это означает, что в остаточной сети нет отрицательных циклов, и, соответственно, <tex>f</tex> {{---}} поток минимальной стоимости.}}

Обозначим за <tex>\mu^{*}</tex> минимальную величину среди средних весов циклов для потока <tex>f</tex>, а за <tex>\varepsilon^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный.
{{Лемма
|id=lemma3
|about=<tex>3</tex>
|statement=Если <tex>f</tex> {{---}} поток не минимальной стоимости, то <tex>\varepsilon^{*}=-\mu^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса в остаточной сети.
*Покажем, что <tex>\mu^{*} \geqslant -\varepsilon^{*}</tex>.
:Поскольку поток <tex>f</tex> является <tex>\varepsilon^{*}</tex>-оптимальным, верно следующее: <tex>p(C) = p_{\varphi}(C) \geqslant -\texttt{len}(C) \cdot \varepsilon^{*}</tex> или <tex>\dfrac{p(C)}{\texttt{len}(C)} \geqslant -\varepsilon^{*} </tex>, то есть <tex>\mu(C)=\mu^{*} \geqslant -\varepsilon^{*}</tex>.

*Теперь покажем, что <tex>\mu^{*} \leqslant -\varepsilon^{*}</tex>.
:Пусть <tex>p'(uv)=p(uv)-\mu^{*}</tex> для любого <tex>uv \in E_{f}</tex>. Логичным будет также обозначить для некоторого цикла <tex>C</tex> за <tex>\mu'(C)</tex> величину <tex>\dfrac{p'(C)}{\texttt{len}(C)}</tex>. Таким образом, для любого цикла <tex>C</tex>, <tex>\mu'(C)=\mu(C)-\mu^{*}\geqslant 0</tex>.
:Далее проведем рассуждения, аналогичные доказательству [[#lemma1|леммы <tex>1</tex>]].
:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость (считая стоимостью функцию <tex>p'</tex>) минимального пути из <tex>a</tex> в <tex>u</tex>.
:Таким образом, <tex>\varphi(v) \leqslant \varphi(u) + p'(uv) = \varphi(u) + p(uv) - \mu^{*}</tex>. Отсюда получаем, что <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex> для любого ребра <tex>uv</tex> из остаточной сети <tex>E_{f}</tex>, что означает, что <tex>f</tex> {{---}} <tex>(-\mu^{*})</tex>-оптимальный, и, по определению <tex>\varepsilon^{*}</tex>, <tex>\varepsilon^{*} \leqslant -\mu^{*}</tex>.
}}

{{Лемма
|id=lemma4
|about=<tex>4</tex>
|statement=Отмена цикла минимального среднего веса не увеличивает <tex>\varepsilon^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса, который мы хотим отменить на текущем шаге нашего алгоритма. Перед тем, как мы отменим этот цикл, любое ребро в остаточной сети, в том числе, любое входящее в цикл <tex>C</tex> ребро <tex>uv</tex> удовлетворяет свойству <tex>\varepsilon^{*}</tex>-оптимальности: <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>.
:По [[#lemma3|лемме <tex>3</tex>]], <tex>\varepsilon^{*}=-\mu^{*}</tex>, то есть <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex>. Но поскольку <tex>\mu^{*}</tex> {{---}} средний вес цикла, то <tex>p_{\varphi}(uv) = \mu^{*} = -\varepsilon^{*}</tex>.
:По [[Поток минимальной стоимости #Свойства стоимости|свойству антисимметричности потока]], после отмены цикла <tex>C</tex>, в остаточной сети появятся ребра стоимости <tex>\varepsilon</tex>. Таким образом, свойство <tex>p_{\varphi}(uv) \geqslant -\varepsilon</tex> все еще выполняется.
}}

{{Определение
|definition='''Допустимым графом''' (англ. ''admissible graph'') будем называть такой подграф остаточной сети, что он включает только ребра отрицательной приведенной стоимости. <tex>H=\{uv \in E_{f}\;|\; p_{\varphi}(uv) < 0\}</tex>
}}

{{Лемма
|id=lemma5
|about=<tex>5</tex>
|statement=Пусть <tex>f</tex> {{---}} некоторый поток, а <tex>f'</tex> {{---}} поток после <tex>E</tex> отмен циклов минимального среднего веса. Тогда <tex>\varepsilon'^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, где <tex>\varepsilon'^{*}</tex> {{---}} минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный.
|proof=
:Изначально любое ребро <tex>uv</tex> удовлетворяет свойству <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>. Отмена цикла добавляет в остаточную сеть <tex>G_{f}</tex> только ребра положительной приведенной стоимости (см. [[#lemma4|лемму <tex>4</tex>]]) и удаляет из сети <tex>G</tex> как минимум одно ребро. Рассмотрим два случая:
:#Ни один из отмененных циклов не содержал ребер, обладающих неотрицательной приведенной стоимостью. Тогда каждая отмена цикла уменьшает размер допустимого графа <tex>H</tex> и после <tex>E</tex> отмен граф <tex>H</tex> пуст, что означает, что <tex>f'</tex> {{---}} оптимальный поток, то есть <tex>\varepsilon'^{*}=0</tex>.
:#Некоторые из отмененных циклов содержали ребра неотрицательной приведенной стоимости. Пусть впервые такое случилось на <tex>i</tex>-ой итерации, и, соответственно, <tex>C_{i}</tex> {{---}} первый из таких циклов. Для <tex>C_{i}</tex> имеем, что каждое его ребро обладает приведенной стоимостью как минимум <tex>-\varepsilon_{i}^{*}</tex> (при этом <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} \leqslant \varepsilon^{*}</tex> по [[#lemma4|лемме <tex>4</tex>]]), хотя бы одно из ребер <tex>C_{i}</tex> обладает неотрицательной приведенной стоимостью и количество ребер в <tex>C_{i}</tex> не превышает <tex>V</tex>. Тогда средний вес этого цикла <tex>\mu(C_{i}) = \mu_{i}^{*} \geqslant -\left(1-\dfrac{1}{V}\right)\varepsilon_{i}^{*} \geqslant - \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, и <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} = -\mu_{i}^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>.}}

{{Определение
|definition='''<tex>\varepsilon</tex>-фиксированным''' (англ. ''<tex>\varepsilon</tex>-fixed'') будем называть ребро, поток через которое неизменен для любых <tex>\varepsilon</tex>-оптимальных потоков в сети.}}

{{Теорема
|id=theorem1
|statement=Пусть поток <tex>f</tex> является <tex>\varepsilon</tex>-оптимальным с функцией потенциалов <tex>\varphi</tex>. Также пусть для некоторого ребра <tex>uv \; \left|p_{\varphi}(uv)\right| \geqslant 2V\varepsilon</tex>. Тогда ребро <tex>uv</tex> <tex>\varepsilon</tex>-фиксировано.
|proof=
:По свойству антисимметричности, достаточно будет доказать теорему для случая <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon</tex>.

:Рассмотрим такой поток <tex>f'</tex>, что <tex>f'(uv) \neq f(uv)</tex>. Поскольку <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon > \varepsilon</tex>, поток по ребру <tex>uv</tex> должен быть как можно меньше, то есть <tex>f(uv) = -c(uv)</tex>, и тогда раз <tex>f'(uv) \neq f(uv)</tex>, то <tex>f'(uv) > f(uv)</tex>.

:Покажем теперь, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимальный.
:Обозначим за <tex>G_{>}</tex> подграф <tex>G</tex> такой, что <tex>G_{>}=(V, \{uv \in E \;|\; f'(uv) > f(uv) \})</tex>. Рассмотрим некоторое ребро <tex>uv</tex> в <tex>G_{>}</tex>. Поскольку <tex>f</tex> и <tex>f'</tex> являются циркуляциями, в <tex>G_{>}</tex> должен содержаться простой цикл <tex>C</tex>, проходящий через <tex>uv</tex>. Поскольку все ребра в <tex>C</tex> {{---}} остаточные, стоимость <tex>C</tex> не меньше <tex>p_{\varphi}(uv) - (\texttt{len}(C)-1)\varepsilon \geqslant 2V\varepsilon - (V-1)\varepsilon > V\varepsilon</tex>.
:Теперь рассмотрим цикл <tex>\overline{C}</tex>, который получен из <tex>C</tex> разворотом всех его ребер. Заметим, что <tex>\overline{C}</tex> является циклом в <tex>G_{<}=(V,\{uv \in E \;|\; f'(uv) < f(uv)\})</tex> и, соответственно, циклом в <tex>G_{f}</tex>. По свойству антисимметричности, стоимость <tex>\overline{C}</tex> меньше, чем <tex>-V\varepsilon</tex> и, таким образом, <tex>\mu(\overline{C}) < -\varepsilon</tex>. Откуда по [[#lemma3|лемме <tex>3</tex>]] имеем, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимален.
}}

{{Лемма
|about=доказательство оценки времени работы алгоритма в случае вещественных стоимостей
|statement=Пусть <tex>k=VE(\lceil \log V + 1 \rceil)</tex>. Разобьем работу алгоритма на группы по <tex>k</tex> последовательных итераций. Утверждается, что каждая группа фиксирует поток на независимом ребре <tex>uv</tex>, то есть итерации из другой группы не меняют величину <tex>f(uv)</tex>.
|proof=
:Оценка времени работы следует непосредственно из этого утверждения.
:Чтобы доказать его, рассмотрим некоторую группу итераций. Пусть <tex>f</tex> {{---}} поток до первой итерации, а <tex>f'</tex> {{---}} после последней итерации этой группы. Обозначим за <tex>\varepsilon'^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный, а за <tex>\varphi'</tex> {{---}} функцию потенциалов такую, что <tex>f'</tex> удовлетворяет свойству <tex>\varepsilon'^{*}</tex>-оптимальности. Выбор <tex>k</tex> и [[#lemma5|лемма <tex>5</tex>]] дают нам следующее неравенство: <tex>\varepsilon'^{*} \leqslant \varepsilon^{*} \left(1-\dfrac{1}{V} \right)^{V(\log V + 1)} \leqslant \dfrac{\varepsilon^{*}}{2V}</tex>.
:Рассмотрим цикл <tex>C</tex>, отмененный на первой итерации рассматриваемой группы. Поскольку средний вес цикла <tex>C</tex> равен <tex>-\varepsilon^{*}</tex> (см. [[#lemma3|лемму <tex>3</tex>]]), некоторое ребро <tex>uv</tex> цикла <tex>C</tex> должно иметь приведенную стоимость <tex>p_{\varphi'}(uv) \leqslant -\varepsilon^{*} \leqslant -2V\varepsilon'^{*}</tex>. Таким образом, поток на ребре <tex>uv</tex> не изменится при итерациях, происходящих после этой группы. Таким образом, по [[#theorem1|теореме]] каждая группа фиксирует поток на независимом ребре.}}

==Алгоритм поиска цикла минимального среднего веса==
===Наивный способ===
Устроим [[Вещественный двоичный поиск |двоичный поиск]].
Установим нижнюю и верхнюю границы величины среднего веса цикла <tex>l</tex> и <tex>r</tex> соответственно, вычислим серединное значение <tex>m</tex> и отнимем полученную величину <tex>m</tex> от всех ребер сети. Если теперь в нашей сети есть отрицательный цикл (этот факт можно проверить при помощи [[Алгоритм Форда-Беллмана #Нахождение отрицательного цикла|алгоритма Форда-Беллмана]]), значит существует цикл с меньшим средним весом, чем <tex>m</tex>. Тогда продолжим поиск среди значений в диапазоне от <tex>l</tex> до <tex>m</tex>, иначе {{---}} от <tex>m</tex> до <tex>r</tex>.

Тогда, если <tex>C_{max}</tex> и <tex>C_{min}</tex> {{---}} максимальная и минимальная возможные величины среднего веса цикла соответственно, такой алгоритм для вещественных значений весов ребер будет работать за <tex>O\left(\log \dfrac{C_{max}-C_{min}}{\varepsilon} \cdot EV\right)</tex>, где <tex>\varepsilon</tex> {{---}} точность выбора среднего веса цикла.
При этом для целочисленных значений на ребрах точность выбора величины среднего веса цикла не может превысить <tex>\dfrac{1}{V}</tex>, что дает нам оценку <tex>O\left(\log (V(C_{max}-C_{min})) \cdot EV\right)</tex>.

====Псевдокод====

'''func''' findMinCycleBinarySearch (l, r):
m = (l + r) / <tex>2</tex>
'''for''' e : edges
e.weight -= m
'''if''' <tex>\exists C</tex> : <tex>\mu (C) < 0</tex>
findMinCycleBinarySearch (l, m)
'''else'''
findMinCycleBinarySearch (m, r)

===Продвинутый алгоритм===
Добавим к нашему графу вершину <tex>s</tex> и ребра из нее во все остальные вершины.
Запустим [[алгоритм Форда-Беллмана]] и попросим его построить нам квадратную матрицу со следующим условием: <tex>d[i][u]</tex> {{---}} длина минимального пути от <tex>s</tex> до <tex>u</tex> ровно из <tex>i</tex> ребер.
Тогда длина оптимального цикла <tex>\mu^{*}</tex> минимального среднего веса вычисляется как <tex>\min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>.

Достаточно будет доказать это правило для <tex>\mu^{*}=0</tex>, так как для других <tex>\mu^{*}</tex> можно просто отнять эту величину от всех ребер и получить снова случай с <tex>\mu^{*}=0</tex>.

Чтобы найти цикл после построения матрицы <tex>d[k][u]</tex>, запомним, при каких <tex>u</tex> и <tex>k</tex> достигается оптимальное значение <tex>\mu^{*}</tex>, и, используя <tex>d[n][u]</tex>, поднимемся по указателям предков. Как только мы попадем в уже посещенную вершину {{---}} мы нашли цикл минимального среднего веса.

Этот алгоритм работает за <tex>O(VE)</tex> <ref>[[Алгоритм Форда-Беллмана #Сложность| Сложность алгоритма Форда-Беллмана]]</ref>.

====Псевдокод====
'''func''' findMinCycle:
'''Node''' s
'''Edge''' e
insert(s) // добавляем мнимую вершину <tex>s</tex> и проводим рёбра нулевого веса в каждую вершину графа
'''for''' u '''in''' <tex>G</tex>
e.begin = s
e.end = u
e.weight = <tex>0</tex>
fordBellman(s)
<tex>\mu^{*} = \min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>

==См. также==
* [[Использование потенциалов Джонсона при поиске потока минимальной стоимости]]
* [[Сведение задачи о назначениях к задаче о потоке минимальной стоимости]]

==Примечания==
<references/>

==Источники информации==
* [https://youtu.be/bykbw7HovSo?t=4287 Лекция 14 | Дополнительные главы алгоритмов | Андрей Станкевич | CSC | Лекториум]
* [http://sirius.cs.put.poznan.pl/~inf84789/acm/p873-goldberg.pdf A.V.Goldberg and R.E.Tarjan {{---}} Finding Minimum-Cost Circulations by Cancelling Negative Cycles (Journal of the Association for Computing Machinery. Vol. 36, No. 4. October 1989. pp. 873-886.)]
*[https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-854j-advanced-algorithms-fall-2008/lecture-notes/lec4.pdf Lecture by M.X.Goemans on Goldberg-Tarjan Min-Cost Circulation Algorithm]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о потоке минимальной стоимости]]

Алгоритм отмены цикла минимального среднего веса

2018-03-30T04:18:01Z

188.227.78.184: /* Псевдокод */

В статье описывается один из сильно полиномиальных алгоритмов решения [[Поток минимальной стоимости #Задача о потоке минимальной стоимости|задачи о поиске потока минимальной стоимости]].
==Алгоритм==
Приведенный алгоритм основан на идее [[Поток минимальной стоимости #Метод устранения отрицательных циклов в остаточной сети|алгоритма Клейна отмены цикла отрицательного веса]]. Выбор цикла минимального среднего веса вместо случайного делает алгоритм сильно полиномиальным.
{{Определение
|definition='''Сильно полиномиальными''' (англ. ''strongly polynomial'') в контексте данной задачи называются алгоритмы, чья сложность полиномиально зависит от <tex>V</tex> и <tex>E</tex>.}}
===Описание===
Обозначим как <tex>c_{f}(C)</tex> остаточную [[Определение сети, потока|пропускную способность]] цикла <tex>C</tex> при протекании в сети потока <tex>f</tex>.
Cтоимость цикла <tex>C</tex> обозначим за <tex>p(C)</tex>, а длину (число входящих в него ребер) {{---}} за <tex>\texttt{len}(C)</tex>.
{{Определение
|definition='''Средним весом''' (англ. ''mean weight'') цикла будем называть отношение его стоимости к его длине <tex>\mu (C)=\dfrac{p(C)}{\texttt{len}(C)}</tex>}}
Данный алгоритм заключается в последовательной отмене циклов минимального среднего веса в [[Дополняющая сеть, дополняющий путь|остаточной сети]] посредством их насыщения. Алгоритм работает до тех пор, пока минимальный средний вес циклов не окажется положительным, что будет означать, что поток минимальной стоимости найден.

Более формально:
* '''Шаг <tex>1</tex>'''. Рассмотрим некоторый поток <tex>f</tex>.
* '''Шаг <tex>2</tex>'''. Найдем цикл <tex>C</tex>, обладающий наименьшим средним весом. Если <tex>\mu (C) \geqslant 0</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости и алгоритм завершается.
* '''Шаг <tex>3</tex>'''. Отменим цикл <tex>C</tex>, пустив по нему максимально возможный поток: <tex>f = f + c_{f}(C)\cdot f_{C}</tex>. Перейдем к '''шагу <tex>1</tex>'''.

===Сложность===
Для сетей с целочисленными стоимостями на ребрах <tex>O(VE\cdot VE\log{CV})</tex>, с вещественными {{---}} <tex>O(VE\cdot VE^{2}\log{V})</tex>.
В обоих случаях <tex>O(VE)</tex> времени тратится на поиск цикла минимального среднего веса.

===Псевдокод===
'''func''' findMin:
'''while''' <tex>f</tex>
<tex>c</tex> = <tex>\mathrm{min} \mu(C)</tex> // <tex>\mu(C)</tex> {{---}} вес минимального цикла
'''if''' <tex>\mu (C) \geqslant 0</tex>
'''return''' <tex>f</tex> // тогда мы нашли f {{---}} поток минимальной стоимости, алгоритм завершается
'''else'''
<tex>f</tex> += <tex>c_{f}(C)\cdot f_{C}</tex> // иначе отменим цикл

===Корректность===
Пусть <tex>f</tex> {{---}} поток минимальной стоимости. Введём на нашей сети функцию [[Алгоритм Джонсона|потенциалов]] <tex>\varphi</tex>.
{{Определение
|definition='''Приведённой стоимостью''' (англ. ''reduced cost'') ребра назовем следующую величину: <tex>p_{\varphi}(uv)=\varphi(u) + p(uv) - \varphi(v)</tex>.}}
Иными словами, приведённая стоимость {{---}} это сколько нужно потратить денег, чтобы перевезти единицу жидкости из <tex>u</tex> в <tex>v</tex> (её нужно купить в <tex>u</tex>, перевезти из <tex>u</tex> в <tex>v</tex> и продать в <tex>v</tex>).

{{Лемма
|id=lemma1
|about=<tex>1</tex>
|statement=Если <tex>f</tex> {{---}} поток минимальной стоимости, то <tex>\exists \varphi</tex> такое, что <tex>\forall uv: \; c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant 0</tex>.
|proof=
:Рассмотрим остаточную сеть {{---}} граф <tex>G_{f}</tex>. В нем нет отрицательных циклов, так как <tex>f</tex> {{---}} поток минимальной стоимости<ref>[[Лемма об эквивалентности свойства потока быть минимальной стоимости и отсутствии отрицательных циклов в остаточной сети]]</ref>.

:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость минимального пути из <tex>a</tex> в <tex>u</tex>.

:Рассмотрим теперь некоторое ребро <tex>uv</tex>. Понятно, что <tex>\varphi(v) \leqslant \varphi(u) + p(uv)</tex>. (Здесь сравниваются минимальный путь <tex>a \rightsquigarrow v</tex> и путь <tex>a \rightsquigarrow u \rightarrow v</tex>). Перенеся <tex>\varphi(v)</tex> в другую часть неравенства, получаем <tex>0 \leqslant \varphi(u) + p(uv) - \varphi(v)</tex> или <tex>0 \leqslant p_{\varphi}(uv)</tex>.}}

{{Определение
|definition=Будем говорить, что поток <tex>f</tex> {{---}} '''<tex>\varepsilon</tex>-оптимальный''' (англ. ''<tex>\varepsilon</tex>-optimal''), если <tex>\exists \varphi</tex> такая, что <tex>\forall uv: c_{f}(uv) > 0 \implies p_{\varphi}(uv) \geqslant -\varepsilon</tex>.}}

{{Лемма
|id=lemma2
|about=<tex>2</tex>
|statement=Если стоимости целочисленны и поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный, где <tex>\varepsilon < \dfrac{1}{V}</tex>, то <tex>f</tex> {{---}} поток минимальной стоимости.
|proof=
:Рассмотрим цикл в остаточной сети <tex>C</tex>. Заметим, что <tex>p(C)=p_{\varphi}(C)</tex> (для доказательства этого факта достаточно расписать <tex>p_{\varphi}(C)</tex> по определению).

:Возьмем <tex>\varphi</tex> такое, что стоимости всех ребер в <tex>C</tex> не меньше <tex>-\varepsilon</tex>. Тогда стоимость всего цикла <tex>p_{\varphi}(C)\geqslant -V\cdot \varepsilon</tex> (в цикле не больше <tex>V</tex> ребер). Таким образом, <tex>p_{\varphi}(C) > -1</tex>, то есть <tex>p(C) > -1</tex>. Но исходные пропускные способности были целочисленными, поэтому <tex>p(C) \geqslant 0</tex>, а это означает, что в остаточной сети нет отрицательных циклов, и, соответственно, <tex>f</tex> {{---}} поток минимальной стоимости.}}

Обозначим за <tex>\mu^{*}</tex> минимальную величину среди средних весов циклов для потока <tex>f</tex>, а за <tex>\varepsilon^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f</tex> {{---}} <tex>\varepsilon</tex>-оптимальный.
{{Лемма
|id=lemma3
|about=<tex>3</tex>
|statement=Если <tex>f</tex> {{---}} поток не минимальной стоимости, то <tex>\varepsilon^{*}=-\mu^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса в остаточной сети.
*Покажем, что <tex>\mu^{*} \geqslant -\varepsilon^{*}</tex>.
:Поскольку поток <tex>f</tex> является <tex>\varepsilon^{*}</tex>-оптимальным, верно следующее: <tex>p(C) = p_{\varphi}(C) \geqslant -\texttt{len}(C) \cdot \varepsilon^{*}</tex> или <tex>\dfrac{p(C)}{\texttt{len}(C)} \geqslant -\varepsilon^{*} </tex>, то есть <tex>\mu(C)=\mu^{*} \geqslant -\varepsilon^{*}</tex>.

*Теперь покажем, что <tex>\mu^{*} \leqslant -\varepsilon^{*}</tex>.
:Пусть <tex>p'(uv)=p(uv)-\mu^{*}</tex> для любого <tex>uv \in E_{f}</tex>. Логичным будет также обозначить для некоторого цикла <tex>C</tex> за <tex>\mu'(C)</tex> величину <tex>\dfrac{p'(C)}{\texttt{len}(C)}</tex>. Таким образом, для любого цикла <tex>C</tex>, <tex>\mu'(C)=\mu(C)-\mu^{*}\geqslant 0</tex>.
:Далее проведем рассуждения, аналогичные доказательству [[#lemma1|леммы <tex>1</tex>]].
:Добавим вершину <tex>a</tex> и проведем из нее ребро стоимости <tex>0</tex> во все вершины графа <tex>G_{f}</tex>. В качестве <tex>\varphi(u)</tex> выберем стоимость (считая стоимостью функцию <tex>p'</tex>) минимального пути из <tex>a</tex> в <tex>u</tex>.
:Таким образом, <tex>\varphi(v) \leqslant \varphi(u) + p'(uv) = \varphi(u) + p(uv) - \mu^{*}</tex>. Отсюда получаем, что <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex> для любого ребра <tex>uv</tex> из остаточной сети <tex>E_{f}</tex>, что означает, что <tex>f</tex> {{---}} <tex>(-\mu^{*})</tex>-оптимальный, и, по определению <tex>\varepsilon^{*}</tex>, <tex>\varepsilon^{*} \leqslant -\mu^{*}</tex>.
}}

{{Лемма
|id=lemma4
|about=<tex>4</tex>
|statement=Отмена цикла минимального среднего веса не увеличивает <tex>\varepsilon^{*}</tex>.
|proof=
:Пусть <tex>C</tex> {{---}} цикл минимального среднего веса, который мы хотим отменить на текущем шаге нашего алгоритма. Перед тем, как мы отменим этот цикл, любое ребро в остаточной сети, в том числе, любое входящее в цикл <tex>C</tex> ребро <tex>uv</tex> удовлетворяет свойству <tex>\varepsilon^{*}</tex>-оптимальности: <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>.
:По [[#lemma3|лемме <tex>3</tex>]], <tex>\varepsilon^{*}=-\mu^{*}</tex>, то есть <tex>p_{\varphi}(uv) \geqslant \mu^{*}</tex>. Но поскольку <tex>\mu^{*}</tex> {{---}} средний вес цикла, то <tex>p_{\varphi}(uv) = \mu^{*} = -\varepsilon^{*}</tex>.
:По [[Поток минимальной стоимости #Свойства стоимости|свойству антисимметричности потока]], после отмены цикла <tex>C</tex>, в остаточной сети появятся ребра стоимости <tex>\varepsilon</tex>. Таким образом, свойство <tex>p_{\varphi}(uv) \geqslant -\varepsilon</tex> все еще выполняется.
}}

{{Определение
|definition='''Допустимым графом''' (англ. ''admissible graph'') будем называть такой подграф остаточной сети, что он включает только ребра отрицательной приведенной стоимости. <tex>H=\{uv \in E_{f}\;|\; p_{\varphi}(uv) < 0\}</tex>
}}

{{Лемма
|id=lemma5
|about=<tex>5</tex>
|statement=Пусть <tex>f</tex> {{---}} некоторый поток, а <tex>f'</tex> {{---}} поток после <tex>E</tex> отмен циклов минимального среднего веса. Тогда <tex>\varepsilon'^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, где <tex>\varepsilon'^{*}</tex> {{---}} минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный.
|proof=
:Изначально любое ребро <tex>uv</tex> удовлетворяет свойству <tex>p_{\varphi}(uv) \geqslant -\varepsilon^{*}</tex>. Отмена цикла добавляет в остаточную сеть <tex>G_{f}</tex> только ребра положительной приведенной стоимости (см. [[#lemma4|лемму <tex>4</tex>]]) и удаляет из сети <tex>G</tex> как минимум одно ребро. Рассмотрим два случая:
:#Ни один из отмененных циклов не содержал ребер, обладающих неотрицательной приведенной стоимостью. Тогда каждая отмена цикла уменьшает размер допустимого графа <tex>H</tex> и после <tex>E</tex> отмен граф <tex>H</tex> пуст, что означает, что <tex>f'</tex> {{---}} оптимальный поток, то есть <tex>\varepsilon'^{*}=0</tex>.
:#Некоторые из отмененных циклов содержали ребра неотрицательной приведенной стоимости. Пусть впервые такое случилось на <tex>i</tex>-ой итерации, и, соответственно, <tex>C_{i}</tex> {{---}} первый из таких циклов. Для <tex>C_{i}</tex> имеем, что каждое его ребро обладает приведенной стоимостью как минимум <tex>-\varepsilon_{i}^{*}</tex> (при этом <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} \leqslant \varepsilon^{*}</tex> по [[#lemma4|лемме <tex>4</tex>]]), хотя бы одно из ребер <tex>C_{i}</tex> обладает неотрицательной приведенной стоимостью и количество ребер в <tex>C_{i}</tex> не превышает <tex>V</tex>. Тогда средний вес этого цикла <tex>\mu(C_{i}) = \mu_{i}^{*} \geqslant -\left(1-\dfrac{1}{V}\right)\varepsilon_{i}^{*} \geqslant - \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>, и <tex>\varepsilon'^{*} \leqslant \varepsilon_{i}^{*} = -\mu_{i}^{*} \leqslant \left(1-\dfrac{1}{V}\right)\varepsilon^{*}</tex>.}}

{{Определение
|definition='''<tex>\varepsilon</tex>-фиксированным''' (англ. ''<tex>\varepsilon</tex>-fixed'') будем называть ребро, поток через которое неизменен для любых <tex>\varepsilon</tex>-оптимальных потоков в сети.}}

{{Теорема
|id=theorem1
|statement=Пусть поток <tex>f</tex> является <tex>\varepsilon</tex>-оптимальным с функцией потенциалов <tex>\varphi</tex>. Также пусть для некоторого ребра <tex>uv \; \left|p_{\varphi}(uv)\right| \geqslant 2V\varepsilon</tex>. Тогда ребро <tex>uv</tex> <tex>\varepsilon</tex>-фиксировано.
|proof=
:По свойству антисимметричности, достаточно будет доказать теорему для случая <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon</tex>.

:Рассмотрим такой поток <tex>f'</tex>, что <tex>f'(uv) \neq f(uv)</tex>. Поскольку <tex>p_{\varphi}(uv) \geqslant 2V\varepsilon > \varepsilon</tex>, поток по ребру <tex>uv</tex> должен быть как можно меньше, то есть <tex>f(uv) = -c(uv)</tex>, и тогда раз <tex>f'(uv) \neq f(uv)</tex>, то <tex>f'(uv) > f(uv)</tex>.

:Покажем теперь, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимальный.
:Обозначим за <tex>G_{>}</tex> подграф <tex>G</tex> такой, что <tex>G_{>}=(V, \{uv \in E \;|\; f'(uv) > f(uv) \})</tex>. Рассмотрим некоторое ребро <tex>uv</tex> в <tex>G_{>}</tex>. Поскольку <tex>f</tex> и <tex>f'</tex> являются циркуляциями, в <tex>G_{>}</tex> должен содержаться простой цикл <tex>C</tex>, проходящий через <tex>uv</tex>. Поскольку все ребра в <tex>C</tex> {{---}} остаточные, стоимость <tex>C</tex> не меньше <tex>p_{\varphi}(uv) - (\texttt{len}(C)-1)\varepsilon \geqslant 2V\varepsilon - (V-1)\varepsilon > V\varepsilon</tex>.
:Теперь рассмотрим цикл <tex>\overline{C}</tex>, который получен из <tex>C</tex> разворотом всех его ребер. Заметим, что <tex>\overline{C}</tex> является циклом в <tex>G_{<}=(V,\{uv \in E \;|\; f'(uv) < f(uv)\})</tex> и, соответственно, циклом в <tex>G_{f}</tex>. По свойству антисимметричности, стоимость <tex>\overline{C}</tex> меньше, чем <tex>-V\varepsilon</tex> и, таким образом, <tex>\mu(\overline{C}) < -\varepsilon</tex>. Откуда по [[#lemma3|лемме <tex>3</tex>]] имеем, что <tex>f'</tex> не <tex>\varepsilon</tex>-оптимален.
}}

{{Лемма
|about=доказательство оценки времени работы алгоритма в случае вещественных стоимостей
|statement=Пусть <tex>k=VE(\lceil \log V + 1 \rceil)</tex>. Разобьем работу алгоритма на группы по <tex>k</tex> последовательных итераций. Утверждается, что каждая группа фиксирует поток на независимом ребре <tex>uv</tex>, то есть итерации из другой группы не меняют величину <tex>f(uv)</tex>.
|proof=
:Оценка времени работы следует непосредственно из этого утверждения.
:Чтобы доказать его, рассмотрим некоторую группу итераций. Пусть <tex>f</tex> {{---}} поток до первой итерации, а <tex>f'</tex> {{---}} после последней итерации этой группы. Обозначим за <tex>\varepsilon'^{*}</tex> минимальное <tex>\varepsilon</tex> такое, что поток <tex>f'</tex> <tex>\varepsilon</tex>-оптимальный, а за <tex>\varphi'</tex> {{---}} функцию потенциалов такую, что <tex>f'</tex> удовлетворяет свойству <tex>\varepsilon'^{*}</tex>-оптимальности. Выбор <tex>k</tex> и [[#lemma5|лемма <tex>5</tex>]] дают нам следующее неравенство: <tex>\varepsilon'^{*} \leqslant \varepsilon^{*} \left(1-\dfrac{1}{V} \right)^{V(\log V + 1)} \leqslant \dfrac{\varepsilon^{*}}{2V}</tex>.
:Рассмотрим цикл <tex>C</tex>, отмененный на первой итерации рассматриваемой группы. Поскольку средний вес цикла <tex>C</tex> равен <tex>-\varepsilon^{*}</tex> (см. [[#lemma3|лемму <tex>3</tex>]]), некоторое ребро <tex>uv</tex> цикла <tex>C</tex> должно иметь приведенную стоимость <tex>p_{\varphi'}(uv) \leqslant -\varepsilon^{*} \leqslant -2V\varepsilon'^{*}</tex>. Таким образом, поток на ребре <tex>uv</tex> не изменится при итерациях, происходящих после этой группы. Таким образом, по [[#theorem1|теореме]] каждая группа фиксирует поток на независимом ребре.}}

==Алгоритм поиска цикла минимального среднего веса==
===Наивный способ===
Устроим [[Вещественный двоичный поиск |двоичный поиск]].
Установим нижнюю и верхнюю границы величины среднего веса цикла <tex>l</tex> и <tex>r</tex> соответственно, вычислим серединное значение <tex>m</tex> и отнимем полученную величину <tex>m</tex> от всех ребер сети. Если теперь в нашей сети есть отрицательный цикл (этот факт можно проверить при помощи [[Алгоритм Форда-Беллмана #Нахождение отрицательного цикла|алгоритма Форда-Беллмана]]), значит существует цикл с меньшим средним весом, чем <tex>m</tex>. Тогда продолжим поиск среди значений в диапазоне от <tex>l</tex> до <tex>m</tex>, иначе {{---}} от <tex>m</tex> до <tex>r</tex>.

Тогда, если <tex>C_{max}</tex> и <tex>C_{min}</tex> {{---}} максимальная и минимальная возможные величины среднего веса цикла соответственно, такой алгоритм для вещественных значений весов ребер будет работать за <tex>O\left(\log \dfrac{C_{max}-C_{min}}{\varepsilon} \cdot EV\right)</tex>, где <tex>\varepsilon</tex> {{---}} точность выбора среднего веса цикла.
При этом для целочисленных значений на ребрах точность выбора величины среднего веса цикла не может превысить <tex>\dfrac{1}{V}</tex>, что дает нам оценку <tex>O\left(\log (V(C_{max}-C_{min})) \cdot EV\right)</tex>.

====Псевдокод====

'''func''' findMinCycleBinarySearch (l, r):
m = (l + r) / <tex>2</tex>
'''for''' e : edges
e.weight -= m
'''if''' <tex>\exists C</tex> : <tex>\mu (C) < 0</tex>
findMinCycleBinarySearch (l, m)
'''else'''
findMinCycleBinarySearch (m, r)

===Продвинутый алгоритм===
Добавим к нашему графу вершину <tex>s</tex> и ребра из нее во все остальные вершины.
Запустим [[алгоритм Форда-Беллмана]] и попросим его построить нам квадратную матрицу со следующим условием: <tex>d[i][u]</tex> {{---}} длина минимального пути от <tex>s</tex> до <tex>u</tex> ровно из <tex>i</tex> ребер.
Тогда длина оптимального цикла <tex>\mu^{*}</tex> минимального среднего веса вычисляется как <tex>\min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>.

Достаточно будет доказать это правило для <tex>\mu^{*}=0</tex>, так как для других <tex>\mu^{*}</tex> можно просто отнять эту величину от всех ребер и получить снова случай с <tex>\mu^{*}=0</tex>.

Чтобы найти цикл после построения матрицы <tex>d[k][u]</tex>, запомним, при каких <tex>u</tex> и <tex>k</tex> достигается оптимальное значение <tex>\mu^{*}</tex>, и, используя <tex>d[n][u]</tex>, поднимемся по указателям предков. Как только мы попадем в уже посещенную вершину {{---}} мы нашли цикл минимального среднего веса.

Этот алгоритм работает за <tex>O(VE)</tex> <ref>[[Алгоритм Форда-Беллмана #Сложность| Сложность алгоритма Форда-Беллмана]]</ref>.

====Псевдокод====
'''func''' findMinCycle:
'''Node''' s
'''Edge''' e
insert(s) // добавляем мнимую вершину <tex>s</tex> и проводим рёбра нулевого веса в каждую вершину графа
'''for''' u '''in''' <tex>G</tex>
e.begin = s
e.end = u
e.weight = <tex>0</tex>
fordBellman(s)
<tex>\mu^{*} = \min\limits_{u} {\max\limits_{k} {\dfrac{d[n][u]-d[k][u]}{n-k}}}</tex>

==См. также==
* [[Использование потенциалов Джонсона при поиске потока минимальной стоимости]]
* [[Сведение задачи о назначениях к задаче о потоке минимальной стоимости]]

==Примечания==
<references/>

==Источники информации==
* [https://youtu.be/bykbw7HovSo?t=4287 Лекция 14 | Дополнительные главы алгоритмов | Андрей Станкевич | CSC | Лекториум]
* [http://sirius.cs.put.poznan.pl/~inf84789/acm/p873-goldberg.pdf A.V.Goldberg and R.E.Tarjan {{---}} Finding Minimum-Cost Circulations by Cancelling Negative Cycles (Journal of the Association for Computing Machinery. Vol. 36, No. 4. October 1989. pp. 873-886.)]
*[https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-854j-advanced-algorithms-fall-2008/lecture-notes/lec4.pdf Lecture by M.X.Goemans on Goldberg-Tarjan Min-Cost Circulation Algorithm]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о потоке минимальной стоимости]]

Список заданий по ДМ 2к 2018 весна

2018-03-22T17:16:22Z

188.227.78.184: грамм. ошибки

# Формальный степенной ряд $\exp(s) = e^s$ определен как $e^s=1+\frac{1}{1!}s+\frac{1}{2!}s^2+\frac{1}{3!}s^3+\ldots+\frac{1}{n!}s^n+\ldots$. Логично, что $e^{-s}=1-\frac{1}{1!}s+\frac{1}{2!}s^2-\frac{1}{3!}s^3+\ldots+(-1)^n\frac{1}{n!}s^n+\ldots$. Докажите, используя определение умножения для степенных рядов, что $e^se^{-s}=1$.
# Формальный степенной ряд $(1+s)^\alpha$ определен как $(1+s)^\alpha=1+\frac{\alpha}{1}s+\frac{\alpha(\alpha-1)}{1 \cdot 2}s^2+\ldots+\frac{\alpha(\alpha-1)\ldots(\alpha-n+1)}{1 \cdot 2 \cdot\ldots\cdot n}s^n+\ldots$. Докажите, что $(1+s)^\alpha(1+s)^\beta=(1+s)^{\alpha+\beta}$.
# Формальный степенной ряд $\ln\left(\frac{1}{1-s}\right)$ определен как $\ln\left(\frac{1}{1-s}\right)=s+\frac{1}{2}s^2+\frac{1}{3}s^3+\ldots+\frac{1}{n}s^n+\ldots$. Докажите, что $\exp\left(\ln\left(\frac{1}{1-s}\right)\right)=(1-s)^{-1}$.
# Пусть $B(s) = b_1s+b_2s^2+b_3s^3+\ldots+b_ns^n+\ldots$, причем $b_1\ne 0$. Пусть формальные степенные ряды $A(s)$ и $C(s)$ таковы, что $A(B(s)) = s$, $B(C(s))=s$. Докажите, что $A(s)=C(s)$ Этот ряд называется обратным к $B(s)$, обозначается как $B^{-1}(s)$.
# Будем называть нулем степенной ряд $0(s) = 0 + 0s + 0s^2 + \ldots$. Докажите, что $A(s) \ne 0(s)$, $B(s) \ne 0(s)$, то $A(s)B(s) \ne 0(s)$.
# Докажите, что $(A(s)B(s))' = A'(s)B(s) + A(s)B'(s)$.
# Докажите, что $\int(A'(s)B(s) + A(s)B'(s)) = A(s)B(s) - A(0)B(0)$.
# Найдите производящую функцию для последовательности $0 \cdot 1, 1 \cdot 2, 2 \cdot 3, 3 \cdot 4, \ldots, (n - 1) \cdot n, \ldots$.
# Найдите производящую функцию для последовательности $1^2, 2^2, 3^2, \ldots, n^2, \ldots$.
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0 + a_1, a_1 + a_2, \ldots, a_k+a_{k+1}$
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0, a_0 + a_1, a_0 + a_1 + a_2, \ldots, \sum\limits_{i=0}^ka_i,\ldots$
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0, a_1b, a_2b^2, \ldots, a_kb^k, \ldots$
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0, 0, a_1, 0, a_2, 0, a_3 \ldots$
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0, a_2, a_4, a_6 \ldots$
# Пользуясь производящей функцией для чисел Фибоначчи, докажите утверждение, что $f_0+f_1+\ldots+f_n=f_{n+2}-1$.
# Пользуясь производящей функцией для чисел Фибоначчи, докажите утверждение, что $f_0+f_2+\ldots+f_{2n}=f_{2n+1}$.
# Найдите производящую функцию для замощений прямоугольника $2\times n$ доминошками и единичными клетками.
# Найдите производящую функцию для замощений прямоугольника $2\times n$ уголками (квадратами $2\times 2$ с вырезанной одной клеткой) и единичными клетками.
# Пользуясь производящей функцией для чисел Фибоначчи, докажите утверждение, что $f_1+f_3+\ldots+f_{2n-1}=f_{2n}-1$.
# Пользуясь производящей функцией для чисел Фибоначчи, докажите утверждение, что $f_0^2+f_1^2+f_2^2+\ldots+f_n^2=f_nf_{n+1}$.
# Найдите производящую функцию для чисел "трибоначчи" $f_0=f_1=f_2=1$, $f_n = f_{n-1}+f_{n-2}+f_{n-3}$.
# Найдите производящую функцию для последовательности, заданной рекуррентностью $f_0=f_1=f_2=1$, $f_n = f_{n-1}-2f_{n-3}$.
# Производящая функция называется рациональной, если она представима в виде отношения двух многочленов. Для производящих функций каждой из следующих последовательностей выясните, является ли она рациональной, если да, приведите ее представление в таком виде. Последовательность $1, -2, 3, -4, 5, \ldots$.
# Последовательность $2, -6, 12, \ldots, (-1)^k(k+1)(k+2),\ldots$
# Последовательность $0, 1, 4, 9, 16, 25, \ldots, k^2,\ldots$
# Последовательность $0, 1, 8, 27, 64, 125, \ldots, k^3,\ldots$
# Последовательность $0, 1, 2^s, 3^s, 4^s, 5^s, \ldots, k^s,\ldots$
# Последовательность $1, -4, 9, -16, \ldots, (-1)^k(k+1)^2,\ldots$
# Последовательность $1, 1, 4, 9, 25, \ldots, F_k^2,\ldots$
# Найдите производящую функцию для чисел Каталана.
# Путь Моцкина - путь, начинающийся в точке $(0, 0)$, составленный из векторов $(1, 1)$, $(1, 0)$, $(1, -1)$, не опускающийся ниже оси $OX$ и заканчивающийся в точке $(n, 0)$. Напишите рекуррентное соотношение для числа путей Моцкина, найдите производящую функцию для числа таких путей.
# Рассмотрим множество путей на прямой, начинающихся в 0, состоящих из шагов длины 1 вправо или влево. Будем называть такой путь блужданием. Найдите рекуррентную формулу и производящую функцию для числа блужданий из $n$ шагов, оканчивающихся в 0.
# Найдите рекуррентную формулу и производящую функцию для числа блужданий из $n$ шагов, оканчивающихся в 0 и не заходящих в отрицательную полупрямую.
# Найдите рекуррентную формулу и производящую функцию для числа блужданий из $n$ шагов, оканчивающихся в фиксированной точке $N > 0$.
# Найдите рекуррентную формулу и производящую функцию для числа блужданий из $n$ шагов, оканчивающихся в фиксированной точке $N > 0$ и не заходящих в отрицательную полупрямую.
# Найдите производящую функцию для последовательности, заданной рекуррентным соотношением $a_0 = 2$, $a_n = a_{n-1}^2$.
# Найдите производящую функцию для последовательности, заданной рекуррентным соотношением $a_0 = 2$, $a_n = a_{n-1}^3$.
# Найдите производящую функцию для последовательности, заданной рекуррентным соотношением $a_0=a_1= 2$, $a_n = a_{n-1}\cdot a_{n - 2}$.
# Последовательность задана рекуррентным соотношением $a_0=a_1=1$, $a_n = 5a_{n-1}-6a_{n-2}$. Оцените асимптотическое поведение $a_n$ при $n\to+\infty$.
# Последовательность задана рекуррентным соотношением $a_0=a_1=1$, $a_n = 6a_{n-2}-a_{n-1}$. Оцените асимптотическое поведение $a_n$ при $n\to+\infty$.
# Последовательность задана рекуррентным соотношением $a_0=a_1=1$, $a_n = 4a_{n-1}-4a_{n-2}$. Оцените асимптотическое поведение $a_n$ при $n\to+\infty$.
# Петя заинтересовался, что будет, если последовательность, заданная линейным рекуррентным соотношением, имеет производящую фукнцию, в знаменателе которой стоит $Q(t)=(1-ct)(1+ct)$, ведь тогда асимптотическое поведение членов на четных и нечетных позициях разное. Разберитесь.
# Последовательность задана рекуррентным соотношением $a_0=a_1=1$, $a_n = 2a_{n-1}-2a_{n-2}$. Оцените асимптотическое поведение $a_n$ при $n\to+\infty$.
# Докажите, что если последовательность $a_n$ допускает представление в виде $a_n = \sum_i p_i(n)q_i^n$, где $p_i(n)$ - полиномы, и все $q_i$ различны, то такое представление единственно с точностью до порядка слагаемых.
# Используя результат из предыдушего задания, докажите, что формальный степенной ряд $\ln\left(\frac{1}{1-s}\right)=s+\frac{1}{2}s^2+\frac{1}{3}s^3+\ldots+\frac{1}{n}s^n+\ldots$ не представим в виде отношения двух полиномов.
# Произведением Адамара двух производящих функций $A(t)$ и $B(t)$ называется призводящая функция для ряда $C(t) = a_0b_0+a_1b_1t+a_2b_2t^2+\ldots+a_nb_nt^n+\ldots$. Докажите, что если $A(t)$ и $B(t)$ являются отношениями двух полиномов, то таким же свойством обладает и $C(t)$.
# Найдите произведение Адамара $\frac{1}{1-x}$ и $\frac{1}{1-2x}$.
# Найдите произведение Адамара $\frac{1}{1-2x}$ и $\frac{1}{1-3x}$.
# Найдите произведение Адамара $\frac{1}{1+3x-x^2}$ и $\frac{1}{1-2x}$.
# Найдите произведение Адамара $\frac{1}{1-2x-x^2}$ и $\frac{1}{1-2x}$.
# Пусть $A$ - семейство комбинаторных объектов. Пусть $M = MSet(A)$, а $P = Set(A)$. Докажите, что $M(t) = P(t)M(t^2)$.
# Пусть $A$ - семейство комбинаторных объектов с производящей функцией $A(t)$. Обозначим как $Seq^k(A)$ множество последовательностей длины $k$, каждый элемент которого является последовательностью из $k$ объектов. Найдите производящую функцию для $Seq^k(A)$.
# Пусть $A$ - семейство комбинаторных объектов с производящей функцией $A(t)$. Обозначим как $Seq^{\le k}(A)$ множество последовательностей длины $k$, каждый элемент которого является последовательностью из не более чем $k$ объектов. Найдите производящую функцию для $Seq^{\le k}(A)$.
# Пусть $A$ - семейство комбинаторных объектов с производящей функцией $A(t)$. Обозначим как $Seq^{\ge k}(A)$ множество последовательностей длины $k$, каждый элемент которого является последовательностью из не менее чем $k$ объектов. Найдите производящую функцию для $Seq^{\ge k}(A)$.
# Пусть $A$ - семейство комбинаторных объектов с производящей функцией $A(t)$. Пусть $\mathbb{N}$ - множество натуральных чисел, (вес числа $k$ равен $k$). Пусть $T \subset \mathbb{N}$, обозначим как $T(t)$ производящую функцию для множества $T$. Обозначим как $Seq_T(A)$ множество последовательностей элементов из $A$, где длина последовательности лежит в множестве $T$. Обозначим как $Z$ множество из одного элемента веса $1$. Обозначим как $C^T$ множество представлений в виде суммы, где порядок слагаемых важен и слагаемые выбраны из множества $T$. Осознайте, что $C^T = Seq(Seq_T(Z))$. Найдите производяющую функцию для $C^T$.
# Обозначим как $P^T$ множество разбиений на слагаемые, где порядок слагаемых не важен, а слагаемые выбраны из множества $T$. Осознайте, что $P^T = MSet(Seq_T(Z))$. Найдите производяющую функцию для $P^T$.
# Индекс Хирша. Докажите, что $\prod\limits_{n=1}^\infty\frac{1}{1-z^n}=\sum\limits_{n\ge 0}\frac{z^{n^2}}{((1-z)\cdots(1-z^n))^2}$.
# Докажите, что $\frac{1}{1-z}=\prod\limits_{j=0}^\infty(1+z^{2^j})$.
# Найдите производящую функцию для слов над $m$-буквенным алфавитом (вес каждой буквы равен 1, слова равен его длине).
# Обозначим как $W$ множество слов над алфавитом $\{a, b\}$. Осознайте, что $W=Seq\{a\}\times Seq(\{b\}\times Seq\{a\})$. Проверьте равенство для производящих функций.
# Обозначим как $W^{(k)}$ множество слов над алфавитом $\{a, b\}$, не содержащих $k$ букв $a$ подряд. Запишите $W^{(k)}$ через $Seq_T$ и $\times$. Найдите производящую функцию для $W^{(k)}$.
# Обобщите задание 60 на произвольный алфавит.
# Обобщите задание 61 на произвольный алфавит.
# Неявное задание КО. Пусть $A$, $B$ и $X$ - семейства комбинаторных объектов, причем $B \cap X = \varnothing$, $A = B \cup X$. Пусть производящие функции для $A$ и $B$ - $A(t)$ и $B(t)$, соответственно. Найдите производящую функцию $X(t)$.
# Неявное задание КО 2. Пусть $A$, $B$ и $X$ - семейства комбинаторных объектов, причем $A = B \times X$. Пусть производящие функции для $A$ и $B$ - $A(t)$ и $B(t)$, соответственно. Найдите производящую функцию $X(t)$.
# Неявное задание КО 3. Пусть $A$ и $X$ - семейства комбинаторных объектов, причем $A = Seq(X)$. Пусть производящая функция для $A$ - $A(t)$. Найдите производящую функцию $X(t)$.
# Неявное задание КО 4. Пусть $A$ и $X$ - семейства комбинаторных объектов, причем $A = MSet(X)$. Пусть производящая функция для $A$ - $A(t)$. Найдите производящую функцию $X(t)$.
# Экспоненциальная производящая функция для целочисленной последовательности называется функцией Гурвица. Докажите, что сумма, произведение, интеграл и производная функции Гурвица является функцией Гурвица.
# Докажите, что результат подстановки функции Гурвица в функцию Гурвица является функцией Гурвица
# Опишите класс помеченных объектов $seq(cyc(Z))$. Найдите его экспоненциальную производящую функцию.
# Будем обозначать $seq_T$, $cyc_T$, $set_T$ соответственно последовательности, циклы и множества, размер которых принадлежит множеству $T$. Опишите класс помеченных объектов $set(cyc_{\ge 1}(Z))$. Найдите его экспоненциальную производящую функцию.
# Опишите класс помеченных объектов $set(cyc_{1, 2}(Z))$. Найдите его экспоненциальную производящую функцию.
# Сюрьекции на $r$-элементное множество. Осознайте, что $seq_{=r}(set_{\ge 1}(Z))$ задаёт сюрьекции на $r$-элементное множество. Найдите экспоненциальную производящую функцию.
# Разбиения на $r$ множеств. Осознайте, что $set_{=r}(set_{\ge 1}(Z))$ задаёт разбиения на $r$-элементное множество. Найдите экспоненциальную производящую функцию. Что стоит при $z^n$?
# Гиперболический синус $\mathrm{sh}\,z$ равен $\frac{1}{2}(e^{z}-e^{-z})$. Гиперболический косинус $\mathrm{ch}\,z$ равен $\frac{1}{2}(e^{z}+e^{-z})$. Рассмотрим разбиения $n$-элементного множества на непустые подмножества. Для произвольных подмножеств экспоненциальная производящая функция равна $e^{e^z-1}$. Докажите, что для разбиений на нечетное число подмножеств экспоненциальная производящая функция равна $\mathrm{sh}(e^z-1)$.
# Докажите, что для разбиений на четное число подмножеств экспоненциальная производящая функция равна $\mathrm{ch}(e^z-1)$.
# Докажите, что для разбиений на произвольное число подмножеств, каждое из которых содержит нечетное число элементов, экспоненциальная производящая функция равна $e^{\mathrm{sh}\,z}$.
# Докажите, что для разбиений на произвольное число подмножеств, каждое из которых содержит четное число элементов, экспоненциальная производящая функция равна $e^{\mathrm{ch}\,z-1}$. Почему здесь в показателе степени есть $-1$, а в предыдущем задании нет?
# Обобщите четыре предыдущих задания. Как выглядят экспоненциальные производящие функции для разбиений на (не)четное число подмножеств, каждое из которых содержит (не)четное число элементов? (Необходимо дать четыре ответа для всех комбинаций)

Список заданий по ДМ 2к 2018 весна

2018-03-14T19:21:52Z

188.227.78.184:

# Формальный степенной ряд $\exp(s) = e^s$ определен как $e^s=1+\frac{1}{1!}s+\frac{1}{2!}s^2+\frac{1}{3!}s^3+\ldots+\frac{1}{n!}s^n+\ldots$. Логично, что $e^{-s}=1-\frac{1}{1!}s+\frac{1}{2!}s^2-\frac{1}{3!}s^3+\ldots+(-1)^n\frac{1}{n!}s^n+\ldots$. Докажите, используя определение умножения для степенных рядов, что $e^se^{-s}=1$.
# Формальный степенной ряд $(1+s)^\alpha$ определен как $(1+s)^\alpha=1+\frac{\alpha}{1}s+\frac{\alpha(\alpha-1)}{1 \cdot 2}s^2+\ldots+\frac{\alpha(\alpha-1)\ldots(\alpha-n+1)}{1 \cdot 2 \cdot\ldots\cdot n}s^n+\ldots$. Докажите, что $(1+s)^\alpha(1+s)^\beta=(1+s)^{\alpha+\beta}$.
# Формальный степенной ряд $\ln\left(\frac{1}{1-s}\right)$ определен как $\ln\left(\frac{1}{1-s}\right)=s+\frac{1}{2}s^2+\frac{1}{3}s^3+\ldots+\frac{1}{n}s^n+\ldots$. Докажите, что $\exp\left(\ln\left(\frac{1}{1-s}\right)\right)=(1-s)^{-1}$.
# Пусть $B(s) = b_1s+b_2s^2+b_3s^3+\ldots+b_ns^n+\ldots$, причем $b_1\ne 0$. Пусть формальные степенные ряды $A(s)$ и $C(s)$ таковы, что $A(B(s)) = s$, $B(C(s))=s$. Докажите, что $A(s)=C(s)$ Этот ряд называется обратным к $B(s)$, обозначается как $B^{-1}(s)$.
# Будем называть нулем степенной ряд $0(s) = 0 + 0s + 0s^2 + \ldots$. Докажите, что $A(s) \ne 0(s)$, $B(s) \ne 0(s)$, то $A(s)B(s) \ne 0(s)$.
# Докажите, что $(A(s)B(s))' = A'(s)B(s) + A(s)B'(s)$.
# Докажите, что $\int(A'(s)B(s) + A(s)B'(s)) = A(s)B(s) - A(0)B(0)$.
# Найдите производящую функцию для последовательности $0 \cdot 1, 1 \cdot 2, 2 \cdot 3, 3 \cdot 4, \ldots, (n - 1) \cdot n, \ldots$.
# Найдите производящую функцию для последовательности $1^2, 2^2, 3^2, \ldots, n^2, \ldots$.
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0 + a_1, a_1 + a_2, \ldots, a_k+a_{k+1}$
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0, a_0 + a_1, a_0 + a_1 + a_2, \ldots, \sum\limits_{i=0}^ka_i,\ldots$
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0, a_1b, a_2b^2, \ldots, a_kb^k, \ldots$
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0, 0, a_1, 0, a_2, 0, a_3 \ldots$
# Последовательность $a_0, a_1, a_2, \ldots, a_k, \ldots$ имеет производящую функцию $A(s)=a_0+a_1s+a_2s^2+\ldots$. Найдите производящую функцию последовательности $a_0, a_2, a_4, a_6 \ldots$
# Пользуясь производящей функцией для чисел Фибоначчи, докажите утверждение, что $f_0+f_1+\ldots+f_n=f_{n+2}-1$.
# Пользуясь производящей функцией для чисел Фибоначчи, докажите утверждение, что $f_0+f_2+\ldots+f_{2n}=f_{2n+1}$.
# Найдите производящую функцию для замощений прямоугольника $2\times n$ доминошками и единичными клетками.
# Найдите производящую функцию для замощений прямоугольника $2\times n$ уголками (квадратами $2\times 2$ с вырезанной одной клеткой) и единичными клетками.
# Пользуясь производящей функцией для чисел Фибоначчи, докажите утверждение, что $f_1+f_3+\ldots+f_{2n-1}=f_{2n}-1$.
# Пользуясь производящей функцией для чисел Фибоначчи, докажите утверждение, что $f_0^2+f_1^2+f_2^2+\ldots+f_n^2=f_nf_{n+1}$.
# Найдите производящую функцию для чисел "трибоначчи" $f_0=f_1=f_2=1$, $f_n = f_{n-1}+f_{n-2}+f_{n-3}$.
# Найдите производящую функцию для последовательности, заданной рекуррентностью $f_0=f_1=f_2=1$, $f_n = f_{n-1}-2f_{n-3}$.
# Производящая функция называется рациональной, если она представима в виде отношения двух многочленов. Для производящих функций каждой из следующих последовательностей выясните, является ли она рациональной, если да, приведите ее представление в таком виде. Последовательность $1, -2, 3, -4, 5, \ldots$.
# Последовательность $2, -6, 12, \ldots, (-1)^k(k+1)(k+2),\ldots$
# Последовательность $0, 1, 4, 9, 16, 25, \ldots, k^2,\ldots$
# Последовательность $0, 1, 8, 27, 64, 125, \ldots, k^3,\ldots$
# Последовательность $0, 1, 2^s, 3^s, 4^s, 5^s, \ldots, k^s,\ldots$
# Последовательность $1, -4, 9, -16, \ldots, (-1)^k(k+1)^2,\ldots$
# Последовательность $1, 1, 4, 9, 25, \ldots, F_k^2,\ldots$
# Найдите производящую функцию для чисел Каталана.
# Путь Моцкина - путь, начинающийся в точке $(0, 0)$, составленный из векторов $(1, 1)$, $(1, 0)$, $(1, -1)$, не опускающийся ниже оси $OX$ и заканчивающийся в точке $(n, 0)$. Напишите рекуррентное соотношение для числа путей Моцкина, найдите производящую функцию для числа таких путей.
# Рассмотрим множество путей на прямой, начинающихся в 0, состоящих из шагов длины 1 вправо или влево. Будем называть такой путь блужданием. Найдите рекуррентную формулу и производящую функцию для числа блужданий из $n$ шагов, оканчивающихся в 0.
# Найдите рекуррентную формулу и производящую функцию для числа блужданий из $n$ шагов, оканчивающихся в 0 и не заходящих в отрицательную полупрямую.
# Найдите рекуррентную формулу и производящую функцию для числа блужданий из $n$ шагов, оканчивающихся в фиксированной точке $N > 0$.
# Найдите рекуррентную формулу и производящую функцию для числа блужданий из $n$ шагов, оканчивающихся в фиксированной точке $N > 0$ и не заходящих в отрицательную полупрямую.
# Найдите производящую функцию для последовательности, заданной рекуррентным соотношением $a_0 = 2$, $a_n = a_{n-1}^2$.
# Найдите производящую функцию для последовательности, заданной рекуррентным соотношением $a_0 = 2$, $a_n = a_{n-1}^3$.
# Найдите производящую функцию для последовательности, заданной рекуррентным соотношением $a_0=a_1= 2$, $a_n = a_{n-1}\cdot a_{n - 2}$.
# Последовательность задана рекуррентным соотношением $a_0=a_1=1$, $a_n = 5a_{n-1}-6a_{n-2}$. Оцените асимптотическое поведение $a_n$ при $n\to+\infty$.
# Последовательность задана рекуррентным соотношением $a_0=a_1=1$, $a_n = 6a_{n-2}-a_{n-1}$. Оцените асимптотическое поведение $a_n$ при $n\to+\infty$.
# Последовательность задана рекуррентным соотношением $a_0=a_1=1$, $a_n = 4a_{n-1}-4a_{n-2}$. Оцените асимптотическое поведение $a_n$ при $n\to+\infty$.
# Петя заинтересовался, что будет, если последовательность, заданная линейным рекуррентным соотношением, имеет производящую фукнцию, в знаменателе которой стоит $Q(t)=(1-ct)(1+ct)$, ведь тогда асимптотическое поведение членов на четных и нечетных позициях разное. Разберитесь.
# Последовательность задана рекуррентным соотношением $a_0=a_1=1$, $a_n = 2a_{n-1}-2a_{n-2}$. Оцените асимптотическое поведение $a_n$ при $n\to+\infty$.
# Докажите, что если последовательность $a_n$ допускает представление в виде $a_n = \sum_i p_i(n)q_i^n$, где $p_i(n)$ - полиномы, и все $q_i$ различны, то такое представление единственно с точностью до порядка слагаемых.
# Используя результат из предыдушего задания, докажите, что формальный степенной ряд $\ln\left(\frac{1}{1-s}\right)=s+\frac{1}{2}s^2+\frac{1}{3}s^3+\ldots+\frac{1}{n}s^n+\ldots$ не представим в виде отношения двух полиномов.
# Произведением Адамара двух производящих функций $A(t)$ и $B(t)$ называется призводящая функция для ряда $C(t) = a_0b_0+a_1b_1t+a_2b_2t^2+\ldots+a_nb_nt^n+\ldots$. Докажите, что если $A(t)$ и $B(t)$ являются отношениями двух полиномов, то таким же свойством обладает и $C(t)$.
# Найдите произведение Адамара $\frac{1}{1-x}$ и $\frac{1}{1-2x}$.
# Найдите произведение Адамара $\frac{1}{1-2x}$ и $\frac{1}{1-3x}$.
# Найдите произведение Адамара $\frac{1}{1+3x-x^2}$ и $\frac{1}{1-2x}$.
# Найдите произведение Адамара $\frac{1}{1-2x-x^2}$ и $\frac{1}{1-2x}$.
# Пусть $A$ - семейство комбинаторных объектов. Пусть $M = MSet(A)$, а $P = Set(A)$. Докажите, что $M(t) = P(t)M(t^2)$.
# Пусть $A$ - семейство комбинаторных объектов с производящей функцией $A(t)$. Обозначим как $Seq^k(A)$ множество последовательностей длины $k$, каждый элемент которого является последовательностью из $k$ объектов. Найдите производящую функцию для $Seq^k(A)$.
# Пусть $A$ - семейство комбинаторных объектов с производящей функцией $A(t)$. Обозначим как $Seq^{\le k}(A)$ множество последовательностей длины $k$, каждый элемент которого является последовательностью из не более чем $k$ объектов. Найдите производящую функцию для $Seq^{\le k}(A)$.
# Пусть $A$ - семейство комбинаторных объектов с производящей функцией $A(t)$. Обозначим как $Seq^{\ge k}(A)$ множество последовательностей длины $k$, каждый элемент которого является последовательностью из не менее чем $k$ объектов. Найдите производящую функцию для $Seq^{\ge k}(A)$.
# Пусть $A$ - семейство комбинаторных объектов с производящей функцией $A(t)$. Пусть $\mathbb{N}$ - множество натуральных чисел, (вес числа $k$ равен $k$). Пусть $T \subset \mathbb{N}$, обозначим как $T(t)$ производящую функцию для множества $T$. Обозначим как $Seq_T(A)$ множество последовательностей элементов из $A$, где длина последовательности лежит в множестве $T$. Обозначим как $Z$ множество из одного элемента веса $1$. Обозначим как $C^T$ множество представлений в виде суммы, где порядок слагаемых важен и слагаемые выбраны из множества $T$. Осознайте, что $C^T = Seq(Seq_T(Z))$. Найдите производяющую функцию для $C^T$.
# Обозначим как $P^T$ множество разбиений на слагаемые, где порядок слагаемых не важен, а слагаемые выбраны из множества $T$. Осознайте, что $P^T = MSet(Seq_T(Z))$. Найдите производяющую функцию для $P^T$.
# Индекс Хирша. Докажите, что $\prod\limits_{n=1}^\infty\frac{1}{1-z^n}=\sum\limits_{n\ge 0}\frac{z^{n^2}}{((1-z)\cdots(1-z^n))^2}$.
# Докажите, что $\frac{1}{1-z}=\prod\limits_{j=0}^\infty(1+z^{2^j})$.
# Найдите производящую функцию для слов над $m$-буквенным алфавитом (вес каждой буквы равен 1, слова равен его длине).
# Обозначим как $W$ множество слов над алфавитом $\{a, b\}$. Осознайте, что $W=Seq\{a\}\times Seq(\{b\}\times Seq\{a\})$. Проверьте равенство для производящих функций.
# Обозначим как $W^{(k)}$ множество слов над алфавитом $\{a, b\}$, не содержащих $k$ букв $a$ подряд. Запишите $W^(k)$ через $Seq_T$ и $\times$. Найдите производящую функцию для $W^{(k)}$.
# Обобщите задание 60 на произвольный алфавит.
# Обобщите задание 61 на произвольный алфавит.
# Неявное задание. Пусть $A$, $B$ и $X$ - семейства комбинаторных объектов, причем $B \cap X = \varnothing$, $A = B \cup X$. Пусть производящие функции для $A$ и $B$ - $A(t)$ и $B(t)$, соответственно. Найдите производящую функцию $X(t)$.
# Неявное задание 2. Пусть $A$, $B$ и $X$ - семейства комбинаторных объектов, причем $A = B \times X$. Пусть производящие функции для $A$ и $B$ - $A(t)$ и $B(t)$, соответственно. Найдите производящую функцию $X(t)$.
# Неявное задание 3. Пусть $A$ и $X$ - семейства комбинаторных объектов, причем $A = Seq(X)$. Пусть производящая функция для $A$ - $A(t)$. Найдите производящую функцию $X(t)$.
# Неявное задание 4. Пусть $A$ и $X$ - семейства комбинаторных объектов, причем $A = MSet(X)$. Пусть производящая функция для $A$ - $A(t)$. Найдите производящую функцию $X(t)$.

Произведение Адамара рациональных производящих функций

2018-03-01T15:21:33Z

188.227.78.184: /* Рациональность произведения Адамара */

Одно из наиболее привлекательных свойств рациональных [[Производящая функция|производящих функций]] {{---}} их замкнутость относительно произведения Адамара.
{{Определение
|definition = '''Произведением Адамара''' (англ. ''Hadamard product'') производящих функций <tex>A(s) = a_0 + a_1 s + a_2 s^2 + \dots</tex> и <tex>B(s) = b_0 + b_1 s + b_2 s^2 + \dots</tex> называется производящая функция <tex>A(s) \circ B(s) = (a_0 b_0) + (a_1 b_1) s + (a_2 b_2) s^2 + \dots</tex>.
}}
Таким образом, произведение Адамара двух последовательностей {{---}} это последовательность, состоящая из почленных произведений соответственных членов этих последовательностей. Необходимость в производящей функции для произведения Адамара уже встречалась: в [[Задача о счастливых билетах|задаче о числе счастливых билетов]] нам понадобилось вычислить сумму квадратов коэффициентов производящего многочлена <tex>A_3</tex>. Эта необходимость возникает при перечислении пар объектов одинакового порядка: если число объектов первого типа равно <tex>a_n</tex>, а число объектов второго типа <tex>b_n</tex> то число пар объектов, составленных из элементов первого и второго типа, равно <tex>a_n b_n</tex>.

==Рациональность произведения Адамара==

{{Лемма
|statement=Производящая функция для последовательности <tex>a_0, a_1,
a_2, \dots</tex> рациональна тогда и только тогда, когда существуют такие числа <tex>q_1, \dots, q_l</tex> и такие многочлены <tex>p_1(n),
\dots, p_l(n)</tex>, что начиная с некоторого номера <tex>n</tex>
<tex>a_n = p_1(n) q_1^n + \dots + p_l(n) q_l^n.</tex>
Выражение в правой части равенства называется '''квазимногочленом''' (англ. ''quasypolynomial'') от переменной <tex>n</tex>.
|proof=

<tex>\Rightarrow</tex>

Заметим прежде всего, что производящая функция <tex>(1 - q s)^{-k}</tex> имеет вид

<tex>(1 - q s)^{-k} = 1 - \begin{pmatrix} -k \\ 1 \end{pmatrix} q s + \begin{pmatrix} -k \\ 2 \end{pmatrix} q^{2} s^{2} - \begin{pmatrix} -k \\ 3 \end{pmatrix} q^{3} s^{3} + \dots = </tex>
:::<tex> = 1+ \begin{pmatrix} k \\ 1 \end{pmatrix} q s + \begin{pmatrix} k+1 \\ 2 \end{pmatrix} q^{2} s^{2} + \begin{pmatrix} k+2 \\ 3 \end{pmatrix} q^{3} s^{3} + \dots =</tex>
:::<tex> = 1 + \begin{pmatrix} k \\ k-1 \end{pmatrix} q s + \begin{pmatrix} k+1 \\ k-1 \end{pmatrix} q^{2} s^{2} + \begin{pmatrix} k+2 \\ k-1 \end{pmatrix}q^{3} s^{3} + \dots</tex>

Коэффициент при <tex>s^n</tex> в этой производящей функции равен

<tex>\dfrac{(n + 1)(n + 2)\dots(n + k - 1)}{(k - 1)!} q^{n} = P_{k - 1}(n) q^{n}</tex>,

где <tex>P_{k - 1}(n)</tex> {{---}} многочлен от <tex>n</tex> степени <tex>k - 1</tex>. Всякая рациональная функция от переменной <tex>s</tex> представляется в виде линейной комбинации многочлена и элементарных дробей вида <tex>(1 - q_i s)^{-k_i}</tex>, поэтому коэффициенты соответствующей производящей функции являются квазимногочленами.

<tex>\Leftarrow</tex>

Наоборот, предположим, что коэффициенты производящей функции, начиная с некоторого номера, представляются в виде квазимногочлена. Покажем, что в случае квазимногочлена <tex>p(n) q^{n}</tex> соответствующая производящая функция рациональна. Пусть степень многочлена <tex>p</tex> равна <tex>k - 1</tex>. Многочлены <tex>P_0, P_1, \dots, P_{k - 1}</tex>, определенные равенством <tex>\dfrac{(n + 1)(n + 2)\dots(n + k - 1)}{(k - 1)!} q^{n} = P_{k - 1}(n) q^{n}</tex>, образуют базис в пространстве многочленов степени не выше <tex> k - 1</tex>. Действительно, любая последовательность многочленов степеней <tex>0, 1, \dots, k - 1</tex> образует базис в этом пространстве. Поэтому многочлен <tex>p</tex> представляется в виде линейной комбинации многочленов <tex>P_i</tex> и соответствующая производящая функция есть просто линейная комбинация функций <tex>(1 - q s)^{-j}</tex>, <tex>j = 0, 1, \dots, k - 1</tex>.
Для произвольного квазимногочлена мы получаем линейную комбинацию функций такого вида при разных <tex>q_i</tex>.}}

{{Теорема
|statement= Предположим, что производящие функции для последовательностей <tex>a_0, a_1, a_2, \dots</tex> и <tex>b_0, b_1, b_2, \dots</tex>

<tex>A(s) = a_0 + a_1 s + a_2 s^2 + \dots</tex> и <tex>B(s) = b_0 + b_1 s + b_2 s^2 + \dots</tex>

являются рациональными. Значит производящая функция для их произведения Адамара

<tex>A(s) \circ B(s) = (a_0 b_0) + (a_1 b_1) s + (a_2 b_2) s^2 + \dots</tex>.

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

|proof= Для доказательства теоремы осталось заменить, что произведение квазимногочленов является квазимногочленом. Это утверждение непосредственно вытекает из формулы <tex>a_n = p_1(n) q_1^n + \dots + p_l(n) q_l^n.</tex>}}

== См. также ==
* [[Производящая функция]]
* [[Задача о счастливых билетах]]

==Источники информации==
* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 26с. ISBN 978-5-94057-042-4
* [[wikipedia:en:Generating function transformation | Wikipedia {{---}} Generating function transformation]]

[[Категория: Дискретная математика и алгоритмы]]

Задача о счастливых билетах

2018-03-01T15:13:43Z

188.227.78.184: /* Способ с конечной суммой */

Троллейбусный (трамвайный) билет имеет номер, состоящий из шести цифр. Билет считается счастливым, если сумма первых трёх цифр равна сумме последних трёх, например, <tex>024321</tex>. Известно, что количество счастливых билетов из шести цифр равно <tex>55252</tex>.
{{Задача
|definition = Для натурального <tex>n</tex> найти количество <tex>2n</tex>-значных счастливых билетов <tex>L_n</tex>.
}}
__TOC__
== Общие идеи ==
Обозначим количество <tex>n</tex>-значных чисел с суммой <tex>k</tex> как <tex>D_n^k</tex> (число может содержать ведущие нули). <tex>2n</tex>-значный счастливый билет состоит из двух частей: левой (<tex>n</tex> цифр) и правой (тоже <tex>n</tex> цифр), причём в обеих частях сумма цифр одинакова. Зафиксируем <tex>x</tex> {{---}} <tex>n</tex>-значное число с суммой <tex>k</tex> в левой части (всего таких чисел <tex>D_n^k</tex>, значит это можно сделать <tex>D_n^k</tex> способами). Для него будет существовать <tex>D_n^k</tex> возможных вариантов числа в правой части, следовательно количество счастливых билетов с суммой <tex>k</tex> в одной из частей равно <tex>(D_n^k)^2</tex>. Значит общее число билетов равно <tex>L_n = \sum\limits_{k=0}^{9n} (D_{n}^{k})^2</tex>. Верхний индекс суммирования равен <tex>9n</tex>, так как максимальная сумма цифр в одной части билета равна <tex>9n</tex>. Также можно сопоставить счастливому билету <tex>a_1a_2\ldots a_n b_1b_2 \ldots b_n</tex> <tex>2n</tex>-значное число с суммой <tex>9n</tex>: <tex>a_1a_2\ldots a_n (9-b_1)(9-b_2) \ldots (9-b_n)</tex>, причем это соответствие взаимно-однозначно, значит множества счастливых билетов и <tex>2n</tex>-значных чисел с суммой <tex>9n</tex> равномощны, поэтому <tex>L_n=D_{2n}^{9n}</tex>.
== Метод динамического программирования ==
Научимся вычислять <tex>D_n^k</tex>. Положим <tex>D_0^k=\begin{cases}1,&k=0\\0,&k>0\end{cases}</tex>. При <tex>n>0</tex> количество <tex>n</tex>-значных чисел с суммой цифр <tex>k</tex> можно выразить через количество <tex>(n-1)</tex>-значных чисел, добавляя к ним <tex>n</tex>-ю цифру, которая может быть равна <tex>0, 1, \ldots, 9</tex>: <tex>D_n^k=\sum\limits_{j=0}^{9}D_{n-1}^{k-j}</tex>. Ответ {{---}} в <tex>D_{2n}^{9n}</tex>, алгоритм будет работать за <tex>O(n^2)</tex>.

== Метод производящей функции ==
Выпишем производящую функцию <tex>G(z)</tex>, коэффициент при <tex>z^k</tex> у которой будет равен <tex>D_1^k</tex>:
<tex>
G(z) = 1+z+z^2+z^3+z^4+z^5+z^6+z^7+z^8+z^9.</tex>
Действительно, однозначное число с суммой цифр <tex>k</tex> (для <tex>k=0,\ldots,9</tex>) можно представить одним способом. Для <tex>k>9</tex> — ноль способов. Заметим, что <tex>G^n(z)</tex> — производящая функция для чисел <tex>D_n^k</tex>, поскольку коэффициент при <tex>z^k</tex> получается перебором всех возможных комбинаций из <tex>n</tex> цифр, равных в сумме <tex>k</tex>. Ответом на задачу будет <tex>[z^{9n}]G^{2n}(z)</tex>. Перепишем производящую функцию в ином виде: <tex>
G(z) = 1+z+\ldots+z^9 = \dfrac{1-z^{10}}{1-z}
</tex> и получим, что <tex dpi="140">G^{2n}(z)=(1-z^{10})^{2n}(1-z)^{-2n}=\sum\limits_{k=0}^{2n}\binom{2n}{k}(-z^{10})^k\sum\limits_{j=0}^{\infty}\binom{-2n}{j}(-z)^j</tex>. Так как <tex dpi="140">\binom{-2n}{k}=(-1)^k\binom{2n+k-1}{k}</tex>, понятно, что <tex dpi="140">[z^{9n}]G^{2n}(z)=\sum\limits_{j=0}^{\lfloor{\frac{9n}{10}}\rfloor}(-1)^j\binom{2n}{j}\binom{11n-10j-1}{9n-10j}</tex>, что при <tex>n=3</tex> дает <tex dpi="140">\binom{6}{0}\binom{32}{27}-\binom{6}{1}\binom{22}{17}+\binom{6}{2}\binom{12}{7}=55252</tex>.

== Решение с помощью [[Формула включения-исключения | формулы включения-исключения]]==
Как мы заметили раньше, ответ на задачу равен количеству шестизначных билетов с суммой <tex>27</tex>. Рассмотрим расстановки целых неотрицательных чисел на шести позициях, дающих в сумме <tex>27</tex>; обозначим их множество <tex>A</tex>. Выделим шесть его подмножеств <tex>C_i, i = 1 \ldots 6</tex>, где <tex>i</tex>-е множество состоит из расстановок, у которых в <tex>i</tex>-й позиции стоит число, не меньшее <tex>10</tex>. Число счастливых билетов равно числу расстановок, не принадлежащих ни одному из множеств. Расстановке <tex>(a_1,a_2 \ldots a_n)</tex> из <tex>n</tex> чисел с суммой <tex>k</tex> сопоставим сочетание с повторениями <ref>[https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D0%B5#.D0.A1.D0.BE.D1.87.D0.B5.D1.82.D0.B0.D0.BD.D0.B8.D1.8F_.D1.81_.D0.BF.D0.BE.D0.B2.D1.82.D0.BE.D1.80.D0.B5.D0.BD.D0.B8.D1.8F.D0.BC.D0.B8 Сочетание — Википедия]</ref> из <tex>n</tex> по <tex>k</tex>, в котором <tex>i</tex>-й элемент повторяется <tex>a_i</tex> раз. Так как это сопоставление взаимно-однозначно, количество расстановок равно количеству сочетаний с повторениями, т.е. <tex dpi="140">\binom{n+k-1}{n-1}</tex>. Число <tex>\left\vert{A}\right\vert</tex> всех расстановок неотрицательных целых чисел с суммой <tex>27</tex> в шесть позиций равно <tex dpi="140">\binom{32}{5}</tex>. Число расстановок <tex>\left\vert{C_i}\right\vert</tex> одинаково для всех <tex>i</tex> и равно <tex dpi="140">\binom{22}{5}</tex>. В самом деле, мы можем поставить в <tex>i</tex>-ю позицию число <tex>10</tex>, а оставшуюся сумму <tex>17</tex> произвольно распределить по шести позициям. Аналогично, число расстановок <tex>\left\vert{C_i \cap C_j}\right\vert</tex> одинаково для любой пары <tex>i, j, i \neq j</tex> и равно <tex dpi="140">\binom{12}{5}</tex>: мы выбираем две позиции и ставим в них <tex>10</tex> и произвольно распределяем оставшуюся сумму <tex>7</tex> по шести позициям. Таким образом, искомое количество расстановок равно <tex dpi="140">\left\vert{A}\right\vert - \binom{6}{1}\left\vert{C_i}\right\vert+\binom{6}{2}\left\vert{C_i \cap C_j}\right\vert = \binom{32}{5}-6\binom{22}{5}+15\binom{12}{5} = 55252</tex>.

== Решение путем интегрирования ==
Рассмотрим многочлен Лорана (т.е. многочлен, в котором допускаются отрицательные степени) <tex>H(z)=G^3(z)G^3(1/z)</tex>. Заметим, что его свободный член равен <tex>\sum\limits_{i=0}^{27}[z^i]G^3(z)\cdot [z^{-i}]G^3(z^{-1})=\sum\limits_{i=0}^{27}(D_3^i)^2</tex>. Воспользуемся теоремой Коши <ref>[https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%9A%D0%BE%D1%88%D0%B8 Интегральная формула Коши — Википедия]
</ref> из комплексного анализа:
{{Теорема
|id=th1
|author=Коши
|statement=Для любого многочлена Лорана <tex>p(z)</tex> его свободный член <tex>p_0</tex> равен
: <tex>p_0=\dfrac{1}{2\pi i}{\displaystyle \int} \dfrac{p(z)}{z} dz</tex>, где интегрирование происходит по любой окружности, ориентированной против часовой стрелки и содержащей внутри себя начало координат.
}}
Упростим многочлен <tex>H(z)</tex>:
: <tex>H(z)=\left( \dfrac{1-z^{10}}{1-z} \right) ^3\left(\dfrac{1-z^{-10}}{1-z^{-1}}\right)^3=\left(\dfrac{2-z^{10}-z^{-10}}{2-z-z^{-1}}\right)^3</tex> и применим замену <tex>z=e^{i\phi}</tex>:
: <tex>p_0=\dfrac{1}{2\pi}\displaystyle\int\limits_0^{2\pi}\left(\dfrac{2-e^{10i\phi}-e^{-10i\phi}}{2-e^{i\phi}-e^{-i\phi}}\right)^3d\phi=\dfrac{1}{2\pi}\displaystyle\int\limits_0^{2\pi}\left(\dfrac{2-2\cos(10\phi)}{2-2cos\phi}\right)^3d\phi=\dfrac{1}{2\pi}\displaystyle\int\limits_{0}^{2\pi}\left(\dfrac{\sin^2(5\phi)}{\sin^2(\frac{\phi}{2})}\right)^3d\phi=\dfrac{1}{\pi}\displaystyle\int\limits_0^{\pi}\left(\dfrac{\sin(10\phi)}{\sin\phi}\right)^6d\phi=\dfrac{1}{\pi}\displaystyle\int\limits_{-\pi/2}^{\pi/2}\left(\dfrac{\sin(10\phi)}{\sin\phi}\right)^6d\phi</tex>

Рассмотрим функцию <tex>f(\phi)=\dfrac{\sin(10\phi)}{\sin\phi}</tex> на <tex>\left[-\dfrac{\pi}{2},\dfrac{\pi}{2}\right]</tex>. Вне отрезка <tex>\left[\dfrac{-\pi}{10},\dfrac{\pi}{10}\right]
f(\phi) \leqslant \dfrac{1}{\sin\frac{\pi}{10}}\approx 3</tex>, значит интеграл по этой части не больше <tex>3^6\pi \approx 2300</tex>, основная часть сосредоточена на <tex>\left[-\dfrac{\pi}{10},\dfrac{\pi}{10}\right]</tex>. Оценим интеграл по этому промежутку с помощью метода стационарной фазы. <ref>[https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%81%D1%82%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D1%80%D0%BD%D0%BE%D0%B9_%D1%84%D0%B0%D0%B7%D1%8B Метод стационарной фазы — Википедия]</ref> Этот метод позволяет оценить значение интеграла
: <tex>\displaystyle\int\limits_{-\pi/10}^{\pi/10}f^td\phi=\displaystyle\int\limits_{-\pi/10}^{\pi/10}e^{t\ln{f}}d\phi</tex>. При <tex>t \rightarrow \infty</tex> значение интеграла определяется поведением его фазы, т.е. <tex>\ln{f}</tex>, в окрестности стационарной точки <tex>0</tex> (точки, где <tex>(\ln{f})'=0</tex>, или, что то же самое, <tex>f'=0</tex>). Вблизи <tex>0</tex> <tex>f(\phi) \approx 10 \left(1 - \dfrac{33}{2}\phi^2\right)</tex>, а <tex>\ln{f}(\phi) \approx \ln 10 - \dfrac{33}{2}\phi^2</tex>. При больших <tex>t </tex> получим
: <tex>{\displaystyle\int\limits_{-\pi/10}^{\pi/10}\exp(t(\ln 10 - \frac{33}{2}\phi^2))d\phi=10^t \int\limits_{-\pi/10}^{\pi/10}\exp(-\frac{33}{2}\phi^2)d\phi=\sqrt{\dfrac{\pi}{66t}} \cdot \mathrm{erf}\left(\sqrt{\dfrac{33t}{2}\phi}\right)\bigg\rvert_{-\pi/10}^{\pi/10}}</tex>, где <tex>\mathrm{erf}(z)</tex> {{---}} функция ошибок <ref>[http://mathworld.wolfram.com/Erf.html Erf -- from Wolfram MathWorld]</ref>. Заметим, что при <tex>z > 2 </tex> <tex>\mathrm{erf}(z) \approx 1</tex>, поэтому интеграл примерно равен <tex>10^t \sqrt{\dfrac{2\pi}{33t}}</tex>.
Полагая <tex>t=6</tex> и вспоминая выражение для <tex>p_0</tex>, получаем приближенное равенство:
: <tex>p_0 \approx \dfrac{10^6}{3\sqrt{11\pi}} \approx 56700</tex>
Этот результат с хорошей точностью (отклонение составляет не более <tex>3\%</tex>) приближает искомое значение.

== Способ с конечной суммой ==
Рассмотрим функцию <tex>g(\phi)=H(e^{i\phi})=\left(\dfrac{\sin{5\phi}}{\sin{\frac{\pi}{2}}}\right)^6</tex>. Как доказано выше, <tex>L_6=\dfrac{1}{2\pi}\displaystyle\int\limits_0^{2\pi}g(\phi)d\phi</tex>. Для интеграла можно выписать приближенную формулу и получить <tex>L_6 \approx \dfrac{1}{N}\sum\limits_{k=0}^{N-1}g(\dfrac{2\pi k}{N})</tex>. Интересно, что при достаточно большом <tex>N</tex> это равенство становится точным.
{{Утверждение
|statement=При <tex>N \geqslant 28</tex> и любом <tex>\phi_0</tex> <tex>L_6 = \dfrac{1}{N}\sum\limits_{k=0}^{N-1}g(\phi_k)</tex>, где <tex>\phi_k=\phi_0+\dfrac{2\pi k}{N}, k > 0</tex>.
|proof=По определению, <tex>g(\phi)=\sum\limits_{j=-27}^{27}a_je^{ij\phi}</tex>, где <tex>a_j</tex> {{---}} коэффициенты многочлена <tex>H(z)</tex>. Обозначим
<tex>r(\phi)=\sum\limits_{j=1}^{27}a_j(e^{ij\phi}+e^{-ij\phi}), g(\phi)=a_0+r(\phi)</tex>. Докажем, что
<tex>\sum\limits_{k=0}^{N-1}g(\phi_k)=0</tex>. Раскроем <tex>g(\phi_k)</tex>:
: <tex>{\displaystyle\sum\limits_{k=0}^{N-1}\sum\limits_{j=1}^{27}a_j\left(\exp\left(ij\left(\phi_0+\dfrac{2\pi k}{N}\right)\right) + \exp\left(-ij\left(\phi_0+\dfrac{2\pi k}{N}\right)\right)\right)= e^{ij\phi_0}\sum\limits_{j=1}^{27}a_j\sum\limits_{k=0}^{N-1}\left(\exp\left(ij\dfrac{2\pi k}{N}\right) + \exp\left(-ij\dfrac{2\pi k}{N}\right)\right)}</tex>.
Рассмотрим внутреннюю сумму:
: <tex>{\displaystyle\sum\limits_{k=0}^{N-1}\left(\exp\left(\dfrac{2ijk\pi}{N}\right)+\exp\left(-\dfrac{2ijk\pi}{N}\right)\right)=\sum\limits_{k=0}^{N-1}\exp\left(\dfrac{2ijk\pi}{N}\right)+\sum\limits_{k=0}^{N-1}\exp\left(-\dfrac{2ijk\pi}{N}\right)}</tex>. Получили две геометрические прогрессии со знаменателями, не равными <tex>1</tex>: <tex>N>j \implies \exp\left(\dfrac{2ij\pi}{N}\right)\neq 1, \exp\left(-\dfrac{2ij\pi}{N}\right)\neq 1</tex>. Значит искомая сумма равна
: <tex>\dfrac{1-\exp\left(2ij\pi\right)}{1-\exp\left(\dfrac{2ij\pi}{N}\right)}+\dfrac{1-\exp\left(-2ij\pi\right)}{1-\exp\left(-\dfrac{2ij\pi}{N}\right)}=0</tex>, так как <tex>e^{2\pi i}=1</tex>.
Таким образом,
<tex>\dfrac{1}{N}\sum\limits_{k=0}^{N-1}g\left(\phi_k\right)=\dfrac{1}{N}\sum\limits_{k=0}^{N-1}\left(a_0+g\left(\phi_k\right)\right)=a_0</tex>,
а свободный член <tex>H\left(z\right)</tex> равен <tex>L_6</tex>, как известно из предыдущего раздела.
}}

== См. также ==
* [[Производящая функция]]

* [[Динамическое программирование]]

== Примечания ==
<references />
== Источники информации ==
* [http://www.genfunc.ru/theory/lucky/ Задача о счастливых билетах :: Производящие функции]

* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 144с. ISBN 978-5-94057-042-4
[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Комбинаторика]]
[[Категория:Производящие функции]]

Задача о счастливых билетах

2018-03-01T15:10:52Z

188.227.78.184: /* Решение путем интегрирования */

Троллейбусный (трамвайный) билет имеет номер, состоящий из шести цифр. Билет считается счастливым, если сумма первых трёх цифр равна сумме последних трёх, например, <tex>024321</tex>. Известно, что количество счастливых билетов из шести цифр равно <tex>55252</tex>.
{{Задача
|definition = Для натурального <tex>n</tex> найти количество <tex>2n</tex>-значных счастливых билетов <tex>L_n</tex>.
}}
__TOC__
== Общие идеи ==
Обозначим количество <tex>n</tex>-значных чисел с суммой <tex>k</tex> как <tex>D_n^k</tex> (число может содержать ведущие нули). <tex>2n</tex>-значный счастливый билет состоит из двух частей: левой (<tex>n</tex> цифр) и правой (тоже <tex>n</tex> цифр), причём в обеих частях сумма цифр одинакова. Зафиксируем <tex>x</tex> {{---}} <tex>n</tex>-значное число с суммой <tex>k</tex> в левой части (всего таких чисел <tex>D_n^k</tex>, значит это можно сделать <tex>D_n^k</tex> способами). Для него будет существовать <tex>D_n^k</tex> возможных вариантов числа в правой части, следовательно количество счастливых билетов с суммой <tex>k</tex> в одной из частей равно <tex>(D_n^k)^2</tex>. Значит общее число билетов равно <tex>L_n = \sum\limits_{k=0}^{9n} (D_{n}^{k})^2</tex>. Верхний индекс суммирования равен <tex>9n</tex>, так как максимальная сумма цифр в одной части билета равна <tex>9n</tex>. Также можно сопоставить счастливому билету <tex>a_1a_2\ldots a_n b_1b_2 \ldots b_n</tex> <tex>2n</tex>-значное число с суммой <tex>9n</tex>: <tex>a_1a_2\ldots a_n (9-b_1)(9-b_2) \ldots (9-b_n)</tex>, причем это соответствие взаимно-однозначно, значит множества счастливых билетов и <tex>2n</tex>-значных чисел с суммой <tex>9n</tex> равномощны, поэтому <tex>L_n=D_{2n}^{9n}</tex>.
== Метод динамического программирования ==
Научимся вычислять <tex>D_n^k</tex>. Положим <tex>D_0^k=\begin{cases}1,&k=0\\0,&k>0\end{cases}</tex>. При <tex>n>0</tex> количество <tex>n</tex>-значных чисел с суммой цифр <tex>k</tex> можно выразить через количество <tex>(n-1)</tex>-значных чисел, добавляя к ним <tex>n</tex>-ю цифру, которая может быть равна <tex>0, 1, \ldots, 9</tex>: <tex>D_n^k=\sum\limits_{j=0}^{9}D_{n-1}^{k-j}</tex>. Ответ {{---}} в <tex>D_{2n}^{9n}</tex>, алгоритм будет работать за <tex>O(n^2)</tex>.

== Метод производящей функции ==
Выпишем производящую функцию <tex>G(z)</tex>, коэффициент при <tex>z^k</tex> у которой будет равен <tex>D_1^k</tex>:
<tex>
G(z) = 1+z+z^2+z^3+z^4+z^5+z^6+z^7+z^8+z^9.</tex>
Действительно, однозначное число с суммой цифр <tex>k</tex> (для <tex>k=0,\ldots,9</tex>) можно представить одним способом. Для <tex>k>9</tex> — ноль способов. Заметим, что <tex>G^n(z)</tex> — производящая функция для чисел <tex>D_n^k</tex>, поскольку коэффициент при <tex>z^k</tex> получается перебором всех возможных комбинаций из <tex>n</tex> цифр, равных в сумме <tex>k</tex>. Ответом на задачу будет <tex>[z^{9n}]G^{2n}(z)</tex>. Перепишем производящую функцию в ином виде: <tex>
G(z) = 1+z+\ldots+z^9 = \dfrac{1-z^{10}}{1-z}
</tex> и получим, что <tex dpi="140">G^{2n}(z)=(1-z^{10})^{2n}(1-z)^{-2n}=\sum\limits_{k=0}^{2n}\binom{2n}{k}(-z^{10})^k\sum\limits_{j=0}^{\infty}\binom{-2n}{j}(-z)^j</tex>. Так как <tex dpi="140">\binom{-2n}{k}=(-1)^k\binom{2n+k-1}{k}</tex>, понятно, что <tex dpi="140">[z^{9n}]G^{2n}(z)=\sum\limits_{j=0}^{\lfloor{\frac{9n}{10}}\rfloor}(-1)^j\binom{2n}{j}\binom{11n-10j-1}{9n-10j}</tex>, что при <tex>n=3</tex> дает <tex dpi="140">\binom{6}{0}\binom{32}{27}-\binom{6}{1}\binom{22}{17}+\binom{6}{2}\binom{12}{7}=55252</tex>.

== Решение с помощью [[Формула включения-исключения | формулы включения-исключения]]==
Как мы заметили раньше, ответ на задачу равен количеству шестизначных билетов с суммой <tex>27</tex>. Рассмотрим расстановки целых неотрицательных чисел на шести позициях, дающих в сумме <tex>27</tex>; обозначим их множество <tex>A</tex>. Выделим шесть его подмножеств <tex>C_i, i = 1 \ldots 6</tex>, где <tex>i</tex>-е множество состоит из расстановок, у которых в <tex>i</tex>-й позиции стоит число, не меньшее <tex>10</tex>. Число счастливых билетов равно числу расстановок, не принадлежащих ни одному из множеств. Расстановке <tex>(a_1,a_2 \ldots a_n)</tex> из <tex>n</tex> чисел с суммой <tex>k</tex> сопоставим сочетание с повторениями <ref>[https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%87%D0%B5%D1%82%D0%B0%D0%BD%D0%B8%D0%B5#.D0.A1.D0.BE.D1.87.D0.B5.D1.82.D0.B0.D0.BD.D0.B8.D1.8F_.D1.81_.D0.BF.D0.BE.D0.B2.D1.82.D0.BE.D1.80.D0.B5.D0.BD.D0.B8.D1.8F.D0.BC.D0.B8 Сочетание — Википедия]</ref> из <tex>n</tex> по <tex>k</tex>, в котором <tex>i</tex>-й элемент повторяется <tex>a_i</tex> раз. Так как это сопоставление взаимно-однозначно, количество расстановок равно количеству сочетаний с повторениями, т.е. <tex dpi="140">\binom{n+k-1}{n-1}</tex>. Число <tex>\left\vert{A}\right\vert</tex> всех расстановок неотрицательных целых чисел с суммой <tex>27</tex> в шесть позиций равно <tex dpi="140">\binom{32}{5}</tex>. Число расстановок <tex>\left\vert{C_i}\right\vert</tex> одинаково для всех <tex>i</tex> и равно <tex dpi="140">\binom{22}{5}</tex>. В самом деле, мы можем поставить в <tex>i</tex>-ю позицию число <tex>10</tex>, а оставшуюся сумму <tex>17</tex> произвольно распределить по шести позициям. Аналогично, число расстановок <tex>\left\vert{C_i \cap C_j}\right\vert</tex> одинаково для любой пары <tex>i, j, i \neq j</tex> и равно <tex dpi="140">\binom{12}{5}</tex>: мы выбираем две позиции и ставим в них <tex>10</tex> и произвольно распределяем оставшуюся сумму <tex>7</tex> по шести позициям. Таким образом, искомое количество расстановок равно <tex dpi="140">\left\vert{A}\right\vert - \binom{6}{1}\left\vert{C_i}\right\vert+\binom{6}{2}\left\vert{C_i \cap C_j}\right\vert = \binom{32}{5}-6\binom{22}{5}+15\binom{12}{5} = 55252</tex>.

== Решение путем интегрирования ==
Рассмотрим многочлен Лорана (т.е. многочлен, в котором допускаются отрицательные степени) <tex>H(z)=G^3(z)G^3(1/z)</tex>. Заметим, что его свободный член равен <tex>\sum\limits_{i=0}^{27}[z^i]G^3(z)\cdot [z^{-i}]G^3(z^{-1})=\sum\limits_{i=0}^{27}(D_3^i)^2</tex>. Воспользуемся теоремой Коши <ref>[https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%9A%D0%BE%D1%88%D0%B8 Интегральная формула Коши — Википедия]
</ref> из комплексного анализа:
{{Теорема
|id=th1
|author=Коши
|statement=Для любого многочлена Лорана <tex>p(z)</tex> его свободный член <tex>p_0</tex> равен
: <tex>p_0=\dfrac{1}{2\pi i}{\displaystyle \int} \dfrac{p(z)}{z} dz</tex>, где интегрирование происходит по любой окружности, ориентированной против часовой стрелки и содержащей внутри себя начало координат.
}}
Упростим многочлен <tex>H(z)</tex>:
: <tex>H(z)=\left( \dfrac{1-z^{10}}{1-z} \right) ^3\left(\dfrac{1-z^{-10}}{1-z^{-1}}\right)^3=\left(\dfrac{2-z^{10}-z^{-10}}{2-z-z^{-1}}\right)^3</tex> и применим замену <tex>z=e^{i\phi}</tex>:
: <tex>p_0=\dfrac{1}{2\pi}\displaystyle\int\limits_0^{2\pi}\left(\dfrac{2-e^{10i\phi}-e^{-10i\phi}}{2-e^{i\phi}-e^{-i\phi}}\right)^3d\phi=\dfrac{1}{2\pi}\displaystyle\int\limits_0^{2\pi}\left(\dfrac{2-2\cos(10\phi)}{2-2cos\phi}\right)^3d\phi=\dfrac{1}{2\pi}\displaystyle\int\limits_{0}^{2\pi}\left(\dfrac{\sin^2(5\phi)}{\sin^2(\frac{\phi}{2})}\right)^3d\phi=\dfrac{1}{\pi}\displaystyle\int\limits_0^{\pi}\left(\dfrac{\sin(10\phi)}{\sin\phi}\right)^6d\phi=\dfrac{1}{\pi}\displaystyle\int\limits_{-\pi/2}^{\pi/2}\left(\dfrac{\sin(10\phi)}{\sin\phi}\right)^6d\phi</tex>

Рассмотрим функцию <tex>f(\phi)=\dfrac{\sin(10\phi)}{\sin\phi}</tex> на <tex>\left[-\dfrac{\pi}{2},\dfrac{\pi}{2}\right]</tex>. Вне отрезка <tex>\left[\dfrac{-\pi}{10},\dfrac{\pi}{10}\right]
f(\phi) \leqslant \dfrac{1}{\sin\frac{\pi}{10}}\approx 3</tex>, значит интеграл по этой части не больше <tex>3^6\pi \approx 2300</tex>, основная часть сосредоточена на <tex>\left[-\dfrac{\pi}{10},\dfrac{\pi}{10}\right]</tex>. Оценим интеграл по этому промежутку с помощью метода стационарной фазы. <ref>[https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%81%D1%82%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D1%80%D0%BD%D0%BE%D0%B9_%D1%84%D0%B0%D0%B7%D1%8B Метод стационарной фазы — Википедия]</ref> Этот метод позволяет оценить значение интеграла
: <tex>\displaystyle\int\limits_{-\pi/10}^{\pi/10}f^td\phi=\displaystyle\int\limits_{-\pi/10}^{\pi/10}e^{t\ln{f}}d\phi</tex>. При <tex>t \rightarrow \infty</tex> значение интеграла определяется поведением его фазы, т.е. <tex>\ln{f}</tex>, в окрестности стационарной точки <tex>0</tex> (точки, где <tex>(\ln{f})'=0</tex>, или, что то же самое, <tex>f'=0</tex>). Вблизи <tex>0</tex> <tex>f(\phi) \approx 10 \left(1 - \dfrac{33}{2}\phi^2\right)</tex>, а <tex>\ln{f}(\phi) \approx \ln 10 - \dfrac{33}{2}\phi^2</tex>. При больших <tex>t </tex> получим
: <tex>{\displaystyle\int\limits_{-\pi/10}^{\pi/10}\exp(t(\ln 10 - \frac{33}{2}\phi^2))d\phi=10^t \int\limits_{-\pi/10}^{\pi/10}\exp(-\frac{33}{2}\phi^2)d\phi=\sqrt{\dfrac{\pi}{66t}} \cdot \mathrm{erf}\left(\sqrt{\dfrac{33t}{2}\phi}\right)\bigg\rvert_{-\pi/10}^{\pi/10}}</tex>, где <tex>\mathrm{erf}(z)</tex> {{---}} функция ошибок <ref>[http://mathworld.wolfram.com/Erf.html Erf -- from Wolfram MathWorld]</ref>. Заметим, что при <tex>z > 2 </tex> <tex>\mathrm{erf}(z) \approx 1</tex>, поэтому интеграл примерно равен <tex>10^t \sqrt{\dfrac{2\pi}{33t}}</tex>.
Полагая <tex>t=6</tex> и вспоминая выражение для <tex>p_0</tex>, получаем приближенное равенство:
: <tex>p_0 \approx \dfrac{10^6}{3\sqrt{11\pi}} \approx 56700</tex>
Этот результат с хорошей точностью (отклонение составляет не более <tex>3\%</tex>) приближает искомое значение.

== Способ с конечной суммой ==
Рассмотрим функцию <tex>g(\phi)=H(e^{i\phi})=\left(\dfrac{\sin{5\phi}}{\sin{\frac{\pi}{2}}}\right)^6</tex>. Как доказано выше, <tex>L_6=\dfrac{1}{2\pi}\displaystyle\int_0^{2\pi}g(\phi)d\phi</tex>. Для интеграла можно выписать приближенную формулу и получить <tex>L_6 \approx \dfrac{1}{N}\sum\limits_{k=0}^{N-1}g(\dfrac{2\pi k}{N})</tex>. Интересно, что при достаточно большом <tex>N</tex> это равенство становится точным.
{{Утверждение
|statement=При <tex>N \geqslant 28</tex> и любом <tex>\phi_0</tex> <tex>L_6 = \dfrac{1}{N}\sum\limits_{k=0}^{N-1}g(\phi_k)</tex>, где <tex>\phi_k=\phi_0+\dfrac{2\pi k}{N}, k > 0</tex>.
|proof=По определению, <tex>g(\phi)=\sum\limits_{j=-27}^{27}a_je^{ij\phi}</tex>, где <tex>a_j</tex> {{---}} коэффициенты многочлена <tex>H(z)</tex>. Обозначим
<tex>r(\phi)=\sum\limits_{j=1}^{27}a_j(e^{ij\phi}+e^{-ij\phi}), g(\phi)=a_0+r(\phi)</tex>. Докажем, что
<tex>\sum\limits_{k=0}^{N-1}g(\phi_k)=0</tex>. Раскроем <tex>g(\phi_k)</tex>:
: <tex>{\displaystyle\sum\limits_{k=0}^{N-1}\sum\limits_{j=1}^{27}a_j\left(\exp\left(ij\left(\phi_0+\dfrac{2\pi k}{N}\right)\right) + \exp\left(-ij\left(\phi_0+\dfrac{2\pi k}{N}\right)\right)\right)= e^{ij\phi_0}\sum\limits_{j=1}^{27}a_j\sum\limits_{k=0}^{N-1}\left(\exp\left(ij\dfrac{2\pi k}{N}\right) + \exp\left(-ij\dfrac{2\pi k}{N}\right)\right)}</tex>.
Рассмотрим внутреннюю сумму:
: <tex>{\displaystyle\sum\limits_{k=0}^{N-1}\left(\exp\left(\dfrac{2ijk\pi}{N}\right)+\exp\left(-\dfrac{2ijk\pi}{N}\right)\right)=\sum\limits_{k=0}^{N-1}\exp\left(\dfrac{2ijk\pi}{N}\right)+\sum\limits_{k=0}^{N-1}\exp\left(-\dfrac{2ijk\pi}{N}\right)}</tex>. Получили две геометрические прогрессии со знаменателями, не равными <tex>1</tex>: <tex>N>j \implies \exp\left(\dfrac{2ij\pi}{N}\right)\neq 1, \exp\left(-\dfrac{2ij\pi}{N}\right)\neq 1</tex>. Значит искомая сумма равна
: <tex>\dfrac{1-\exp\left(2ij\pi\right)}{1-\exp\left(\dfrac{2ij\pi}{N}\right)}+\dfrac{1-\exp\left(-2ij\pi\right)}{1-\exp\left(-\dfrac{2ij\pi}{N}\right)}=0</tex>, так как <tex>e^{2\pi i}=1</tex>.
Таким образом,
<tex>\dfrac{1}{N}\sum\limits_{k=0}^{N-1}g\left(\phi_k\right)=\dfrac{1}{N}\sum\limits_{k=0}^{N-1}\left(a_0+g\left(\phi_k\right)\right)=a_0</tex>,
а свободный член <tex>H\left(z\right)</tex> равен <tex>L_6</tex>, как известно из предыдущего раздела.
}}

== См. также ==
* [[Производящая функция]]

* [[Динамическое программирование]]

== Примечания ==
<references />
== Источники информации ==
* [http://www.genfunc.ru/theory/lucky/ Задача о счастливых билетах :: Производящие функции]

* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 144с. ISBN 978-5-94057-042-4
[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Комбинаторика]]
[[Категория:Производящие функции]]

Производящие функции нескольких переменных

2018-03-01T14:52:50Z

188.227.78.184: /* Многочлены Бернулли */

{{Определение
|definition=
'''Производящие функции нескольких переменных''' (англ. ''multivariable generating function'') {{---}} обычные [[Производящая функция | производящие функции]], зависящие более, чем от одной переменной. Очень часто применяются функции от двух переменных (далее они и будут рассматриваться), которые в общем случае принимают вид:

<tex>G(x, y) = \sum\limits_{n, k \geqslant 0} g_{n, k} x^n y^k</tex>.
}}

Рассмотрим несколько примеров :

== Треугольник Паскаля ==

{{Определение
|definition=
'''Треугольник Паскаля''' (англ. ''Pascal's triangle'') {{---}} бесконечная таблица биномиальных коэффициентов<ref>[https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BD%D0%BE%D0%BC%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82 Биномиальные коэффициенты]</ref>, имеющая треугольную форму. В этом треугольнике на вершине и по бокам стоят единицы. Каждое число равно сумме двух расположенных над ним чисел.
}}

[[File:Pascal_triangle.png|thumb|400px|right|Рис.<tex>1</tex>]]

Элементы треугольника (рис.<tex>1</tex>) перечисляют пути, идущие из его вершины в соответствующую клетку. Пути имеют вид ломаных, составленных из векторов единичной длины двух видов: идущих вправо-вниз и идущих влево-вниз.

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

<tex>\sum\limits_{n,k = 0}^{\infty} c_{n,k} x^k y^n = \sum\limits_{n,k = 0}^{\infty} \begin{pmatrix} n \\ k \end{pmatrix} x^k y^n = \sum\limits_{n = 0}^{\infty}\Big(\sum\limits_{k = 0}^{n} \begin{pmatrix} n \\ k \end{pmatrix} x^k\Big) y^n = \sum\limits_{n = 0}^{\infty} (1 + x)^n y^n = \dfrac{1}{1 - y - xy}</tex>

[[File:Pascal_triangle_3.png|thumb|600px|right|Рис.<tex>2</tex>]]

Второй способ соответсвует нумерации элементов треугольника числом отрезков каждого типа на путях, ведущих в соответствующую точку (рис.<tex>2</tex>) <tex>C_{n,m} = c_{n+m, n} = \begin{pmatrix} n + m \\ m \end{pmatrix}</tex>. Тогда производящая функция будет иметь вид

<tex>\sum\limits_{n,m = 0}^{\infty} C_{n, m} x^n y^m = \sum\limits_{n,m = 0}^{\infty} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{k = 0}^{\infty} \sum\limits_{n + m = k} \begin{pmatrix} n + m \\ n \end{pmatrix}
x^n y^m = \sum\limits_{k = 0}^{\infty} (x + y)^k = \dfrac{1}{1 -x - y}</tex>

Также существует еще один способ: сопоставить треугольнику Паскаля ''экспоненциальную производящую функцию''. Экспоненциальная производящая функция отличается от обычной тем, что в качестве коэффициентов степенного ряда берутся не элементы последовательности <tex>a_n</tex>, а числа <tex>\dfrac{a_n}{n!}</tex>.

==Экспоненциальные производящие функции==

Зафиксируем произвольную последовательность <tex>\{ \alpha_n \}</tex>. Каждой последовательности <tex>\{ \alpha_n \}</tex> мы можем сопоставить производящую функцию

<tex>\{ \alpha_n \} \mapsto \sum\limits_{n = 0}^{\infty} a_n \alpha_n s^n</tex>

определяемую последовательностью <tex>\{ \alpha_n \}</tex>. Если в последовательности <tex>\{ \alpha_n \}</tex> отсутствуют нулевые элементы, то такое сопоставление взаимно однозначно. До сих пор мы пользовались обычными производящими функциями, отвечающими последовательности <tex>\{ \alpha_n \} \equiv 1</tex>. В зависимости от преследуемых целей могут принести и другие последовательности.

{{Определение
|definition=
'''Производящие экспоненциальные функции''' (англ. ''exponential generating function'') {{---}} функции, соответсвующие последовательности <tex>\{ \alpha_n \} = \dfrac{1}{n!}</tex>.
}}

{{Определение
|definition=
Экспоненциальные производящие функции для целочисленных последовательностей называют '''функциями Гурвица''' (англ. ''Hurwitz function'').
}}

Чем отличаются экспоненциальные производящие функции от обычных? Посмотрим на поведение экспоненциальных производящих функций при выполнении операции над ними. Сумма ведет себя обычным образом:

<tex>\sum\limits_{n = 0}^{\infty} \dfrac{a_n}{n!}s^n + \sum\limits_{n = 0}^{\infty} \dfrac{b+n}{n!}s^n = \sum\limits_{n = 0}^{\infty} \dfrac{(a_n + b_n)}{n!} s^n</tex>

а с произведением по-другому:

<tex>\bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots\bigg)\bigg(\dfrac{b_0}{0!} + \dfrac{b_1}{1!}s + \dfrac{b_2}{2!}s^2 + \ldots\bigg) = \dfrac{a_0}{0!} \dfrac{b_0}{0!} + \bigg(\dfrac{a_0}{0!} \dfrac{b_1}{1!} + \dfrac{a_1}{1!} \dfrac{b_0}{0!}\bigg)s + \bigg(\dfrac{a_0}{0!} \dfrac{b_2}{2!} + \dfrac{a_1}{1!} \dfrac{b_1}{1!} + \dfrac{a_2}{2!} \dfrac{b_0}{0!}\bigg)s^2 + \ldots</tex>

Коэффициенты <tex>\dfrac{c_n}{n!}</tex> произведения вычисляются по формуле

<tex>c_n = \begin{pmatrix} n \\ 0 \end{pmatrix} a_0 b_n + \begin{pmatrix} n \\ 1 \end{pmatrix} a_1 b_{n - 1} + \ldots + \begin{pmatrix} n \\ n \end{pmatrix} a_0 b_0</tex>

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

<tex>\bigg( \dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg)^{'} = \dfrac{a_1}{0!} + \dfrac{a_2}{1!}s + \dfrac{a_3}{2!}s^2 + \ldots </tex>

<tex>\int \bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg) = \dfrac{a_0}{1!}s + \dfrac{a_1}{2!}s^2 + \dfrac{a_2}{3!}s^3 + \dfrac{a_3}{4!}s^4 + \ldots </tex>

Обычная производящая функция <tex>A(s) = a_0 + a_1s + a_2s^2 + \ldots</tex> выражается через экспоненциальную <tex>B(t) = \dfrac{a_0}{0!} + \dfrac{a_1}{1!}t + \dfrac{a_2}{2!}t^2 + \ldots </tex> по формуле

<tex>A(s) = \int_{0}^{\infty} e^{-t} B(st) dt</tex>

Действительно,

<tex>k! = \int_{0}^{\infty} e^{-t}t^kdt</tex>

Теперь можно выписать экспоненциальную производящую функцию для треугольника Паскаля:

<tex>\sum\limits_{n, m = 0}^{\infty} \dfrac{1}{(n + m)!} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{n = 0}^{\infty} \dfrac{(x + y)^n}{n!} = e^{x + y}</tex>

==Многочлены Бернулли==
Для начала введен операцию ''усреднения'', положив

<tex>A(f(x)) = \int\limits_{x}^{x+1}f(t)dt</tex>.

Нетрудно заметить, что эта операция переводит многочлены в многочлены: она линейна, т.е. <tex>A(a_1f_1 + a_2f_2) = a_1A(f_1) + a_2A(f_2)</tex> для любых постоянных <tex>a_1, a_2</tex> и любых многочленов <tex>f_1,
f_2</tex>, а ее значение на мономе<ref>[https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%87%D0%BB%D0%B5%D0%BD Моном]</ref> <tex>x^n</tex> равно

<tex>A(x^n) = ((x + 1)^{n+1} - x^{n+1}) / (n+1) = x^n + \ldots</tex>,

где многоточие обозначает слагаемые, степени которых меньше <tex>n</tex>. Последняя формула показывает также, что преобразование <tex>A</tex> переводит пространство многочленов степени не выше <tex>n</tex> в себя, а значит, является линейным оператором в этом пространстве. Этот оператор обратим. Действительно, любой многочлен степени не выше <tex>n-1</tex> может быть получен в результате усреднения многочлена такой же степени, и, используя последнюю формулу, мы заключаем, что и любой многочлен степени не выше <tex>n</tex> является результатом усреднения некоторого многочлена степени не выше <tex>n</tex>. Отметим, что при усреднении степень многочлена сохраняется.

{{Определение
|definition=
'''Многочленом Бернулли''' (англ. ''Bernoulli polynomial'') степени <tex>n</tex> называется многочлен <tex>B_n(x)</tex>, результатом усреднения которого служит моном <tex>x^n</tex>, т.е. <tex>B_n(x) = A^{-1}(x^n)</tex>.
}}

Первые многочлены Бернулли нетрудно сосчитать:

<tex>B_0(x) = 1</tex>

<tex>B_1(x) = x - \dfrac{1}{2}</tex>

<tex>B_2(x) = x^2 -x + \dfrac{1}{6}</tex>

<tex>B_3(x) = x^3 - \dfrac{3}{2}x^2 + \dfrac{1}{2}x</tex>

<tex>B_4(x) = x^4 - 2x^3 + x^2 - \dfrac{1}{30}</tex>

<tex>B_5(x) = x^5 - \dfrac{5}{2}x^4 + \dfrac{5}{3}x^3 - \dfrac{1}{6}x</tex>

<tex>B_6(x) = x^6 - 3x^5 + \dfrac{5}{2}x^4 - \dfrac{1}{2}x^2 + \dfrac{1}{42}</tex>

{{Теорема
| about = Экспоненциальная производящая функция для многочленов Бернулли
| statement =
Экспоненциальная производящая функция для многочленов Бернулли имеет вид:

<tex>\mathcal{B}(x, s) = \sum\limits_{n=0}^{\infty}B_n(x)\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}e^{sx}</tex>.
| proof =
Для доказательства теоремы достаточно применить операцию усреднения к левой и правой частям равенства. С одной стороны, мы имеем:

<tex>A(B(x, s)) = \sum\limits_{n=0}^{\infty}A(B_n(x))\dfrac{s^n}{n!} = \sum\limits_{n=0}^{\infty}x^n\dfrac{s^n}{n!} = e^{xs}</tex>.

С другой стороны, имеем:

<tex>A(\dfrac{s}{e^s - 1}e^{sx}) = \dfrac{s}{e^s-1}A(e^{sx}) = \dfrac{s}{e^s-1}\dfrac{1}{s}(e^{s(x+1)} - e^{sx}) = e^{sx}</tex>,

и теорема доказана.
}}

Определим теперь ''числа Бернулли''<ref>[https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8 числа Бернулли]</ref> как значения многочленов Бернулли в нуле. Вот начало последовательности чисел Бернулли:

<tex>1, -\dfrac{1}{2}, 0, \dfrac{1}{6}, -\dfrac{1}{30}, \dfrac{1}{42}, 0, -\dfrac{1}{30}, \dfrac{5}{66}, 0, -\dfrac{691}{2730}, 0, \ldots </tex>

Доказанная теорема позволяет нам легко выписать экспоненциальную производящую функцию для чисел Бернулли. Для этого достаточно подставить в экспоненциальную производящую функцию для многочленов Бернулли значение <tex>x = 0</tex>:

<tex>\sum\limits_{n=0} B_n\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}</tex>.

==См. также==
*[[Производящая функция]]

==Примечания==
<references/>

==Источники информации==
* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 57с. ISBN 978-5-94057-042-4

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Производящая функция]]

Производящие функции нескольких переменных

2018-03-01T14:40:25Z

188.227.78.184: /* Экспоненциальные производящие функции */

{{Определение
|definition=
'''Производящие функции нескольких переменных''' (англ. ''multivariable generating function'') {{---}} обычные [[Производящая функция | производящие функции]], зависящие более, чем от одной переменной. Очень часто применяются функции от двух переменных (далее они и будут рассматриваться), которые в общем случае принимают вид:

<tex>G(x, y) = \sum\limits_{n, k \geqslant 0} g_{n, k} x^n y^k</tex>.
}}

Рассмотрим несколько примеров :

== Треугольник Паскаля ==

{{Определение
|definition=
'''Треугольник Паскаля''' (англ. ''Pascal's triangle'') {{---}} бесконечная таблица биномиальных коэффициентов<ref>[https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BD%D0%BE%D0%BC%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82 Биномиальные коэффициенты]</ref>, имеющая треугольную форму. В этом треугольнике на вершине и по бокам стоят единицы. Каждое число равно сумме двух расположенных над ним чисел.
}}

[[File:Pascal_triangle.png|thumb|400px|right|Рис.<tex>1</tex>]]

Элементы треугольника (рис.<tex>1</tex>) перечисляют пути, идущие из его вершины в соответствующую клетку. Пути имеют вид ломаных, составленных из векторов единичной длины двух видов: идущих вправо-вниз и идущих влево-вниз.

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

<tex>\sum\limits_{n,k = 0}^{\infty} c_{n,k} x^k y^n = \sum\limits_{n,k = 0}^{\infty} \begin{pmatrix} n \\ k \end{pmatrix} x^k y^n = \sum\limits_{n = 0}^{\infty}\Big(\sum\limits_{k = 0}^{n} \begin{pmatrix} n \\ k \end{pmatrix} x^k\Big) y^n = \sum\limits_{n = 0}^{\infty} (1 + x)^n y^n = \dfrac{1}{1 - y - xy}</tex>

[[File:Pascal_triangle_3.png|thumb|600px|right|Рис.<tex>2</tex>]]

Второй способ соответсвует нумерации элементов треугольника числом отрезков каждого типа на путях, ведущих в соответствующую точку (рис.<tex>2</tex>) <tex>C_{n,m} = c_{n+m, n} = \begin{pmatrix} n + m \\ m \end{pmatrix}</tex>. Тогда производящая функция будет иметь вид

<tex>\sum\limits_{n,m = 0}^{\infty} C_{n, m} x^n y^m = \sum\limits_{n,m = 0}^{\infty} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{k = 0}^{\infty} \sum\limits_{n + m = k} \begin{pmatrix} n + m \\ n \end{pmatrix}
x^n y^m = \sum\limits_{k = 0}^{\infty} (x + y)^k = \dfrac{1}{1 -x - y}</tex>

Также существует еще один способ: сопоставить треугольнику Паскаля ''экспоненциальную производящую функцию''. Экспоненциальная производящая функция отличается от обычной тем, что в качестве коэффициентов степенного ряда берутся не элементы последовательности <tex>a_n</tex>, а числа <tex>\dfrac{a_n}{n!}</tex>.

==Экспоненциальные производящие функции==

Зафиксируем произвольную последовательность <tex>\{ \alpha_n \}</tex>. Каждой последовательности <tex>\{ \alpha_n \}</tex> мы можем сопоставить производящую функцию

<tex>\{ \alpha_n \} \mapsto \sum\limits_{n = 0}^{\infty} a_n \alpha_n s^n</tex>

определяемую последовательностью <tex>\{ \alpha_n \}</tex>. Если в последовательности <tex>\{ \alpha_n \}</tex> отсутствуют нулевые элементы, то такое сопоставление взаимно однозначно. До сих пор мы пользовались обычными производящими функциями, отвечающими последовательности <tex>\{ \alpha_n \} \equiv 1</tex>. В зависимости от преследуемых целей могут принести и другие последовательности.

{{Определение
|definition=
'''Производящие экспоненциальные функции''' (англ. ''exponential generating function'') {{---}} функции, соответсвующие последовательности <tex>\{ \alpha_n \} = \dfrac{1}{n!}</tex>.
}}

{{Определение
|definition=
Экспоненциальные производящие функции для целочисленных последовательностей называют '''функциями Гурвица''' (англ. ''Hurwitz function'').
}}

Чем отличаются экспоненциальные производящие функции от обычных? Посмотрим на поведение экспоненциальных производящих функций при выполнении операции над ними. Сумма ведет себя обычным образом:

<tex>\sum\limits_{n = 0}^{\infty} \dfrac{a_n}{n!}s^n + \sum\limits_{n = 0}^{\infty} \dfrac{b+n}{n!}s^n = \sum\limits_{n = 0}^{\infty} \dfrac{(a_n + b_n)}{n!} s^n</tex>

а с произведением по-другому:

<tex>\bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots\bigg)\bigg(\dfrac{b_0}{0!} + \dfrac{b_1}{1!}s + \dfrac{b_2}{2!}s^2 + \ldots\bigg) = \dfrac{a_0}{0!} \dfrac{b_0}{0!} + \bigg(\dfrac{a_0}{0!} \dfrac{b_1}{1!} + \dfrac{a_1}{1!} \dfrac{b_0}{0!}\bigg)s + \bigg(\dfrac{a_0}{0!} \dfrac{b_2}{2!} + \dfrac{a_1}{1!} \dfrac{b_1}{1!} + \dfrac{a_2}{2!} \dfrac{b_0}{0!}\bigg)s^2 + \ldots</tex>

Коэффициенты <tex>\dfrac{c_n}{n!}</tex> произведения вычисляются по формуле

<tex>c_n = \begin{pmatrix} n \\ 0 \end{pmatrix} a_0 b_n + \begin{pmatrix} n \\ 1 \end{pmatrix} a_1 b_{n - 1} + \ldots + \begin{pmatrix} n \\ n \end{pmatrix} a_0 b_0</tex>

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

<tex>\bigg( \dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg)^{'} = \dfrac{a_1}{0!} + \dfrac{a_2}{1!}s + \dfrac{a_3}{2!}s^2 + \ldots </tex>

<tex>\int \bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg) = \dfrac{a_0}{1!}s + \dfrac{a_1}{2!}s^2 + \dfrac{a_2}{3!}s^3 + \dfrac{a_3}{4!}s^4 + \ldots </tex>

Обычная производящая функция <tex>A(s) = a_0 + a_1s + a_2s^2 + \ldots</tex> выражается через экспоненциальную <tex>B(t) = \dfrac{a_0}{0!} + \dfrac{a_1}{1!}t + \dfrac{a_2}{2!}t^2 + \ldots </tex> по формуле

<tex>A(s) = \int_{0}^{\infty} e^{-t} B(st) dt</tex>

Действительно,

<tex>k! = \int_{0}^{\infty} e^{-t}t^kdt</tex>

Теперь можно выписать экспоненциальную производящую функцию для треугольника Паскаля:

<tex>\sum\limits_{n, m = 0}^{\infty} \dfrac{1}{(n + m)!} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{n = 0}^{\infty} \dfrac{(x + y)^n}{n!} = e^{x + y}</tex>

==Многочлены Бернулли==
Для начала введен операцию ''усреднения'', положив

<tex>A(f(x)) = \int_{x}^{x+1}f(t)dt</tex>.

Нетрудно заметить, что эта операция переводит многочлены в многочлены: она линейна, т.е. <tex>A(a_1f_1 + a_2f_2) = a_1A(f_1) + a_2A(f_2)</tex> для любых постоянных <tex>a_1, a_2</tex> и любых многочленов <tex>f_1,
f_2</tex>, а ее значение на мономе<ref>[https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%87%D0%BB%D0%B5%D0%BD Моном]</ref> <tex>x^n</tex> равно

<tex>A(x^n) = ((x + 1)^{n+1} - x^{n+1}) / (n+1) = x^n + \ldots</tex>,

где многоточие обозначает слагаемые, степени которых меньше <tex>n</tex>. Последняя формула показывает также, что преобразование <tex>A</tex> переводит пространство многочленов степени не выше <tex>n</tex> в себя, а значит, является линейным оператором в этом пространстве. Этот оператор обратим. Действительно, любой многочлен степени не выше <tex>n-1</tex> может быть получен в результате усреднения многочлена такой же степени, и, используя последнюю формулу, мы заключаем, что и любой многочлен степени не выше <tex>n</tex> является результатом усреднения некоторого многочлена степени не выше <tex>n</tex>. Отметим, что при усреднении степень многочлена сохраняется.

{{Определение
|definition=
'''Многочленом Бернулли''' (англ. ''Bernoulli polynomial'') степени <tex>n</tex> называется многочлен <tex>B_n(x)</tex>, результатом усреднения которого служит моном <tex>x^n</tex>, т.е. <tex>B_n(x) = A^{-1}(x^n)</tex>.
}}

Первые многочлены Бернулли нетрудно сосчитать:

<tex>B_0(x) = 1</tex>

<tex>B_1(x) = x - \dfrac{1}{2}</tex>

<tex>B_2(x) = x^2 -x + \dfrac{1}{6}</tex>

<tex>B_3(x) = x^3 - \dfrac{3}{2}x^2 + \dfrac{1}{2}x</tex>

<tex>B_4(x) = x^4 - 2x^3 + x^2 - \dfrac{1}{30}</tex>

<tex>B_5(x) = x^5 - \dfrac{5}{2}x^4 + \dfrac{5}{3}x^3 - \dfrac{1}{6}x</tex>

<tex>B_6(x) = x^6 - 3x^5 + \dfrac{5}{2}x^4 - \dfrac{1}{2}x^2 + \dfrac{1}{42}</tex>

{{Теорема
| about = Экспоненциальная производящая функция для многочленов Бернулли
| statement =
Экспоненциальная производящая функция для многочленов Бернулли имеет вид:

<tex>\mathcal{B}(x, s) = \sum\limits_{n=0}^{\infty}B_n(x)\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}e^{sx}</tex>.
| proof =
Для доказательства теоремы достаточно применить операцию усреднения к левой и правой частям равенства. С одной стороны, мы имеем:

<tex>A(B(x, s)) = \sum\limits_{n=0}^{\infty}A(B_n(x))\dfrac{s^n}{n!} = \sum\limits_{n=0}^{\infty}x^n\dfrac{s^n}{n!} = e^{xs}</tex>.

С другой стороны, имеем:

<tex>A(\dfrac{s}{e^s - 1}e^{sx}) = \dfrac{s}{e^s-1}A(e^{sx}) = \dfrac{s}{e^s-1}\dfrac{1}{s}(e^{s(x+1)} - e^{sx}) = e^{sx}</tex>,

и теорема доказана.
}}

Определим теперь ''числа Бернулли''<ref>[https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8 числа Бернулли]</ref> как значения многочленов Бернулли в нуле. Вот начало последовательности чисел Бернулли:

<tex>1, -\dfrac{1}{2}, 0, \dfrac{1}{6}, -\dfrac{1}{30}, \dfrac{1}{42}, 0, -\dfrac{1}{30}, \dfrac{5}{66}, 0, -\dfrac{691}{2730}, 0, \ldots </tex>

Доказанная теорема позволяет нам легко выписать экспоненциальную производящую функцию для чисел Бернулли. Для этого достаточно подставить в экспоненциальную производящую функцию для многочленов Бернулли значение <tex>x = 0</tex>:

<tex>\sum\limits_{n=0} B_n\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}</tex>.

==См. также==
*[[Производящая функция]]

==Примечания==
<references/>

==Источники информации==
* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 57с. ISBN 978-5-94057-042-4

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Производящая функция]]

Производящие функции нескольких переменных

2018-03-01T14:39:49Z

188.227.78.184: /* Экспоненциальные производящие функции */

{{Определение
|definition=
'''Производящие функции нескольких переменных''' (англ. ''multivariable generating function'') {{---}} обычные [[Производящая функция | производящие функции]], зависящие более, чем от одной переменной. Очень часто применяются функции от двух переменных (далее они и будут рассматриваться), которые в общем случае принимают вид:

<tex>G(x, y) = \sum\limits_{n, k \geqslant 0} g_{n, k} x^n y^k</tex>.
}}

Рассмотрим несколько примеров :

== Треугольник Паскаля ==

{{Определение
|definition=
'''Треугольник Паскаля''' (англ. ''Pascal's triangle'') {{---}} бесконечная таблица биномиальных коэффициентов<ref>[https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BD%D0%BE%D0%BC%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82 Биномиальные коэффициенты]</ref>, имеющая треугольную форму. В этом треугольнике на вершине и по бокам стоят единицы. Каждое число равно сумме двух расположенных над ним чисел.
}}

[[File:Pascal_triangle.png|thumb|400px|right|Рис.<tex>1</tex>]]

Элементы треугольника (рис.<tex>1</tex>) перечисляют пути, идущие из его вершины в соответствующую клетку. Пути имеют вид ломаных, составленных из векторов единичной длины двух видов: идущих вправо-вниз и идущих влево-вниз.

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

<tex>\sum\limits_{n,k = 0}^{\infty} c_{n,k} x^k y^n = \sum\limits_{n,k = 0}^{\infty} \begin{pmatrix} n \\ k \end{pmatrix} x^k y^n = \sum\limits_{n = 0}^{\infty}\Big(\sum\limits_{k = 0}^{n} \begin{pmatrix} n \\ k \end{pmatrix} x^k\Big) y^n = \sum\limits_{n = 0}^{\infty} (1 + x)^n y^n = \dfrac{1}{1 - y - xy}</tex>

[[File:Pascal_triangle_3.png|thumb|600px|right|Рис.<tex>2</tex>]]

Второй способ соответсвует нумерации элементов треугольника числом отрезков каждого типа на путях, ведущих в соответствующую точку (рис.<tex>2</tex>) <tex>C_{n,m} = c_{n+m, n} = \begin{pmatrix} n + m \\ m \end{pmatrix}</tex>. Тогда производящая функция будет иметь вид

<tex>\sum\limits_{n,m = 0}^{\infty} C_{n, m} x^n y^m = \sum\limits_{n,m = 0}^{\infty} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{k = 0}^{\infty} \sum\limits_{n + m = k} \begin{pmatrix} n + m \\ n \end{pmatrix}
x^n y^m = \sum\limits_{k = 0}^{\infty} (x + y)^k = \dfrac{1}{1 -x - y}</tex>

Также существует еще один способ: сопоставить треугольнику Паскаля ''экспоненциальную производящую функцию''. Экспоненциальная производящая функция отличается от обычной тем, что в качестве коэффициентов степенного ряда берутся не элементы последовательности <tex>a_n</tex>, а числа <tex>\dfrac{a_n}{n!}</tex>.

==Экспоненциальные производящие функции==

Зафиксируем произвольную последовательность <tex>\{ \alpha_n \}</tex>. Каждой последовательности <tex>\{ \alpha_n \}</tex> мы можем сопоставить производящую функцию

<tex>\{ \alpha_n \} \mapsto \sum\limits_{n = 0}^{\infty} a_n \alpha_n s^n</tex>

определяемую последовательностью <tex>\{ \alpha_n \}</tex>. Если в последовательности <tex>\{ \alpha_n \}</tex> отсутствуют нулевые элементы, то такое сопоставление взаимно однозначно. До сих пор мы пользовались обычными производящими функциями, отвечающими последовательности <tex>\{ \alpha_n \} \equiv 1</tex>. В зависимости от преследуемых целей могут принести и другие последовательности.

{{Определение
|definition=
'''Производящие экспоненциальные функции''' (англ. ''exponential generating function'') {{---}} функции, соответсвующие последовательности <tex>\{ \alpha_n \} = \dfrac{1}{n!}</tex>.
}}

{{Определение
|definition=
Экспоненциальные производящие функции для целочисленных последовательностей называют '''функциями Гурвица''' (англ. ''Hurwitz function'').
}}

Чем отличаются экспоненциальные производящие функции от обычных? Посмотрим на поведение экспоненциальных производящих функций при выполнении операции над ними. Сумма ведет себя обычным образом:

<tex>\sum\limits_{n = 0}^{\infty} \dfrac{a_n}{n!}s^n + \sum\limits_{n = 0}^{\infty} \dfrac{b+n}{n!}s^n = \sum\limits_{n = 0}^{\infty} \dfrac{(a_n + b_n)}{n!} s^n</tex>

а с произведением по-другому :

<tex>\bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots\bigg)\bigg(\dfrac{b_0}{0!} + \dfrac{b_1}{1!}s + \dfrac{b_2}{2!}s^2 + \ldots\bigg) = \dfrac{a_0}{0!} \dfrac{b_0}{0!} + \bigg(\dfrac{a_0}{0!} \dfrac{b_1}{1!} + \dfrac{a_1}{1!} \dfrac{b_0}{0!}\bigg)s + \bigg(\dfrac{a_0}{0!} \dfrac{b_2}{2!} + \dfrac{a_1}{1!} \dfrac{b_1}{1!} + \dfrac{a_2}{2!} \dfrac{b_0}{0!}\bigg)s^2 + \ldots</tex>

Коэффициенты <tex>\dfrac{c_n}{n!}</tex> произведения вычисляются по формуле

<tex>c_n = \begin{pmatrix} n \\ 0 \end{pmatrix} a_0 b_n + \begin{pmatrix} n \\ 1 \end{pmatrix} a_1 b_{n - 1} + \ldots + \begin{pmatrix} n \\ n \end{pmatrix} a_0 b_0</tex>

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

<tex>\bigg( \dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg)^{'} = \dfrac{a_1}{0!} + \dfrac{a_2}{1!}s + \dfrac{a_3}{2!}s^2 + \ldots </tex>

<tex>\int \bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg) = \dfrac{a_0}{1!}s + \dfrac{a_1}{2!}s^2 + \dfrac{a_2}{3!}s^3 + \dfrac{a_3}{4!}s^4 + \ldots </tex>

Обычная производящая функция <tex>A(s) = a_0 + a_1s + a_2s^2 + \ldots</tex> выражается через экспоненциальную <tex>B(t) = \dfrac{a_0}{0!} + \dfrac{a_1}{1!}t + \dfrac{a_2}{2!}t^2 + \ldots </tex> по формуле

<tex>A(s) = \int_{0}^{\infty} e^{-t} B(st) dt</tex>

Действительно,

<tex>k! = \int_{0}^{\infty} e^{-t}t^kdt</tex>

Теперь можно выписать экспоненциальную производящую функцию для треугольника Паскаля:

<tex>\sum\limits_{n, m = 0}^{\infty} \dfrac{1}{(n + m)!} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{n = 0}^{\infty} \dfrac{(x + y)^n}{n!} = e^{x + y}</tex>

==Многочлены Бернулли==
Для начала введен операцию ''усреднения'', положив

<tex>A(f(x)) = \int_{x}^{x+1}f(t)dt</tex>.

Нетрудно заметить, что эта операция переводит многочлены в многочлены: она линейна, т.е. <tex>A(a_1f_1 + a_2f_2) = a_1A(f_1) + a_2A(f_2)</tex> для любых постоянных <tex>a_1, a_2</tex> и любых многочленов <tex>f_1,
f_2</tex>, а ее значение на мономе<ref>[https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%87%D0%BB%D0%B5%D0%BD Моном]</ref> <tex>x^n</tex> равно

<tex>A(x^n) = ((x + 1)^{n+1} - x^{n+1}) / (n+1) = x^n + \ldots</tex>,

где многоточие обозначает слагаемые, степени которых меньше <tex>n</tex>. Последняя формула показывает также, что преобразование <tex>A</tex> переводит пространство многочленов степени не выше <tex>n</tex> в себя, а значит, является линейным оператором в этом пространстве. Этот оператор обратим. Действительно, любой многочлен степени не выше <tex>n-1</tex> может быть получен в результате усреднения многочлена такой же степени, и, используя последнюю формулу, мы заключаем, что и любой многочлен степени не выше <tex>n</tex> является результатом усреднения некоторого многочлена степени не выше <tex>n</tex>. Отметим, что при усреднении степень многочлена сохраняется.

{{Определение
|definition=
'''Многочленом Бернулли''' (англ. ''Bernoulli polynomial'') степени <tex>n</tex> называется многочлен <tex>B_n(x)</tex>, результатом усреднения которого служит моном <tex>x^n</tex>, т.е. <tex>B_n(x) = A^{-1}(x^n)</tex>.
}}

Первые многочлены Бернулли нетрудно сосчитать:

<tex>B_0(x) = 1</tex>

<tex>B_1(x) = x - \dfrac{1}{2}</tex>

<tex>B_2(x) = x^2 -x + \dfrac{1}{6}</tex>

<tex>B_3(x) = x^3 - \dfrac{3}{2}x^2 + \dfrac{1}{2}x</tex>

<tex>B_4(x) = x^4 - 2x^3 + x^2 - \dfrac{1}{30}</tex>

<tex>B_5(x) = x^5 - \dfrac{5}{2}x^4 + \dfrac{5}{3}x^3 - \dfrac{1}{6}x</tex>

<tex>B_6(x) = x^6 - 3x^5 + \dfrac{5}{2}x^4 - \dfrac{1}{2}x^2 + \dfrac{1}{42}</tex>

{{Теорема
| about = Экспоненциальная производящая функция для многочленов Бернулли
| statement =
Экспоненциальная производящая функция для многочленов Бернулли имеет вид:

<tex>\mathcal{B}(x, s) = \sum\limits_{n=0}^{\infty}B_n(x)\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}e^{sx}</tex>.
| proof =
Для доказательства теоремы достаточно применить операцию усреднения к левой и правой частям равенства. С одной стороны, мы имеем:

<tex>A(B(x, s)) = \sum\limits_{n=0}^{\infty}A(B_n(x))\dfrac{s^n}{n!} = \sum\limits_{n=0}^{\infty}x^n\dfrac{s^n}{n!} = e^{xs}</tex>.

С другой стороны, имеем:

<tex>A(\dfrac{s}{e^s - 1}e^{sx}) = \dfrac{s}{e^s-1}A(e^{sx}) = \dfrac{s}{e^s-1}\dfrac{1}{s}(e^{s(x+1)} - e^{sx}) = e^{sx}</tex>,

и теорема доказана.
}}

Определим теперь ''числа Бернулли''<ref>[https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8 числа Бернулли]</ref> как значения многочленов Бернулли в нуле. Вот начало последовательности чисел Бернулли:

<tex>1, -\dfrac{1}{2}, 0, \dfrac{1}{6}, -\dfrac{1}{30}, \dfrac{1}{42}, 0, -\dfrac{1}{30}, \dfrac{5}{66}, 0, -\dfrac{691}{2730}, 0, \ldots </tex>

Доказанная теорема позволяет нам легко выписать экспоненциальную производящую функцию для чисел Бернулли. Для этого достаточно подставить в экспоненциальную производящую функцию для многочленов Бернулли значение <tex>x = 0</tex>:

<tex>\sum\limits_{n=0} B_n\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}</tex>.

==См. также==
*[[Производящая функция]]

==Примечания==
<references/>

==Источники информации==
* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 57с. ISBN 978-5-94057-042-4

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Производящая функция]]

Производящие функции нескольких переменных

2018-03-01T14:37:07Z

188.227.78.184: /* Экспоненциальные производящие функции */

{{Определение
|definition=
'''Производящие функции нескольких переменных''' (англ. ''multivariable generating function'') {{---}} обычные [[Производящая функция | производящие функции]], зависящие более, чем от одной переменной. Очень часто применяются функции от двух переменных (далее они и будут рассматриваться), которые в общем случае принимают вид:

<tex>G(x, y) = \sum\limits_{n, k \geqslant 0} g_{n, k} x^n y^k</tex>.
}}

Рассмотрим несколько примеров :

== Треугольник Паскаля ==

{{Определение
|definition=
'''Треугольник Паскаля''' (англ. ''Pascal's triangle'') {{---}} бесконечная таблица биномиальных коэффициентов<ref>[https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BD%D0%BE%D0%BC%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82 Биномиальные коэффициенты]</ref>, имеющая треугольную форму. В этом треугольнике на вершине и по бокам стоят единицы. Каждое число равно сумме двух расположенных над ним чисел.
}}

[[File:Pascal_triangle.png|thumb|400px|right|Рис.<tex>1</tex>]]

Элементы треугольника (рис.<tex>1</tex>) перечисляют пути, идущие из его вершины в соответствующую клетку. Пути имеют вид ломаных, составленных из векторов единичной длины двух видов: идущих вправо-вниз и идущих влево-вниз.

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

<tex>\sum\limits_{n,k = 0}^{\infty} c_{n,k} x^k y^n = \sum\limits_{n,k = 0}^{\infty} \begin{pmatrix} n \\ k \end{pmatrix} x^k y^n = \sum\limits_{n = 0}^{\infty}\Big(\sum\limits_{k = 0}^{n} \begin{pmatrix} n \\ k \end{pmatrix} x^k\Big) y^n = \sum\limits_{n = 0}^{\infty} (1 + x)^n y^n = \dfrac{1}{1 - y - xy}</tex>

[[File:Pascal_triangle_3.png|thumb|600px|right|Рис.<tex>2</tex>]]

Второй способ соответсвует нумерации элементов треугольника числом отрезков каждого типа на путях, ведущих в соответствующую точку (рис.<tex>2</tex>) <tex>C_{n,m} = c_{n+m, n} = \begin{pmatrix} n + m \\ m \end{pmatrix}</tex>. Тогда производящая функция будет иметь вид

<tex>\sum\limits_{n,m = 0}^{\infty} C_{n, m} x^n y^m = \sum\limits_{n,m = 0}^{\infty} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{k = 0}^{\infty} \sum\limits_{n + m = k} \begin{pmatrix} n + m \\ n \end{pmatrix}
x^n y^m = \sum\limits_{k = 0}^{\infty} (x + y)^k = \dfrac{1}{1 -x - y}</tex>

Также существует еще один способ: сопоставить треугольнику Паскаля ''экспоненциальную производящую функцию''. Экспоненциальная производящая функция отличается от обычной тем, что в качестве коэффициентов степенного ряда берутся не элементы последовательности <tex>a_n</tex>, а числа <tex>\dfrac{a_n}{n!}</tex>.

==Экспоненциальные производящие функции==

Зафиксируем произвольную последовательность <tex>\{ \alpha_n \}</tex>. Каждой последовательности <tex>\{ \alpha_n \}</tex> мы можем сопоставить производящую функцию

<tex>\{ \alpha_n \} \mapsto \sum\limits_{n = 0}^{\infty} a_n \alpha_n s^n</tex>

определяемую последовательностью <tex>\{ \alpha_n \}</tex>. Если в последовательности <tex>\{ \alpha_n \}</tex> отсутствуют нулевые элементы, то такое сопоставление взаимно однозначно. До сих пор мы пользовались обычными производящими функциями, отвечающими последовательности <tex>\{ \alpha_n \} \equiv 1</tex>. В зависимости от преследуемых целей могут принести и другие последовательности.

{{Определение
|definition=
'''Производящие экспоненциальные функции''' (англ. ''exponential generating function'') {{---}} функции, соответсвующие последовательности <tex>\{ \alpha_n \} = \dfrac{1}{n!}</tex>.
}}

{{Определение
|definition=
Экспоненциальные производящие функции для целочисленных последовательностей называют '''функциями Гурвица''' (англ. ''Hurwitz function'').
}}

Чем отличаются экспоненциальные производящие функции от обычных? Посмотрим на поведение экспоненциальных производящих функций при выполнении операции над ними. Сумма ведет себя обычным образом:

<tex>\sum\limits_{n = 0}^{\infty} \dfrac{a_n}{n!}s^n + \sum\limits_{n = 0}^{\infty} \dfrac{b+n}{n!}s^n = \sum\limits_{n = 0}^{\infty} \dfrac{(a_n + b_n)}{n!} s^n</tex>

а с произведением по-другому :

<tex>\bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots\bigg)\bigg(\dfrac{b_0}{0!} + \dfrac{b_1}{1!}s + \dfrac{b_2}{2!}s^2 + \ldots\bigg) = \dfrac{a_0}{0!} \dfrac{b_0}{0!} + \bigg(\dfrac{a_0}{0!} \dfrac{b_1}{1!} + \dfrac{a_1}{1!} \dfrac{b_0}{0!}\bigg)s + \bigg(\dfrac{a_0}{0!} \dfrac{b_2}{2!} + \dfrac{a_1}{1!} \dfrac{b_1}{1!} + \dfrac{a_2}{2!} \dfrac{b_0}{0!}\bigg)s^2 + \ldots</tex>

Коэффициенты <tex>\dfrac{c_n}{n!}</tex> произведения вычисляются по формуле

<tex>c_n = \begin{pmatrix} n \\ 0 \end{pmatrix} a_0 b_n + \begin{pmatrix} n \\ 1 \end{pmatrix} a_1 b_{n - 1} + \ldots + \begin{pmatrix} n \\ n \end{pmatrix} a_0 b_0</tex>

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

<tex>\bigg( \dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg)^{'} = \dfrac{a_1}{0!} + \dfrac{a_2}{1!}s + \dfrac{a_3}{2!}s^2 + \ldots </tex>

<tex>\int \bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg) = \dfrac{a_0}{1!}s + \dfrac{a_1}{2!}s^2 + \dfrac{a_2}{3!}s^3 + \dfrac{a_3}{4!}s^4 + \ldots </tex>

Обычная производящая функция <tex>A(s) = a_0 + a_1s + a_2s^2 + \ldots</tex> выражается через экспоненциальную <tex>B(t) = \dfrac{a_0}{0!} + \dfrac{a_1}{1!}t + \dfrac{a_2}{2!}t^2 + \ldots </tex> по формуле

<tex>A(s) = \int_{0}^{\infty} e^{-t} B(st) dt</tex>

Действительно,

<tex>k! = \int_{0}^{\infty} e^{-t}t^kdt</tex>

Теперь можно выписать экспоненциальную производящую функцию для треугольника Паскаля:

<tex>\sum\limits_{n, m = 0}^{\infty} \dfrac{1}{(n + m)!} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{n = 0}^{\infty} \dfrac{(x + y)^n}{n!} = e^{x + y}</tex>

==Многочлены Бернулли==
Для начала введен операцию ''усреднения'', положив

<tex>A(f(x)) = \int_{x}^{x+1}f(t)dt</tex>.

Нетрудно заметить, что эта операция переводит многочлены в многочлены: она линейна, т.е. <tex>A(a_1f_1 + a_2f_2) = a_1A(f_1) + a_2A(f_2)</tex> для любых постоянных <tex>a_1, a_2</tex> и любых многочленов <tex>f_1,
f_2</tex>, а ее значение на мономе<ref>[https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%87%D0%BB%D0%B5%D0%BD Моном]</ref> <tex>x^n</tex> равно

<tex>A(x^n) = ((x + 1)^{n+1} - x^{n+1}) / (n+1) = x^n + \ldots</tex>,

где многоточие обозначает слагаемые, степени которых меньше <tex>n</tex>. Последняя формула показывает также, что преобразование <tex>A</tex> переводит пространство многочленов степени не выше <tex>n</tex> в себя, а значит, является линейным оператором в этом пространстве. Этот оператор обратим. Действительно, любой многочлен степени не выше <tex>n-1</tex> может быть получен в результате усреднения многочлена такой же степени, и, используя последнюю формулу, мы заключаем, что и любой многочлен степени не выше <tex>n</tex> является результатом усреднения некоторого многочлена степени не выше <tex>n</tex>. Отметим, что при усреднении степень многочлена сохраняется.

{{Определение
|definition=
'''Многочленом Бернулли''' (англ. ''Bernoulli polynomial'') степени <tex>n</tex> называется многочлен <tex>B_n(x)</tex>, результатом усреднения которого служит моном <tex>x^n</tex>, т.е. <tex>B_n(x) = A^{-1}(x^n)</tex>.
}}

Первые многочлены Бернулли нетрудно сосчитать:

<tex>B_0(x) = 1</tex>

<tex>B_1(x) = x - \dfrac{1}{2}</tex>

<tex>B_2(x) = x^2 -x + \dfrac{1}{6}</tex>

<tex>B_3(x) = x^3 - \dfrac{3}{2}x^2 + \dfrac{1}{2}x</tex>

<tex>B_4(x) = x^4 - 2x^3 + x^2 - \dfrac{1}{30}</tex>

<tex>B_5(x) = x^5 - \dfrac{5}{2}x^4 + \dfrac{5}{3}x^3 - \dfrac{1}{6}x</tex>

<tex>B_6(x) = x^6 - 3x^5 + \dfrac{5}{2}x^4 - \dfrac{1}{2}x^2 + \dfrac{1}{42}</tex>

{{Теорема
| about = Экспоненциальная производящая функция для многочленов Бернулли
| statement =
Экспоненциальная производящая функция для многочленов Бернулли имеет вид:

<tex>\mathcal{B}(x, s) = \sum\limits_{n=0}^{\infty}B_n(x)\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}e^{sx}</tex>.
| proof =
Для доказательства теоремы достаточно применить операцию усреднения к левой и правой частям равенства. С одной стороны, мы имеем:

<tex>A(B(x, s)) = \sum\limits_{n=0}^{\infty}A(B_n(x))\dfrac{s^n}{n!} = \sum\limits_{n=0}^{\infty}x^n\dfrac{s^n}{n!} = e^{xs}</tex>.

С другой стороны, имеем:

<tex>A(\dfrac{s}{e^s - 1}e^{sx}) = \dfrac{s}{e^s-1}A(e^{sx}) = \dfrac{s}{e^s-1}\dfrac{1}{s}(e^{s(x+1)} - e^{sx}) = e^{sx}</tex>,

и теорема доказана.
}}

Определим теперь ''числа Бернулли''<ref>[https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8 числа Бернулли]</ref> как значения многочленов Бернулли в нуле. Вот начало последовательности чисел Бернулли:

<tex>1, -\dfrac{1}{2}, 0, \dfrac{1}{6}, -\dfrac{1}{30}, \dfrac{1}{42}, 0, -\dfrac{1}{30}, \dfrac{5}{66}, 0, -\dfrac{691}{2730}, 0, \ldots </tex>

Доказанная теорема позволяет нам легко выписать экспоненциальную производящую функцию для чисел Бернулли. Для этого достаточно подставить в экспоненциальную производящую функцию для многочленов Бернулли значение <tex>x = 0</tex>:

<tex>\sum\limits_{n=0} B_n\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}</tex>.

==См. также==
*[[Производящая функция]]

==Примечания==
<references/>

==Источники информации==
* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 57с. ISBN 978-5-94057-042-4

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Производящая функция]]

Производящие функции нескольких переменных

2018-03-01T14:33:20Z

188.227.78.184:

{{Определение
|definition=
'''Производящие функции нескольких переменных''' (англ. ''multivariable generating function'') {{---}} обычные [[Производящая функция | производящие функции]], зависящие более, чем от одной переменной. Очень часто применяются функции от двух переменных (далее они и будут рассматриваться), которые в общем случае принимают вид:

<tex>G(x, y) = \sum\limits_{n, k \geqslant 0} g_{n, k} x^n y^k</tex>.
}}

Рассмотрим несколько примеров :

== Треугольник Паскаля ==

{{Определение
|definition=
'''Треугольник Паскаля''' (англ. ''Pascal's triangle'') {{---}} бесконечная таблица биномиальных коэффициентов<ref>[https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D0%BD%D0%BE%D0%BC%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D1%8D%D1%84%D1%84%D0%B8%D1%86%D0%B8%D0%B5%D0%BD%D1%82 Биномиальные коэффициенты]</ref>, имеющая треугольную форму. В этом треугольнике на вершине и по бокам стоят единицы. Каждое число равно сумме двух расположенных над ним чисел.
}}

[[File:Pascal_triangle.png|thumb|400px|right|Рис.<tex>1</tex>]]

Элементы треугольника (рис.<tex>1</tex>) перечисляют пути, идущие из его вершины в соответствующую клетку. Пути имеют вид ломаных, составленных из векторов единичной длины двух видов: идущих вправо-вниз и идущих влево-вниз.

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

<tex>\sum\limits_{n,k = 0}^{\infty} c_{n,k} x^k y^n = \sum\limits_{n,k = 0}^{\infty} \begin{pmatrix} n \\ k \end{pmatrix} x^k y^n = \sum\limits_{n = 0}^{\infty}\Big(\sum\limits_{k = 0}^{n} \begin{pmatrix} n \\ k \end{pmatrix} x^k\Big) y^n = \sum\limits_{n = 0}^{\infty} (1 + x)^n y^n = \dfrac{1}{1 - y - xy}</tex>

[[File:Pascal_triangle_3.png|thumb|600px|right|Рис.<tex>2</tex>]]

Второй способ соответсвует нумерации элементов треугольника числом отрезков каждого типа на путях, ведущих в соответствующую точку (рис.<tex>2</tex>) <tex>C_{n,m} = c_{n+m, n} = \begin{pmatrix} n + m \\ m \end{pmatrix}</tex>. Тогда производящая функция будет иметь вид

<tex>\sum\limits_{n,m = 0}^{\infty} C_{n, m} x^n y^m = \sum\limits_{n,m = 0}^{\infty} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{k = 0}^{\infty} \sum\limits_{n + m = k} \begin{pmatrix} n + m \\ n \end{pmatrix}
x^n y^m = \sum\limits_{k = 0}^{\infty} (x + y)^k = \dfrac{1}{1 -x - y}</tex>

Также существует еще один способ: сопоставить треугольнику Паскаля ''экспоненциальную производящую функцию''. Экспоненциальная производящая функция отличается от обычной тем, что в качестве коэффициентов степенного ряда берутся не элементы последовательности <tex>a_n</tex>, а числа <tex>\dfrac{a_n}{n!}</tex>.

==Экспоненциальные производящие функции==

Зафиксируем произвольную последовательность <tex>\{ \alpha_n \}</tex>. Каждой последовательности <tex>\{ \alpha_n \}</tex> мы можем сопоставить производящую функцию

<tex>\{ \alpha_n \} \mapsto \sum\limits_{n = 0}^{\infty} a_n \alpha_n s^n</tex>

определяемую последовательностью <tex>\{ \alpha_n \}</tex>. Если в последовательности <tex>\{ \alpha_n \}</tex> отсутствуют нулевые элементы, то такое сопоставление взаимно однозначно. До сих пор мы пользовались обычными производящими функциями - отвечающими последовательности <tex>\{ \alpha_n \} \equiv 1</tex>. В зависимости от преследуемых целей целей могут принести и другие последовательности .

{{Определение
|definition=
'''Производящие экспоненциальные функции''' (англ. ''exponential generating function'') {{---}} функции, соответсвующие последовательности <tex>\{ \alpha_n \} = \dfrac{1}{n!}</tex>.
}}

{{Определение
|definition=
Экспоненциальные производящие функции для целочисленных последовательностей называют '''функциями Гурвица''' (англ. ''Hurwitz function'').
}}

Чем отличаются экспоненциальные производящие функции от обычных? Посмотрим на поведение экспоненциальных производящих функций при выполнении операции над ними. Сумма ведет себя обычным образом:

<tex>\sum\limits_{n = 0}^{\infty} \dfrac{a_n}{n!}s^n + \sum\limits_{n = 0}^{\infty} \dfrac{b+n}{n!}s^n = \sum\limits_{n = 0}^{\infty} \dfrac{(a_n + b_n)}{n!} s^n</tex>

а с произведением по-другому :

<tex>\bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots\bigg)\bigg(\dfrac{b_0}{0!} + \dfrac{b_1}{1!}s + \dfrac{b_2}{2!}s^2 + \ldots\bigg) = \dfrac{a_0}{0!} \dfrac{b_0}{0!} + \bigg(\dfrac{a_0}{0!} \dfrac{b_1}{1!} + \dfrac{a_1}{1!} \dfrac{b_0}{0!}\bigg)s + \bigg(\dfrac{a_0}{0!} \dfrac{b_2}{2!} + \dfrac{a_1}{1!} \dfrac{b_1}{1!} + \dfrac{a_2}{2!} \dfrac{b_0}{0!}\bigg)s^2 + \ldots</tex>

Коэффициенты <tex>\dfrac{c_n}{n!}</tex> произведения вычисляются по формуле

<tex>c_n = \begin{pmatrix} n \\ 0 \end{pmatrix} a_0 b_n + \begin{pmatrix} n \\ 1 \end{pmatrix} a_1 b_{n - 1} + \ldots + \begin{pmatrix} n \\ n \end{pmatrix} a_0 b_0</tex>

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

<tex>\bigg( \dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg)^{'} = \dfrac{a_1}{0!} + \dfrac{a_2}{1!}s + \dfrac{a_3}{2!}s^2 + \ldots </tex>

<tex>\int \bigg(\dfrac{a_0}{0!} + \dfrac{a_1}{1!}s + \dfrac{a_2}{2!}s^2 + \ldots \bigg) = \dfrac{a_0}{1!}s + \dfrac{a_1}{2!}s^2 + \dfrac{a_2}{3!}s^3 + \dfrac{a_3}{4!}s^4 + \ldots </tex>

Обычная производящая функция <tex>A(s) = a_0 + a_1s + a_2s^2 + \ldots</tex> выражается через экспоненциальную <tex>B(t) = \dfrac{a_0}{0!} + \dfrac{a_1}{1!}t + \dfrac{a_2}{2!}t^2 + \ldots </tex> по формуле

<tex>A(s) = \int_{0}^{\infty} e^{-t} B(st) dt</tex>

Действительно,

<tex>k! = \int_{0}^{\infty} e^{-t}t^kdt</tex>

Теперь можно выписать экспоненциальную производящую функцию для треугольника Паскаля:

<tex>\sum\limits_{n, m = 0}^{\infty} \dfrac{1}{(n + m)!} \begin{pmatrix} n + m \\ m \end{pmatrix} x^n y^m = \sum\limits_{n = 0}^{\infty} \dfrac{(x + y)^n}{n!} = e^{x + y}</tex>

==Многочлены Бернулли==
Для начала введен операцию ''усреднения'', положив

<tex>A(f(x)) = \int_{x}^{x+1}f(t)dt</tex>.

Нетрудно заметить, что эта операция переводит многочлены в многочлены: она линейна, т.е. <tex>A(a_1f_1 + a_2f_2) = a_1A(f_1) + a_2A(f_2)</tex> для любых постоянных <tex>a_1, a_2</tex> и любых многочленов <tex>f_1,
f_2</tex>, а ее значение на мономе<ref>[https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%87%D0%BB%D0%B5%D0%BD Моном]</ref> <tex>x^n</tex> равно

<tex>A(x^n) = ((x + 1)^{n+1} - x^{n+1}) / (n+1) = x^n + \ldots</tex>,

где многоточие обозначает слагаемые, степени которых меньше <tex>n</tex>. Последняя формула показывает также, что преобразование <tex>A</tex> переводит пространство многочленов степени не выше <tex>n</tex> в себя, а значит, является линейным оператором в этом пространстве. Этот оператор обратим. Действительно, любой многочлен степени не выше <tex>n-1</tex> может быть получен в результате усреднения многочлена такой же степени, и, используя последнюю формулу, мы заключаем, что и любой многочлен степени не выше <tex>n</tex> является результатом усреднения некоторого многочлена степени не выше <tex>n</tex>. Отметим, что при усреднении степень многочлена сохраняется.

{{Определение
|definition=
'''Многочленом Бернулли''' (англ. ''Bernoulli polynomial'') степени <tex>n</tex> называется многочлен <tex>B_n(x)</tex>, результатом усреднения которого служит моном <tex>x^n</tex>, т.е. <tex>B_n(x) = A^{-1}(x^n)</tex>.
}}

Первые многочлены Бернулли нетрудно сосчитать:

<tex>B_0(x) = 1</tex>

<tex>B_1(x) = x - \dfrac{1}{2}</tex>

<tex>B_2(x) = x^2 -x + \dfrac{1}{6}</tex>

<tex>B_3(x) = x^3 - \dfrac{3}{2}x^2 + \dfrac{1}{2}x</tex>

<tex>B_4(x) = x^4 - 2x^3 + x^2 - \dfrac{1}{30}</tex>

<tex>B_5(x) = x^5 - \dfrac{5}{2}x^4 + \dfrac{5}{3}x^3 - \dfrac{1}{6}x</tex>

<tex>B_6(x) = x^6 - 3x^5 + \dfrac{5}{2}x^4 - \dfrac{1}{2}x^2 + \dfrac{1}{42}</tex>

{{Теорема
| about = Экспоненциальная производящая функция для многочленов Бернулли
| statement =
Экспоненциальная производящая функция для многочленов Бернулли имеет вид:

<tex>\mathcal{B}(x, s) = \sum\limits_{n=0}^{\infty}B_n(x)\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}e^{sx}</tex>.
| proof =
Для доказательства теоремы достаточно применить операцию усреднения к левой и правой частям равенства. С одной стороны, мы имеем:

<tex>A(B(x, s)) = \sum\limits_{n=0}^{\infty}A(B_n(x))\dfrac{s^n}{n!} = \sum\limits_{n=0}^{\infty}x^n\dfrac{s^n}{n!} = e^{xs}</tex>.

С другой стороны, имеем:

<tex>A(\dfrac{s}{e^s - 1}e^{sx}) = \dfrac{s}{e^s-1}A(e^{sx}) = \dfrac{s}{e^s-1}\dfrac{1}{s}(e^{s(x+1)} - e^{sx}) = e^{sx}</tex>,

и теорема доказана.
}}

Определим теперь ''числа Бернулли''<ref>[https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8 числа Бернулли]</ref> как значения многочленов Бернулли в нуле. Вот начало последовательности чисел Бернулли:

<tex>1, -\dfrac{1}{2}, 0, \dfrac{1}{6}, -\dfrac{1}{30}, \dfrac{1}{42}, 0, -\dfrac{1}{30}, \dfrac{5}{66}, 0, -\dfrac{691}{2730}, 0, \ldots </tex>

Доказанная теорема позволяет нам легко выписать экспоненциальную производящую функцию для чисел Бернулли. Для этого достаточно подставить в экспоненциальную производящую функцию для многочленов Бернулли значение <tex>x = 0</tex>:

<tex>\sum\limits_{n=0} B_n\dfrac{s^n}{n!} = \dfrac{s}{e^s - 1}</tex>.

==См. также==
*[[Производящая функция]]

==Примечания==
<references/>

==Источники информации==
* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 57с. ISBN 978-5-94057-042-4

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Производящая функция]]

Арифметические действия с формальными степенными рядами

2018-03-01T14:29:32Z

188.227.78.184: /* Сдвиг влево */

==Простейшие операции==
Рассмотрим два [[Производящая функция|формальных степенных ряда]] <tex>A(s) = a_0 + a_1 s + a_2 s^2 + \dots</tex> и <tex>B(s) = b_0 + b_1 s + b_2 s^2 + \dots</tex>.
{{Определение
|definition = '''Суммой''' (англ. ''addition'') формальных степенных рядов <tex>A</tex> и <tex>B</tex> называется ряд <tex>A(s) + B(s) = (a_0 + b_0) + (a_1 + b_1) s + (a_2 + b_2) s^2 + \dots</tex>.
}}
{{Определение
|definition = '''Произведением''' (англ. ''multiplication'') формальных степенных рядов <tex>A</tex> и <tex>B</tex> называется ряд <tex>A(s)B(s) = a_0 b_0 + (a_0 b_1 + a_1 b_0) s + (a_0 b_2 + a_1 b_1 + a_2 b_0) s^2 + \dots</tex>.
}}
Операции сложения и умножения формальных степенных рядов коммутативны и ассоциативны.

==Деление==
{{Определение
|definition=
'''Обратным по умножению''' (англ. ''multiplicative inverse'') к формальному степенному ряду <tex>A(s)</tex> называется такой ряд <tex>B(s)</tex>, что <tex>A(s)B(s) = 1</tex>. Обозначение: <tex>B(s) = A^{-1}(s)</tex>.
}}

{{Лемма
|statement = Пусть <tex>A(s) = a_0 + a_1 s + a_2 s^2 + a_3 s^3 + \dots </tex> {{---}} формальный степенной ряд, причем <tex>A(0) \ne 0</tex>. Тогда существует единственный обратный по умножению к <tex>A(s)</tex> ряд <tex>B(s) = b_0 + b_1 s + b_2 s^2 + b_3 s^3 + \dots </tex>.
|proof =
:Распишем <tex>A(s)B(s)</tex> по формуле произведения рядов: <tex>A(s)B(s) = a_0 b_0 + (a_0 b_1 + a_1 b_0)s + (a_0 b_2 + a_1 b_1 + a_2 b_0) s^2 + \dots</tex>. Заметим, что условие <tex>A(s)B(s) = 1</tex> выполнено только в том случае, если <tex>a_0 b_0 = 1</tex>, а все остальные слагаемые полученного ряда равны нулю.
:Докажем по индукции, что такой ряд <tex>B</tex> единственен. Нам известно, что <tex>b_0 = \dfrac{1}{a_0}</tex>. Пусть теперь все коэффициенты ряда <tex>B</tex> вплоть до степени <tex>n - 1</tex> однозначно определены. Коэффициент при <tex>s^n</tex> определяется из условия <tex>a_0 b_n + a_1 b_{n - 1} + \dots + a_n b_0 = 0</tex>. Это линейное уравнение на <tex>b_n</tex>, причем коэффициент <tex>a_0</tex> при <tex>b_n</tex> отличен от нуля. Такое уравнение имеет единственное решение.
}}

{{Определение
|definition=
'''Делением''' (англ. ''division'') формальных степенных рядов <tex>A(s)</tex> и <tex>B(s)</tex> называется операция <tex>\dfrac{A(s)}{B(s)} = A(s) B(s)^{-1}</tex> (при условии существования у <tex>B(s)</tex> обратного).
}}

===Примеры===
#Допустим, надо построить обратный ряд для <tex>A(s) = 1 + s</tex>. Воспользуемся леммой:
#:<tex>b_0 = \dfrac{1}{a_0} = \dfrac{1}{1} = 1</tex>
#:<tex>a_0 b_1 + a_1 b_0 = 0 \Rightarrow b_1 = - \dfrac{a_1 b_0}{a_0} = - \dfrac{1 \cdot 1}{1} = -1</tex>
#:<tex>a_0 b_2 + a_1 b_1 + a_2 b_0 = 0 \Rightarrow b_2 = - \dfrac{a_1 b_1 + a_2 b_0}{a_0} = - \dfrac{1 \cdot (-1) + 0}{1} = 1</tex>
#:<tex>\dots</tex>
#:<tex>b_n = - \dfrac{a_1 b_{n - 1}}{a_0} = -b_{n - 1}</tex>
#:<tex>B(s) = 1 - s + s^2 - s^3 + \dots</tex>
#Пусть теперь надо построить обратный ряд для <tex>A(s) = 1 - s - s^2</tex>:
#:<tex>b_0 = \dfrac{1}{a_0} = \dfrac{1}{1} = 1</tex>
#:<tex>b_1 = - \dfrac{a_1 b_0}{a_0} = - \dfrac{(-1) \cdot 1}{1} = 1</tex>
#:<tex>b_2 = - \dfrac{a_1 b_1 + a_2 b_0}{a_0} = - \dfrac{(-1) \cdot 1 + (-1) \cdot 1}{1} = 2</tex>
#:<tex>b_3 = - \dfrac{a_1 b_2 + a_2 b_1}{a_0} = - \dfrac{(-1) \cdot 2 + (-1) \cdot 1}{1} = 3</tex>
#:<tex>\dots</tex>
#:<tex>b_n = - \dfrac{a_1 b_{n - 1} + a_2 b_{n - 2}}{a_0} = b_{n - 1} + b_{n - 2}</tex>
#:<tex>B(s) = 1 + s + 2 s^2 + 3 s^3 + \dots</tex>

==Композиция==
Пусть <tex>A(s) = a_0 + a_1 s + a_2 s^2 + \dots</tex> и <tex>B(s) = b_0 + b_1 s + b_2 s^2 + \dots</tex> {{---}} два формальных степенных ряда, причем <tex>B(0) = b_0 = 0</tex>.

{{Определение
|definition =
'''Композицией (подстановкой)''' (англ. ''composition'') формальных степенных рядов <tex>A</tex> и <tex>B</tex> называется ряд <tex>A(B(t)) = a_0 + a_1 b_1 t + (a_1 b_2 + a_2 b_1^2) t^2 + (a_1 b_3 + 2 a_2 b_1 b_2 + a_3 b_1^3) t^3 + \dots</tex>.
}}
Если, например, <tex>B(t) = -t</tex>, то <tex>A(B(t)) = A(-t) = a_0 -a_1 t + a_2 t^2 - a_3 t^3 + \dots</tex>.

Операция подстановки в случае, когда <tex>B(0) \ne 0</tex>, не определена. (При попытке подставить такой ряд для вычисления коэффициентов результата возникает необходимость суммирования бесконечных числовых рядов).

==Обратный ряд==
{{Определение
|definition=
'''Левым обратным''' (англ. ''left inverse'') по операции подстановки формальным степенным рядом для ряда <tex>B(t)</tex> называется такой ряд <tex>A(s)</tex>, что <tex>A(B(t)) = t</tex>. Аналогично, '''правым обратным''' (англ. ''right inverse'') формальным степенным рядом для <tex>B(t)</tex> называется такой <tex>C(u)</tex>, что <tex>B(C(u)) = u</tex>.
}}

{{Теорема
|about = об обратном формальном степенном ряде
|statement = Пусть ряд <tex>B(t) = b_0 + b_1 t + b_2 t^2 + b_3 t^3 + \dots</tex> таков, что <tex>B(0) = b_0 = 0</tex>, а <tex>b_1 \ne 0</tex>. Тогда существуют такие ряды <tex> A(s) = a_1 s + a_2 s^2 + a_3 s^3 + \dots</tex>, <tex>A(0) = 0</tex> и <tex>C(u) = c_1 u + c_2 u^2 + c_3 u^3 + \dots</tex>, <tex>C(0) = 0</tex>, что <tex>A(t)</tex> является левым обратным, а <tex>C(u)</tex> {{---}} правым обратным для <tex>B(s)</tex>. При этом, ряды <tex>A</tex> и <tex>C</tex> единственны.
|proof =
:Докажем по индукции существование и единственность левого обратного ряда. Доказательство для правого аналогично.
:Будем определять коэффициенты ряда <tex>A</tex> последовательно. Поскольку <tex>A(B(t)) = t</tex>, <tex>a_1 b_1 = 1</tex>, откуда <tex>a_1 = \dfrac{1}{b_1}</tex>. Все остальные коэффициенты результирующего ряда при этом равны нулю.
:Предположим теперь, что коэффициенты <tex>a_1, a_2, \dots, a_n</tex> уже определены. Коэффициент <tex>a_{n+1}</tex> определяется из условия <tex>a_{n+1} b_1^{n+1} + \dots = 0</tex>, где точками обозначен некоторый многочлен от <tex>a_1, \dots, a_n</tex> и <tex>b_1, \dots, b_n</tex>. Тем самым, условие представляет собой линейное уравнение на <tex>a_{n+1}</tex>, причем коэффициент <tex>b_1^{n+1}</tex> при <tex>a_{n+1}</tex> отличен от нуля. Такое уравнение имеет единственное решение, и теорема доказана.
}}
===Пример===
Найдем левый обратный ряд для <tex>B(t) = t + t^2</tex>:
:<tex>a_0 = 0</tex>
:<tex>a_1 = \dfrac{1}{b_1} = 1</tex>
:<tex>a_1 b_2 + a_2 b_1^2 = 0 \Rightarrow a_2 = - \dfrac{a_1 b_2}{b_1^2} = - \dfrac{1 \cdot 1}{1^2} = -1</tex>
:<tex>a_1 b_3 + 2 a_2 b_1 b_2 + a_3 b_1^3 = 0 \Rightarrow a_3 = - \dfrac{a_1 b_3 + 2 a_2 b_1 b_2}{b_1^3} = - \dfrac{1 \cdot 0 + 2 \cdot (-1) \cdot 1}{1^3} = 2</tex>
:<tex>\dots</tex>
:<tex>A(s) = s - s^2 + 2 s^3 + \dots</tex>

==Сдвиги==
===Сдвиг вправо===
Сдвиг ряда вправо на <tex>k</tex> получается домножением его на <tex>s^k</tex>. Например, пусть исходный ряд <tex>A(s) = a_0 + a_1 s + a_2 s^2 + \dots</tex>. Сдвинем его на <tex>k</tex> вправо: <tex>B(s) = s^k \cdot A(s) = a_0 s^k + a_1 s^{k + 1} + a_2 s^{k + 2} + \dots = 0 + 0 s + 0 s^2 + \dots + a_0 s^k + a_1 s^{k + 1} + \dots</tex>.

===Сдвиг влево===
Сдвинуть ряд влево на <tex>k</tex> можно, вычтя из него первые <tex>k</tex> слагаемых и затем разделив его на <tex>s^k</tex>. Например, сдвинем ряд <tex>A(s) = a_0 + a_1 s + a_2 s^2 + \dots</tex> на <tex>k</tex> влево: <tex>B(s) = \dfrac{A(s) - (a_0 + a_1 s + a_2 s^2 + \dots + a_{k - 1} s^{k - 1})}{s^k} = a_k + a_{k + 1} s + a_{k + 2} s^2 + \dots</tex>.

Сдвиги могут быть полезны для упрощения вычисления производящих функций.
Например, попробуем получить функцию для чисел Фибоначчи, используя сдвиги. Пусть формальный степенной ряд для нее равен <tex>F(s) = f_0 + f_1 s + f_2 s^2 + \dots</tex>, при этом <tex>f_0 = f_1 = 1</tex>, <tex>f_n = f_{n - 2} + f_{n - 1}, n > 1</tex>. Рассмотрим сумму этого ряда и ряда, полученного из него сдвигом на <tex>1</tex> вправо: <tex>F(s) + s \cdot F(s) = (f_0 + f_1 s + f_2 s^2 + f_3 s^3 + \dots) + (0 + f_0 s + f_1 s^2 + f_2 s^3 + \dots) = (f_0 + 0) + (f_1 + f_0) s + (f_2 + f_1) s^2 + (f_3 + f_2) s^3 + \dots = f_1 + f_2 s + f_3 s^2 + f_4 s^3 + \dots</tex>. Заметим, что результат равен сдвигу <tex>F(s)</tex> на <tex>1</tex> влево. Составим и решим уравнение: <tex>F(s) + s \cdot F(s) = \dfrac{F(s) - 1}{s}</tex>; <tex>F(s)(s^2 + s - 1) = -1</tex>; <tex>F(s) = \dfrac{1}{1 - s - s^2}</tex>.

==См. также==
* [[Производящая функция]]
* [[Производящие функции нескольких переменных]]
* [[Разложение рациональной функции в ряд]]

==Источники информации==
* ''Ландо С. К.'', Лекции о производящих функциях. {{---}} 3-е изд., испр. {{---}} М.: МЦНМО, 2007. {{---}} 144с. ISBN 978-5-94057-042-4

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Производящая функция Дирихле

2018-02-24T19:38:31Z

188.227.78.184: /* Обратимость */

{{Определение
|definition=
'''Производящая функция Дирихле''' (англ. ''Dirichlet generating functions'') последовательности <tex>\{a_n\}_{n=1}^{\infty}</tex> — это формальный ряд вида:
<center>
<tex>A(s)= \frac{a_1}{1^s} + \frac{a_2}{2^s} + \frac{a_3}{3^s} + \dots = \sum\limits_{n=1}^\infty \frac{a_n}{n^s}</tex>,
</center>
}}

== Примечание ==
* Нумерация коэффициентов производящих функций Дирихле начинается с единицы, а не с нуля, как это было в случае обыкновенных производящих функций.
* Вместо переменной <tex>x</tex> используется <tex>s</tex>. Это изменение связано больше с традициями, чем с математикой.
* Принято писать <tex> \frac{a_n}{n^s} </tex> вместо <tex> {a_n}{n^{-s}} </tex>. Это считается более удобной формой.

== Примеры ==

Самой известной среди производящих функций Дирихле является дзета-функция Римана
{{Определение
|definition=
'''Дзета-функция Римана ''' (англ. ''The Riemann zeta function'') — производящая функция Дирихле, отвечающая последовательности <tex> \{a_n\}_{n=1}^{\infty} </tex>, состоящей из единиц:<center>
<tex>\zeta (s)={\frac {1}{1^{s}}}+{\frac {1}{2^{s}}}+{\frac {1}{3^{s}}}+\ldots ,</tex>
</center>

}}

Таблица содержит известные производящие функции. Первая из них — это дзета-функция Римана, состоящая из единиц. <tex>[\zeta(s)]^2</tex> является последовательностью количества делителей числа. <tex>\mu(n)</tex> — последовательность Мҷбиуса (англ. Möbius). <tex>H(n)</tex> — последоватльность факторизаций числа. <tex>\phi(n)</tex> — функция Эйлера. <tex>\lambda(s)</tex> — лямбда функция Дирихле.
{| class="wikitable" style="width:20cm" border=1

|-align="center" bgcolor=#EEEEFF
| '''<tex>f(s)</tex>''' || '''Последоватльность''' || '''<tex>{a_n}</tex>'''

|-align="left" bgcolor=#FFFFFF
| <tex>\zeta(s)</tex> || <tex>1</tex> || <tex>1, 1, 1, 1, 1, 1, 1, 1, \dots</tex>

|-align="left" bgcolor=#FFFFFF
| <tex>1/\zeta(s)</tex> || <tex>\mu(n)</tex> || <tex>1, -1, -1, 0, -1, 1, -1, 0, \dots</tex>

|-align="left" bgcolor=#FFFFFF
| <tex>[\zeta(s)]^2</tex> || <tex>d(n)</tex> || <tex>1, 2, 2, 3, 2, 4, 2, 4, \dots</tex>

|-align="left" bgcolor=#FFFFFF
| <tex>\zeta(s)\zeta(s-k)</tex> || <tex>\sigma_k(n)</tex> ||

|-align="left" bgcolor=#FFFFFF
| <tex>\zeta(s-1)/\zeta(s)</tex> || <tex>\phi(n)</tex> || <tex>1, 1, 2, 2, 4, 2, 6, 4, \dots</tex>

|-align="left" bgcolor=#FFFFFF
| <tex>1/[2-\zeta(s)]</tex> || <tex>H(n)</tex> || <tex>1, 1, 1, 2, 1, 3, 1, 4, \dots</tex>

|-align="left" bgcolor=#FFFFFF
| <tex>\lambda(s)</tex> || <tex>1/2[1-(-1)^n]</tex> || <tex>1, 0, 1, 0, 1, 0, 1, 0, \dots</tex>

|-align="left" bgcolor=#FFFFFF
| <tex>(\zeta(s)\zeta(s-1))/(\zeta(2s))</tex> || <tex>\psi(n)</tex> || <tex>1, 3, 4, 6, 6, 12, 8, 12, \dots</tex>
|}
== Операции ==

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

=== Умножение ===

Если <tex>A(s)</tex> и <tex>B(s)</tex> — произодящие функции Дирихле двух последовательностей <tex>\{a_n\}_{n=1}^\infty</tex> и <tex>\{b_n\}_{n=1}^\infty</tex> соответсвенно, то <tex>A(s)B(s) = \frac{a_1b_1}{1^s} + \frac{a_1b_2 + a_2b_1}{2^s} + \frac{a_1b_3 + a_3b_1}{3^s} + \frac{a_1b_4 + a_2b_2 + a_4b_1}{4^s} + \dots = \sum\limits_{n} \frac{\sum\limits_{kl=n} {a_kb_l}}{n^s}</tex>, где внутренние суммирование ведется по всем разложением числа <tex>n</tex> в произведение двух сомножителей. Таким образом, использование производящих функций Дирихле позволяет контролировать мультипликативную структуру натуральных чисел.
=== Сложение ===

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

=== Единица ===

Роль единицы при умножении производящих функций Дирихле играет функция <tex>1 = 1 ^ {-s}</tex>.

=== Обратимость ===

Любая производящая функция Дирихле <tex>A(s)</tex> с ненулевым свободным членом, <tex>a_1 \neq 0</tex>, обратима: для нее существует функция <tex>B(s)</tex>, такая что <tex>A(s)B(s) = 1</tex>

Attention!
Можно привести доказательство теоремы об обратной функции для дзета-функции Римана 

== Источники информации ==
* [http://files.school-collection.edu.ru/dlrstore/d62ef84c-a780-11dc-945c-d34917fee0be/47_lando_lekcii_o_proizvodyashih_foo.pdf С.К.Ландо, Леции о производящих функциях, 2007 год]
* [http://mathworld.wolfram.com/DirichletGeneratingFunction.html Dirichlet Generating Function]
* [https://mathlesstraveled.com/2017/01/30/dirichlet-generating-functions/ Dirichlet generating functions]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Алгоритм Эдмондса-Карпа

2018-02-17T18:02:24Z

188.227.78.184: /* Источники информации */

== Алгоритм ==

Алгоритм Эдмондса-Карпа является реализацией метода [[Алгоритм Форда-Фалкерсона для поиска максимального паросочетания|Форда-Фалкерсона]], в которой в качестве дополняющего пути выбирается [[Обход в ширину |кратчайший по рёбрам путь]] в остаточной сети (длины всех рёбер равны <tex>1</tex>).

=== Описание ===

# Положим все потоки равными нулю. Остаточная сеть изначально совпадает с исходной сетью.
# В остаточной сети находим кратчайший путь из источника в сток. Если такого пути нет, останавливаемся.
# Пускаем через найденный путь (он называется '''увеличивающим путём''' или '''увеличивающей цепью''') максимально возможный поток:
## На найденном пути в остаточной сети ищем ребро с минимальной пропускной способностью <tex>\mathrm{c_{min}}</tex>.
## Для каждого ребра на найденном пути увеличиваем поток на <tex>\mathrm{c_{min}}</tex>, а в противоположном ему — уменьшаем на <tex>\mathrm{c_{min}}</tex>.
## Модифицируем остаточную сеть. Для всех рёбер на найденном пути, а также для противоположных им рёбер, вычисляем новую пропускную способность. Если она стала ненулевой, добавляем ребро к остаточной сети, а если обнулилась, стираем его.
# Возвращаемся на шаг 2.

===Сложность===
Сложность алгоритма Эдмондса-Карпа равна <tex>O(VE^2)</tex>.

== Псевдокод ==

'''function''' EdmondsKarp(G, s, t):
'''for''' (для) каждого ребра <tex>(u,v) \in E[G]</tex>
<tex>f[u,v] \leftarrow 0</tex>
<tex>f[v,u] \leftarrow 0</tex>
'''while''' существует ''кратчайший'' путь <tex>p</tex> из <tex>s</tex> в <tex>t</tex> в остаточной сети <tex>G_f</tex>
<tex>c_f(p) \leftarrow min\{c_f(u,v) : (u,v) \in p\}</tex>
'''for''' <tex>(u,v) \in p</tex>
<tex>f[u,v] \leftarrow f[u,v] + c_f(p)</tex>
<tex>f[v,u] \leftarrow -f[u,v]</tex>

== Корректность алгоритма Эдмондса-Карпа ==

На каждой итерации цикла <tex>\mathrm {while}</tex> поток в графе <tex>G</tex> увеличивается вдоль одного из кратчайших путей в <tex>G_f</tex> из истока <tex>s</tex> в сток <tex>t</tex>. Этот процесс повторяется до тех пор пока существует кратчайший <tex>s \leadsto t</tex> путь в <tex>G_f</tex>. Если в <tex>G_f</tex> не существует кратчайшего пути из <tex>s</tex> в <tex>t</tex>, значит, не существует вообще никакого <tex>s \leadsto t</tex> пути в <tex>G_f</tex> следовательно по [[Теорема Форда-Фалкерсона|теореме Форда-Фалкерсона]] найденный поток <tex>f</tex> максимальный.

== Оценка быстродействия ==

{{Лемма
|id=lemma1
|statement=
Если в сети <tex>G(V,E)</tex> с истоком <tex>s</tex> и стоком <tex>t</tex> увеличение потока производится вдоль кратчайших <tex>s \leadsto t</tex> путей в <tex>G_f</tex>, то для всех вершин <tex>v \in V\backslash\{s,t\}</tex> длина кратчайшего пути <tex>\delta_f(s, v)</tex> в остаточной сети <tex>G_f</tex> не убывает после каждого увеличения потока.
|proof=
Предположим противное, пусть существует вершина <tex>v \in V \backslash\{s,t\}</tex>, что после какого-то увеличения потока длина кратчайшего пути из <tex>s</tex> в <tex>v</tex> уменьшилась. Обозначим потоки до и после увеличения соответственно за <tex>f</tex> и <tex>f'</tex>. Пусть <tex>v</tex> {{---}} вершина, расстояние <tex>\delta'_f(s,v)</tex> от <tex>s</tex> до которой минимально и уменьшилось с увеличением потока. Имеем <tex>\delta'_f(s,v) < \delta_f(s,v)</tex>. Рассмотрим путь <tex>p = s \leadsto u \rightarrow v</tex>, являющийся кратчайшим от <tex>s</tex> к <tex>v</tex> в <tex>G'_f</tex>. Тогда верно, что <tex>\delta'_f(s, u) = \delta'_f(s,v) - 1</tex>.

По выбору <tex>v</tex> и из предыдущего утверждения получаем, что <tex>\delta'_f (s, u) \geqslant\delta_f(s,u)</tex>.

Предположим <tex>(u, v) \in E_f</tex>, тогда <tex>\delta_f(s,v) \leqslant \delta_f(s, u) + 1 \leqslant \delta'_f(s,u) + 1 = \delta'_f(s, v)</tex>. Это противоречит <tex>\delta'_f(s,v) < \delta_f(s,v)</tex>.

Пусть <tex>(u,v) \notin E_f</tex>, но известно, что <tex>(u,v) \in E_f'</tex>. Появление ребра <tex>(u,v)</tex> после увеличения потока означает увеличение потока по обратному ребру <tex>(v, u)</tex>. Увеличение потока производится вдоль кратчайшего пути, поэтому кратчайший путь из <tex>s</tex> в <tex>u</tex> вдоль которого происходило увеличения выглядит как <tex>s \leadsto v \rightarrow u</tex>, из чего получаем <tex>\delta_f(s, v) = \delta_f(s, u) - 1 \leqslant \delta'_f(s, u) - 1 = \delta'(s, v) - 2</tex>. Данное утверждение противоречит <tex>\delta'_f(s,v) < \delta_f(s,v)</tex>. Итак мы пришли к противоречию с существованием вершины <tex>v</tex>, кратчайшее расстояние до которой уменьшилось с увеличением потока.
}}

Опираясь на предшествующую лемму, докажем следующую теорему, которая ограничивает сверху число итераций цикла <tex>\mathrm {while}</tex> в алгоритме Эдмондса-Карпа.

{{Теорема
|statement=Пусть для некоторой сети <tex>G(V,E)</tex> с источником <tex>s</tex> и стоком <tex>t</tex> выполняется алгоритм Эдмондса-Карпа, тогда общее число итераций цикла <tex>\mathrm {while}</tex> составляет <tex>O(V E)</tex>.
|proof=
Рассмотрим множество рёбер <tex>(u,v)</tex> остаточной сети <tex>G_f</tex>, принадлежащих увеличивающему пути <tex>p</tex>, таких что <tex>c_f(p) = c_f(u,v)</tex>. Назовем данные рёбра критическими. Покажем, что каждое из <tex>|E|</tex> рёбер может становиться критическим не более, чем <tex>|V| - 1</tex> раз. Заметим, что после увеличения потока вдоль пути <tex>p</tex> все критические рёбра исчезают из остаточной сети, кроме того по определению остаточной пропускной способности пути хотя бы одно ребро увеличивающего пути {{---}} критическое.

Рассмотрим две вершины <tex>u</tex> и <tex>v</tex> принадлежащие <tex>V</tex>, соединенные некоторым ребром из <tex>E</tex>. Увеличение производится вдоль кратчайших путей, поэтому если ребро <tex>(u,v)</tex> становиться критическим в первый раз, верно, что <tex>\delta_f(s,v) = \delta_f(s,u) + 1</tex>. После увеличения потока ребро <tex>(u, v)</tex> исчезает из сети. Оно не появится в другом увеличивающем пути до тех, пор пока не будет уменьшено по обратному ребру <tex>(v, u)</tex>. Это может произойти только в том случае, если ребро <tex>(v, u)</tex> встретится на некотором увеличивающем пути. Пусть в момент перед увеличением поток в сети <tex>G</tex> составлял <tex>f'</tex>, то поскольку увеличение производиться вдоль кратчайших путей, верно: <tex>\delta'_f(s,u) = \delta'_f(s, v) + 1</tex>. Согласно [[#lemma1|лемме]] <tex>\delta_f(s,v) \leqslant \delta'_f(s,v)</tex>, откуда <tex>\delta'_f(s,u) = \delta'(s,v) + 1 \geqslant \delta_f(s,v) + 1 = \delta_f(s,u) + 2</tex>.

Итак в промежуток времени между тем, когда ребро <tex>(u,v)</tex> становится критическим в первый раз, до момента, когда оно становится критическим в следующий раз, расстояние от <tex>s</tex> до <tex>u</tex> увеличивается минимум на <tex>2</tex>. Расстояние <tex>\delta(s,u)</tex> в начальный момент времени больше либо равно <tex>0</tex>. Среди промежуточных вершин на кратчайшем пути <tex>s \leadsto u</tex> не могут находиться <tex>s</tex>, <tex>u</tex> или <tex>t</tex>. Следовательно к тому моменту, когда вершина <tex>u</tex> станет недостижимой из источника расстояние до нее не превысит <tex>|V| - 2</tex>. Получаем, что ребро <tex>(u, v)</tex> могло стать критическим не более <tex>\dfrac{(|V| -2)}{2} = \dfrac{|V|}{2} - 1</tex> раз. Поскольку в графе не более <tex>O(E)</tex> пар вершин, между которыми могут существовать рёбра в остаточной сети, то общее количество критических рёбер в ходе выполнения алгоритма Эдмондса-Карпа равно <tex>O(V E)</tex>.

Так как каждый увеличивающий путь содержит по крайней мере одно критическое ребро, следовательно число кратчайших путей составляет <tex>O(V E)</tex>. На каждой итерации цикла <tex>\mathrm {while}</tex> рассматривается ровно один увеличивающий путь, а поскольку в случае отсутствия такого пути выполнение цикла прерывается, то число итераций цикла <tex>\mathrm {while}</tex> также составляет <tex>O(V E)</tex>.
}}

Если увеличивающий путь находить поиском в ширину, то каждую итерацию цикла <tex>\mathrm {while}</tex> можно выполнить за время <tex>O(E)</tex>. Инициализация в процедуре '''Edmonds Karp''' производится за <tex>O(E)</tex>, следовательно время работы алгоритма алгоритма Эдмондса-Карпа составляет <tex>O(V E^2)</tex>.

== Пример графа на котором алгоритм дает плохую асимптотику ==
[[Файл:MaxFlowWorstCase.png|365px|thumb|right|«Грибок». Схема построения "сложного" для алгоритма Эдмондса-Карпа графа]]

Заметим также, что существует ''сеть грибок''<ref>[https://www.topcoder.com/community/data-science/data-science-tutorials/maximum-flow-augmenting-path-algorithms-comparison/#! Cтатья на TopCoder.com ]</ref> на которой нижняя граница времени работы алгоритмы Эдмондса-Карпа также составляет <tex>\Omega(V E^2)</tex>. Рассмотрим этот случай более подробно. Норман Заде (англ. ''Norman Zadeh'') описал примеры, которые позволяют добиться асимптотики <tex>\Omega(V^3)</tex><ref>Norman Zadeh. Theoretical Efficiency of the Edmonds-Karp Algorithm for Computing Maximal Flows.</ref>. В нашем примере алгоритм выполнит <tex>\Omega(V^3)</tex> улучшений пути вне зависимости от выбора этого пути.
Разделим все вершины (за исключением <tex>s</tex> и <tex>t</tex>) на подмножества:
*<tex>S={s_1,\ldots,s_k}</tex> — множество вершин, в которые входят рёбра из <tex>s</tex> с пропускной способностью <tex>k</tex>,
*<tex>T={t_1,\ldots,t_k}</tex> — множество вершин, из которых исходят рёбра в <tex>t</tex> с пропускной способностью <tex>k</tex>,
*<tex>U={u_1,\ldots,u_{2p}}</tex> — множество вершин, достижимых из <tex>s</tex> по рёбрам с бесконечной пропускной способностью (не используя иные рёбра),
*<tex>V={v_1,\ldots,v_{2p}}</tex> — множество вершин, из которых можно достигнуть <tex>t</tex> по рёбрам с бесконечной пропускной способностью (не используя иные рёбра).

<tex>S</tex> и <tex>T</tex> содержат <tex>k</tex> вершин, <tex>U</tex> и <tex>V</tex> содержат <tex>2p</tex> вершин. Где <tex>k</tex> и <tex>p</tex> фиксированные целые числа. Каждое ребро, выделенное жирным(см. рисунок, соединяют множества <tex>S</tex> и <tex>T</tex>), имеет единичную пропускную способность; пунктирные рёбра имеют бесконечную пропускную способность; остальные рёбра(в форме дуги) имеют пропускную способность <tex>k</tex>.
В начале работы алгоритма путь увеличиться <tex>k^2</tex> раз по пути (<tex>s</tex>, <tex>S</tex>, <tex>T</tex>, <tex>t</tex>), длина которого равна трем. После этого остаточная сеть будет содержать обратные рёбра из <tex>T</tex> в <tex>S</tex>, и алгоритм выберет еще <tex>k^2</tex> путей <tex>(s, u_1, u_2, T, S, v_2, v_1, t)</tex> длины <tex>7</tex>, затем путь <tex>(s, u_1, u_2, u_3, u_4, S, T, v_4, v_3, v_2, v_1, t)</tex> длины <tex>11</tex> и так далее.
:Число вершин в сети: <tex>n = 2\cdot k + 4\cdot p + 2</tex>.
:Число рёбер: <tex> m = k^2 + 2\cdot p\cdot k + 2\cdot k + 4\cdot p</tex>.

Нетрудно заметить, что число удлиняющих путей <tex> a = k^2\cdot (p+1)</tex>.
Возьмем <tex>p</tex> равным <tex>k - 1</tex>. В этом случае <tex>n = 6 \cdot k - 2</tex> и <tex>a = k^3</tex>. Заде приводит более хитрые примеры с такой же асимптотикой, но они зависят от выбора пути.

[[Файл:InGraph.png|600px|thumb|left| Изначальный граф, нулевой поток]]
[[Файл:SecondStage.png|600px|center|thumb| Граф после <tex>k^2</tex> поисков пути(в нашем случае <tex>k^2 = 4</tex>). Рёбра из между множествами <tex>S</tex> и <tex>T</tex> полностью насыщены. Поток равен четырем]]
[[Файл:ThirdStageEdmunds karp.png|600px|thumb|left| Алгоритм нашел путь через рёбра бесконечной вместимости, совершив еще <tex>k^2 = 4</tex> шагов. Поток равен восьми]]

==Примечания==

<references />

== Источники информации ==
* ''Кормен, Томас Х., Лейзерсон, Чарльз И., Ривест, Рональд Л., Штайн Клиффорд'' '''Алгоритмы: построение и анализ''', 2-е издание. Пер. с англ. — М.:Издательский дом "Вильямс", 2010. — 1296 с.: ил. — Парал. тит. англ. — ISBN 978-5-8459-0857-5 (рус.)
*[https://ru.wikipedia.org/wiki/Алгоритм_Эдмондса_—_Карпа Википедия: Алгоритм Эдмондса-Карпа]
* [https://en.wikipedia.org/wiki/Edmonds–Karp_algorithm Википедия: Алгоритм Эдмондса-Карпа (англ.)]
*[https://www.topcoder.com/community/data-science/data-science-tutorials/maximum-flow-augmenting-path-algorithms-comparison/#! Статья на TopCoder.com]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о максимальном потоке]]

Задача о динамической связности

2018-02-17T07:51:56Z

188.227.78.184: /* Обобщение задачи для произвольных графов */

{{Задача
|definition = Есть [[Основные_определения:_граф,_ребро,_вершина,_степень,_петля,_путь,_цикл#Неориентированные_графы|неориентированный граф]] из <tex>n</tex> вершин, изначально не содержащий рёбер. Требуется обработать <tex>m</tex> запросов трёх типов:
* <tex>\mathrm{add(u,v)}</tex> {{---}} добавить ребро между вершинами <tex>u</tex> и <tex>v</tex>;
* <tex>\mathrm{remove(u,v)}</tex> {{---}} удалить ребро между вершинами <tex>u</tex> и <tex>v</tex>;
* <tex>\mathrm{connected(u,v)}</tex> {{---}} проверить, лежат ли вершины <tex>u</tex> и <tex>v</tex> в одной компоненте связности.
}}
== Динамическая связность в лесах ==
Если задача такова, что в графе нет и не может быть циклов, то она сводится к задаче о связности в [[Деревья Эйлерова обхода|деревьях эйлерова обхода]]. Время работы каждого запроса для упрощённой задачи {{---}} <tex>O(\log n)</tex>, где <tex>n</tex> {{---}} количество вершин в графе.

== Обобщение задачи для произвольных графов ==

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

[[Файл:Graph.jpg|530px|thumb|left|Граф]] [[Файл:Spanforest.jpg|530px|thumb|right|Остовный лес в графе]]

===Проверка связности===
Граф и его остовный лес {{---}} одно и то же с точки зрения связности. Поэтому проверка связности в графе сводится к проверке связности в остовном лесе и решается за <tex>O(\log n)</tex>.

===Добавление ребра===
Чтобы разобраться с тем, как изменится граф и остовный лес при добавлении и удалении ребра, введём функцию <tex>l(e):E{\rightarrow}[0;\log n]</tex> и назовём её ''уровнем ребра'' <tex>e</tex>. Уровни ребра можно распределить любым способом, но для всех <tex> i </tex> должно выполняться следующее свойство: размер каждой компоненты связности <tex>G_i</tex> не превосходит <tex>\dfrac{n}{2^i}</tex>. Здесь графы <tex>G_i</tex> определяются так: <tex>G_i=\langle V, E\rangle: \{e \in E \mid l(e) \geqslant i\}</tex>.

Очевидно, что <tex>G_{\log n} \subseteq G_{\log n-1} \subseteq \ldots \subseteq G_1 \subseteq G_0 = G</tex>. Выделим в графах остовные леса таким образом, что <tex>F_{\log n} \subseteq F_{\log n-1} \subseteq \ldots \subseteq F_1 \subseteq F_0</tex>, где <tex>F_i</tex> {{---}} остовный лес графа <tex>G_i</tex>.

Удобнее всего новому ребру давать уровень <tex>0</tex>. В этом случае изменится только <tex>G_0</tex>, так как в остальные подграфы <tex>G_i</tex> рёбра нулевого уровня не входят. После вставки нового ребра нам нужно проверить, были ли вершины <tex>u</tex> и <tex>v</tex> в одной компоненте связности до того, как мы вставили ребро. Если они лежали в разных компонентах, то необходимо новое ребро добавить и в остовный лес <tex>F_0</tex>.

====Псевдокод====

'''function''' <tex>\mathrm{add}</tex>('''Node''' u, '''Node''' v):
'''Edge''' e = <tex>\langle </tex>u, v<tex>\rangle</tex>
e.level = 0
<tex>G_0</tex> = <tex>G_0</tex> <tex>\cup</tex> e
'''if not''' <tex>\mathrm{connected(u,v)}</tex>
<tex>F_0</tex> = <tex>F_0</tex> <tex>\cup</tex> e

===Удаление ребра===
{{Утверждение
|statement=Если ребро, которое мы хотим удалить, не принадлежит остовному лесу, то связность между любой парой вершин сохранится.
|proof=Докажем от противного. Допустим, что это не так. Понятно, что при разрезании ребра нового пути между вершинами не появится.
Предположим, что нарушилась связность для каких-то двух вершин. Значит, мы убрали мост. А любой мост принадлежит всем остовным деревьям его компоненты. Противоречие.
}}
[[Файл:Is_there_xy.jpg|200px|thumb|right|Компонента связности T.]]

Таким образом, если мы удалили ребро не из остовного леса, то нам не придётся перестраивать лес и пересчитывать значение <tex>\mathrm{connected(u,v)}</tex>.

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

Проверим, является ли ребро мостом. У ребра <tex>uv</tex> известен уровень, пусть он равен <tex>i</tex>. Попробуем найти другое ребро (<tex>xy</tex>), соединяющее поддеревья <tex>T_u</tex> и <tex>T_v</tex>, на которые распалось остовное дерево исследуемой компоненты <tex>T</tex>.

{{Утверждение
|statement=Если ребро <tex>xy</tex> существует, то его уровень не больше <tex>i</tex>.
|proof=От противного. Пусть <tex>l(xy)=j</tex>, где <tex>j > i</tex>. Тогда вершины <tex>x</tex> и <tex>y</tex> каким-то образом связаны в <tex>F_j</tex> (либо непосредственно ребром <tex>xy</tex>, либо каким-то другим путём). Но <tex>F_j \subseteq F_i</tex>. Значит, в <tex>F_i</tex> между <tex>x</tex> и <tex>y</tex> сохранился путь из рёбер уровня не меньше <tex>j</tex> и появился другой путь через <tex>uv</tex>. Приходим к противоречию, так как в <tex>F_i</tex> все компоненты должны быть деревьями.
}}

Чтобы найти <tex>xy</tex>, выберем из поддеревьев <tex>T_u</tex> и <tex>T_v</tex> наименьшее. Не умаляя общности, будем считать, что <tex>|T_u|\leqslant|T_v|</tex>.  Так как всегда из двух слагаемых можно выбрать одно такое, что оно не превосходит половины их суммы, имеем важное свойство: <tex>|T_u|\leqslant\dfrac{|T_u|+|T_v|}{2}=\dfrac{|T|}{2}</tex>. Также нам известно, что <tex>T \subseteq F_i</tex>, а значит, <tex>|T|\leqslant\dfrac{n}{2^i}</tex>. Отсюда <tex>|T_u|\leqslant\dfrac{n}{2^{i+1}}</tex>. Это неравенство позволит нам увеличивать уровни рёбер при необходимости.

Будем искать ребро <tex>xy</tex> следующим образом:
# Выбираем любое ребро уровня <tex>i</tex>, выходящее из вершины, принадлежащей <tex>T_u</tex>.
# Если выбранное ребро ведёт в <tex>T_v</tex>, выходим из цикла и добавляем ребро <tex>xy</tex> в остовные леса <tex>F_i</tex>, для которых <tex>i\leqslant l(xy)</tex> и выходим из цикла;
# Если выбранное ребро ведёт в другую вершину поддерева <tex>T_u</tex>, увеличиваем его уровень на <tex>1</tex>;
# Если есть непроверенные рёбра на интересующем нас уровне <tex>i</tex>, переходим к пункту <tex>1</tex>;
# Если таких рёбер уровня <tex>i</tex> не осталось и <tex>i>0</tex>, рассматриваем уровень на единицу меньший и переходим к пункту <tex>1</tex>;
# Если все рёбра просканированы и <tex>i=0</tex>, то <tex>uv</tex> является мостом.

'''Замечание.''' Увеличив уровень ребра на единицу, нужно не забыть обновить <tex>G_{i+1}</tex> и <tex>F_{i+1}</tex>.
====Оценка времени работы====
Пункт <tex>2</tex> работает за <tex>O(\log^2 n)</tex>, так как после выхода из цикла мы добавляем ребро за <tex>O(\log n)</tex> на каждом уровне, а количество уровней не больше <tex>\log n</tex>.


Пусть до момента, когда мы нашли нужное ребро, мы сделали <tex>S</tex> неудачных сканирований. После каждого такого сканирования нам приходится добавлять новые рёбра в <tex>G_{i+1}</tex>, что стоит <tex>O(\log n)</tex>. Получаем сложность удаления одного ребра <tex>O(\log^2{n}+S\cdot\log n)</tex>. 

Выразим сложность одной операции <tex>\mathrm{remove}</tex> другим способом. Для <tex>n</tex> вершин и <tex>m</tex> вызовов процедуры сложность равна <tex>O(\log^2{n}\cdot m+\log n\cdot\displaystyle \sum_{i=1}^m S_i)</tex>, что не превосходит <tex>O(\log^2{n} \cdot m+\log n\cdot\log n\cdot m)</tex>, так как уровень ребра <tex>m</tex> раз рос максимум до <tex>\log n</tex>. Отсюда суммарная сложность всех запросов равна <tex>O(\log^2{n}\cdot m)</tex>, а для одного запроса мы решаем задачу за <tex>O(\log^2{n})</tex>.

====Псевдокод====

'''function''' <tex>\mathrm{remove}</tex>('''Node''' u, '''Node''' v):
'''Edge''' e = <tex>\langle </tex>u, v<tex>\rangle</tex>
'''for''' i = e.level '''downto''' 0
<tex>G_i</tex> = <tex>G_i\setminus</tex>e
<tex>F_i</tex> = <tex>F_i\setminus</tex>e
'''Edge''' e2
'''for''' e2 = <tex>\langle </tex>x, y<tex>\rangle</tex> : e2.level == i '''and''' x <tex>\in T_u</tex>
'''if''' y <tex>\in T_v</tex>
'''for''' j = i '''downto''' 0
<tex>F_j</tex> = <tex>F_j</tex> <tex>\cup</tex> e2
'''return'''
'''else'''
e2.level++
<tex>G_{i+1}</tex> = <tex>G_{i+1}</tex> <tex>\cup</tex> e2

== См. также ==
* [[Деревья Эйлерова обхода|Деревья эйлерова обхода]]
* [[Задача о динамической связности оффлайн]]

== Источники информации ==
* [https://en.wikipedia.org/wiki/Dynamic_connectivity Dynamic connectivity {{---}} Википедия]
* [http://numeralis.ru/algoritmyi-i-strukturyi-dannyih-poiska-dinamicheskaya-svyaznost-v-grafah-babenko-maksim/ Лекции {{---}} Академия Яндекса]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Связность в графах]]

Задача о динамической связности

2018-02-17T07:50:44Z

188.227.78.184: /* Обобщение задачи для произвольных графов */

Лямбда-исчисление

2018-01-29T01:50:03Z

188.227.78.184: /* β-редукция */

{{nohate}}
'''Лямбда-исчисление''' (''англ. lambda calculus'') {{---}} формальная система, придуманная в 1930-х годах
Алонзо Чёрчем. Лямбда-функция является, по сути, анонимной функцией.
Эта концепция показала себя удобной и сейчас активно используется во многих
языках программирования.

== Лямбда-исчисление==
{{Определение
|definition=
'''Лямбда-выражением''' (англ. <tex>\lambda</tex>''-term'') называется выражение, удовлетворяющее следующей грамматике: 
<tex>
\Lambda \to V\\
\Lambda \to \Lambda \ \Lambda\\
\Lambda \to \lambda V . \Lambda
</tex>
где <tex>V</tex> {{---}} множество всех строк над фиксированным алфавитом <tex> \Sigma \setminus \{ "\lambda", "\ ",\ "."\} </tex>.
}}
Пробел во втором правиле является терминалом грамматики. Иногда его обозначают как @, чтобы он не сливался с другими символами в выражении.

В первом случае функция является просто переменной.
Во втором происходит ''аппликация'' (''применение'') одной функции к другой.
Это аналогично вычислению функции-левого операнда на аргументе-правом операнде.
В третьем {{---}} ''абстракция'' по переменной. В данном случае происходит
создание функции одного аргумента с заданными именем аргумента и телом функции.

Рассмотрим, например, <tex>\lambda</tex>-терм <tex>\operatorname{id} = \lambda x\ .\ x</tex>. Эта функция принимает аргумент и
возвращает его неизменённым. Например,
<tex>\operatorname{id}\ 2 \equiv 2</tex>. Аналогично, <tex>\operatorname{id}\ y \equiv y</tex>.

Еще примеры:
:<tex>
x\\
(x\ z)\\
(\lambda x.(x\ z))\\
(\lambda z.(\lambda w.((\lambda y.((\lambda x.(x\ z))\ y))\ w)))\\
</tex>

Иногда <tex>\lambda</tex> -термы пишут по другому. Для краткости подряд идущие лямбды заменяют на одну. Например:
:<tex>\lambda x\ .\ \lambda y\ .P\ \to\ \lambda xy.P</tex>

===Приоритет операций===
* Аппликация: <tex>x\ y\ z\ w \equiv ((x\ y)\ z)\ w</tex>
* Абстракция забирает себе всё, до чего дотянется: <tex>\lambda x\ .\ \lambda y\ .\ \lambda z\ .\ z\ y\ x \equiv \lambda x\ .\ (\lambda y\ .\ (\lambda z\ .\ ((z\ y)\ x)))</tex>
* Скобки играют привычную роль группировки действий

===Свободные и связанные переменные===
''Связанными'' переменными называются все переменные, по которым выше в
дереве разбора были абстракции. Все остальные переменные называются свободными.

Например, в <tex>\lambda x\ .\ y\ x</tex>, <tex>x</tex> и связана, а <tex>y</tex>{{---}} свободна. А в <tex>\lambda y\ .\ x\ (\lambda x\ .\ x)</tex>
в своём первом вхождении переменная <tex>x</tex> свободна, а во втором {{---}} связана.

Связанные переменные {{---}} это аргументы функции. То есть для функции они являются локальными.

Рассмотрим функции <tex>\lambda y\ .\ y</tex> и <tex>\lambda x\ .\ y</tex>. В первой из них при взгляде на <tex>y</tex>
понятно, что она имеет отношение к переменной, по которой производилась
абстракция. Если по одной и той же
переменной абстракция производилась более одного раза, то переменная связана
с самым поздним (самым нижним в дереве разбора) абстрагированием. Например, в
<tex>\lambda x\ .\ \lambda x\ .\ \lambda y\ .\ \lambda x\ .\ x</tex>, переменная <tex>x</tex> связана с самой правой абстракцией
по <tex>x</tex>.

===α-эквивалетность===

{{Определение
|definition='''<tex>\alpha</tex>-эквивалетностью''' (англ. ''<tex>\alpha</tex> -equivalence'') {{---}} называется наименьшее соотношение эквивалентности на <tex>\Lambda</tex> такое что:
:<tex>P=_\alpha P</tex> для любого <tex>P</tex>
:<tex>\lambda x.P=_\alpha \lambda y.P[x:=y]</tex> если <tex>y \not\in FV(P)</tex>
и замкнуто относительно следующих правил:
:<tex> P=_\alpha P' \Rightarrow \forall x \in V: \lambda x.P=_\alpha \lambda x.P'\\
P=_\alpha P' \Rightarrow \forall Z \in \Lambda : P Z =_\alpha P'Z\\
P=_\alpha P' \Rightarrow \forall Z \in \Lambda : Z P =_\alpha Z P'\\
P=_\alpha P' \Rightarrow P'=_\alpha P\\
P=_\alpha P' \ \& \ P'=_\alpha P'' \Rightarrow P=_\alpha P''\\</tex>
}}

Функции <tex>\lambda x\ .\ \lambda y\ .\ x\ y\ z</tex> и <tex>\lambda a\ .\ \lambda x\ .\ a\ x\ z</tex> являются <tex>\alpha</tex>-эквивалентными,
а <tex>\lambda x\ .\ \lambda y\ .\ y\ z</tex> и <tex>\lambda y\ .\ \lambda x\ .\ y\ z</tex> {{---}} нет.

===β-редукция===

{{Определение
|definition=
'''<tex>\beta</tex>-редукция''' (англ. ''<tex>\beta</tex> -reduction'') {{---}} это наименьшее соотношение на <tex>\Lambda</tex> такое что
:<tex>(\lambda x.P)Q\to _\beta P[x:=Q]</tex>
и замкнуто относительно следующих правил
:<tex>P\to _\beta P' \Rightarrow \forall x\in V:\lambda x.P\to _\beta \lambda x.P'\\
P\to _\beta P' \Rightarrow \forall Z\in \Lambda : P\ Z\to _\beta P'\ Z\\
P\to _\beta P' \Rightarrow \forall Z\in \Lambda : Z\ P\to _\beta Z\ P'</tex>
}}

{{Определение
|definition=
Через <tex>f \to_\beta g</tex> обозначают сведение <tex>f</tex> к <tex>g</tex> с помощью одной <tex>\beta</tex>-редукции.
А через <tex>f \to_\beta^* g</tex> {{---}} за ноль или более.
}}

В <tex>\beta</tex>-редукции вполне возможна функция вида <tex>\lambda x. \lambda x.x</tex>. Во время подстановки вместо <tex>x</tex> внутренняя переменная не заменяется - действует принцип локальной переменной. Но принято считать, что таких ситуаций не возникает и все переменные называются разными именами.

===Каррирование===

{{Определение
|definition=
'''Каррирование''' (англ. ''carrying'') {{---}} преобразование функции от многих переменных в функцию, берущую свои аргументы по одному. Для функции <tex>h</tex> типа <tex>h\ :\ (A\ *\ B)\ \to\ C</tex> оператор каррирования <tex>\Lambda </tex> выполняет преобразование <tex>\Lambda (h)\ :\ A\to (B\to C)</tex>. Таким образом <tex>\Lambda (h)</tex> берет аргумент типа <tex>A</tex> и возвращает функцию типа <tex>B\ \to\ C</tex>. С интуитивной точки зрения, каррирование функции позволяет фиксировать ее некоторый аргумент, возвращая функцию от остальных аргументов. Таким образом, <tex>\Lambda</tex> представляет собой функцию типа <tex>\Lambda :\ (A\ *\ B\to C)\to (A\to (B\to C))</tex>.
}}

==Нотация Де Брауна==
Существует также альтернативное эквивалентное определение <tex>\lambda</tex>-исчисления.
В оригинальном определении для обозначения переменных использовались имена,
и была проблема с тем, что не были запрещены одинаковые имена в разных
абстракциях.

От этой проблемы можно избавиться следующим образом. Вместо имени переменной
будет храниться натуральное число {{---}} количество абстракций в дереве разбора,
на которое нужно подняться, чтобы найти ту лямбду, с которой данная переменная
связана. В данной нотации получаются несколько более простые определения
свободных переменных и <tex>\beta</tex>-редукции.

Грамматику нотации можно задать как:
:<tex>e\ ::= n\ |\ \lambda .e\ |\ e\ e</tex>

Примеры выражений в этой нотации:
:<tex>
\begin{tabular}{cc}
Standart & de Bruijn \\
$\lambda x.x$ & $\lambda .0$ \\
$\lambda z.z$ & $\lambda .0$ \\
$\lambda x. \lambda y.x$ & $\lambda . \lambda .1$\\
$\lambda x. \lambda y. \lambda s. \lambda z.x\ s\ (y\ s\ z)$ & $\lambda . \lambda . \lambda . \lambda .3\ 1(2\ 1\ 0)$\\
$(\lambda x.x\ x)(\lambda x.x\ x)$ & $(\lambda .0\ 0)(\lambda .0\ 0)$\\
$(\lambda x. \lambda x.x)(\lambda y.y)$ & $(\lambda .\lambda .0)(\lambda .0)$\\
\end{tabular}
</tex>

Переменная называется свободной, если ей соответствует число, которое больше
количества абстракций на пути до неё в дереве разбора.

При <tex>\beta</tex>-редукции же нужно будет ко всем свободным переменным заменяющего
дерева при каждой замене прибавить число, равное разницы уровней раньше и сейчас.
Это будет соответствовать тому, что эта переменная продолжит «держаться» за
ту же лямбду, что и раньше.

==Нумералы Чёрча и программирование на <tex>\lambda</tex>-исчислении==

===Определение===
Введём на основе лямбда-исчисления аналог натуральных чисел, основанный на идее,
что натуральное число {{---}} это или ноль, или увеличенное на единицу натуральное
число.

:<tex>\bar 0 = \lambda s\ .\ \lambda z\ .\ z</tex>
:<tex>\bar 1 = \lambda s\ .\ \lambda z\ .\ s\ z</tex>
:<tex>\bar 2 = \lambda s\ .\ \lambda z\ .\ s\ (s\ z)</tex>
:<tex>\bar 3 = \lambda s\ .\ \lambda z\ .\ s\ (s\ (s\ z))</tex>

Каждое число будет функцией двух аргументов: какой-то функции и начального значения.
Число <tex>n</tex> будет <tex>n</tex> раз применять функцию к начальному значению и возвращать
результат. Если такому "числу" дать на вход функцию <tex>(+1)</tex> и <tex>0</tex> в качестве
начального значения, то на выходе как раз будет ожидаемое от функции число:
<tex>\bar 3\ (+1)\ 0 \equiv 3</tex>.

===+1===
Функция, прибавляющая 1 к числу, должна принимать первым аргументом число.
Но число {{---}} функция двух аргументов. Значит, эта функция должна принимать три
аргумента: "число" <tex>n</tex>, которое хочется увеличить, функция, которую надо будет
<tex>n+1</tex> раз применить, и начальное значение.

<tex>\operatorname{succ} = \lambda n\ .\ \lambda s\ .\ \lambda z\ .\ s\ (n\ s\ z)</tex>

Здесь <tex>n\ s\ z</tex> {{---}} <tex>n</tex> раз применённая к <tex>z</tex> функция <tex>s</tex>. Но нужно применить <tex>n+1</tex>
раз. Отсюда <tex>s\ (n\ s\ z)</tex>.

===Сложение===
Сложение двух чисел похоже на прибавление единицы. Но только надо прибавить не единицу, а второе число.

<tex>\operatorname{plus} = \lambda n\ .\ \lambda m\ .\ \lambda s\ .\ \lambda z\ .\ n\ s\ (m\ s\ z)</tex>

<tex>n</tex> раз применить <tex>s</tex> к применённому <tex>m</tex> раз <tex>s</tex> к <tex>z</tex>

<tex>(\operatorname{plus}\ \bar 3\ \bar 3)\ (+1)\ 0 \equiv 6</tex>

<tex>(\operatorname{plus}\ ((\operatorname{plus}\ 2\ 5)(+1)\ 0)\ 4)(+1)0 \equiv 11</tex>

===Умножение===
Умножение похоже на сложение, но прибавлять надо не единицу, а второе число.
Или, в терминах нумералов Чёрча, в качестве применяемой несколько раз
функции должна быть не <tex>s</tex>, а функция, применяющая <tex>n</tex> раз <tex>s</tex>.

<tex>\operatorname{mult} = \lambda n\ .\ \lambda m\ .\ \lambda s\ .\ \lambda z\ .\ n\ (m\ s)\ z</tex>

Здесь <tex>m\ s</tex> {{---}} функция, которая <tex>m</tex> раз применит <tex>s</tex> к тому, что дадут ей на
вход. С помощью <tex>\eta</tex>-редукции можно немного сократить эту формулу

<tex>\operatorname{mult} = \lambda n\ .\ \lambda m\ .\ \lambda s\ .\ n\ (m\ s)</tex>

<tex>(\operatorname{mult} \bar 3\ \bar 3)\ (+1)\ 0 \equiv 9</tex>

===Возведение в степень===
It's a kind of magic

<tex>\operatorname{power} = \lambda n\ .\ \lambda m\ .\ \lambda s\ .\ \lambda z\ .\ m\ n\ s\ z</tex>

<tex>(\operatorname{power}\ \bar 3\ (\operatorname{succ}\ \bar 3))\ (+1)\ 0 \equiv 81</tex>

===Логические значения===
<tex>\operatorname{true} = \lambda a\ .\ \lambda b\ .\ a</tex>

<tex>\operatorname{false} = \lambda a\ .\ \lambda b\ .\ b</tex>

Функции двух аргументов, возвращающие первый и второй, соответственное, аргументы.
Забавный факт: <tex>\operatorname{false} \equiv_\alpha \operatorname{zero}</tex>. Эти функции сделаны такими для того,
чтобы красиво написать функцию <tex>\operatorname{if}</tex>:

<tex>\operatorname{if} = \lambda p\ .\ \lambda t\ .\ \lambda e\ .\ p\ t\ e</tex>

Если ей в качестве первого аргумента дадут <tex>\operatorname{true}</tex>, то вернётся <tex>t</tex>, иначе {{---}} <tex>e</tex>.

Стандартные функции булевой логики:

<tex>\operatorname{and} = \lambda n\ .\ \lambda m\ .\ \operatorname{if}\ n\ m\ \operatorname{false}</tex>

<tex>\operatorname{or} = \lambda n\ .\ \lambda m\ .\ \operatorname{if}\ n\ \operatorname{true} \ m</tex>

<tex>\operatorname{not} = \lambda b\ .\ \operatorname{if}\ b\ \operatorname{false} \ \operatorname{true}</tex>

Ещё одной важной функцией является функция проверки, является ли число нулём:

<tex>\operatorname{isZero} = \lambda n\ .\ n\ (\lambda c\ .\ \operatorname{false})\ \operatorname{true}</tex>

Функция выглядит несколько странно. <tex>\lambda c \to \operatorname{false}</tex> - функция, которая независимо
от того, что ей дали на вход, возвращает <tex>\operatorname{false}</tex>. Тогда, если в качестве <tex>n</tex>
будет дан ноль, то функция, по определению нуля, не выполнится ни разу, и будет
возвращено значение по умолчанию <tex>\operatorname{true}</tex>. Иначе же функция будет запущено, и
вернётся <tex>\operatorname{false}</tex>.

===Пара===

<tex>\operatorname{pair} = \lambda a\ .\ \lambda b\ .\ \lambda t\ .\ t\ a\ b</tex>

<tex>\operatorname{fst} = \lambda p\ .\ p\ \operatorname{true}</tex>

<tex>\operatorname{snd} = \lambda p\ .\ p\ \operatorname{false}</tex>

Функция <tex>\operatorname{pair}</tex> принимает два значения и запаковывает их в пару так, чтобы к ним можно было обращаться по <tex>\operatorname{fst}</tex> и <tex>\operatorname{snd}</tex>. В <tex>\operatorname{fst}</tex> и <tex>\operatorname{snd}</tex> вместо <tex>t</tex> в <tex>\operatorname{pair}</tex> будет подставлено <tex>\operatorname{true}</tex> или <tex>\operatorname{false}</tex>, возвращающие, соответственно, первый и второй аргументы, то есть <tex>a</tex> или <tex>b</tex>, соответственно.

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

<tex>\operatorname{minus} = \lambda n\ .\ \lambda m\ .\ m\ \operatorname{pred} n</tex>

Это то же самое, что <tex>m</tex> раз вычесть единицу из <tex>n</tex>.

Осталось, собственно, функция для вычитания единицы. Однако, это не так просто, как может показаться на первый взгляд. Проблема в том, что, имея функцию, которую нужно применить для того, чтобы продвинуться вперёд, продвинуться назад будет проблематично. Если попробовать воспользоваться идеей о том, чтобы, начав от нуля, идти вперёд, и пройти на один шаг меньше, то будет не очень понятно, как же остановиться ровно за один шаг до конца. Для реализации вычитания единицы сделаем следующее. <tex>n</tex> раз выполним следующее: имея пару <tex>\langle n-1, n-2\rangle</tex> построим пару <tex>\langle n, n-1\rangle</tex>. Тогда после <tex>n</tex> шагов во втором элементе пары будет записано число <tex>n-1</tex>, которое и хочется получить.

<tex>\operatorname{pred} = \lambda n\ .\ \lambda s\ .\ \lambda z.\ \operatorname{snd}\ (
n\ (
\lambda p\ .\ \operatorname{pair}\ (s\ (\operatorname{fst} p))\ (\operatorname{fst} p)
)\ (\operatorname{pair}\ z\ z))</tex>

Если вы ничего не поняли, не огорчайтесь. Вычитание придумал Клини, когда ему вырывали зуб мудрости. А сейчас наркоз уже не тот.

===Сравнение===
Так как вычитание определено таким способом, чтобы для случая, в котором уменьшаемое больше, чем вычитаемое, возвращать ноль, можно определить сравнение на больше-меньше через него. Равными же числа <tex>a</tex> и <tex>b</tex> считаются, если <tex>a - b = 0 \wedge b - a = 0</tex>.

<tex>\operatorname{le} = \lambda n\ .\ \lambda m\ .\ \operatorname{isZero}\ (\operatorname{minus}\ n\ m)</tex>

<tex>\operatorname{less} = \lambda n\ .\ \lambda m\ .\ \operatorname{le}\ n\ (\operatorname{pred} m)</tex>

<tex>\operatorname{eq} = \lambda n\ .\ \lambda m\ .\ \operatorname{and}\ (\operatorname{isZero}\ (\operatorname{minus}\ n\ m))\
(\operatorname{isZero}\ (\operatorname{minus}\ m\ n))</tex>

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

<tex>\operatorname{fact} = \lambda x\ .\ \operatorname{if}\ (\operatorname{isZero}\ x)\ \bar 1\ (\operatorname{fact}\ (\operatorname{pred}\ x))</tex>

Мы столкнулись с проблемой. В определении функции <tex>\operatorname{fact}</tex> используется функция <tex>\operatorname{fact}</tex>. При формальной замене, получим бесконечную функцию. Можно попытаться решить эту проблему следующим образом

<tex>\operatorname{fact} = (\lambda f\ .\ \lambda x\ .\ \operatorname{if}\ (\operatorname{isZero}\ x)\ \bar 1\ (f\ (\operatorname{pred}\ x)))\ \operatorname{fact}</tex>

{{Определение
|definition=''Неподвижной точкой'' лямбда-функции <tex>f</tex> назовём такую функцию <tex>x</tex>, что
<tex>f\ x \to_\beta^* x</tex>.
}}

Лямбда исчисление обладаем замечательным свойством: у каждой функции есть неподвижная точка!

Рассмотрим следующую функцию.

<tex>\operatorname{fix} = \lambda f\ .\ (\lambda x\ .\ f\ (x\ x))\ (\lambda x\ .\ f\ (x\ x))</tex>

Заметим, что <tex>\operatorname{fix} \to_\beta^* \lambda f\ .\ f\ ((\lambda x\ .\ f\ (x\ x))\ (\lambda x\ .\ f\ (x\ x)))</tex>.
Или, что то же самое,
<tex>\lambda f\ .\ (\lambda x\ .\ f\ (x\ x))\ (\lambda x\ .\ f\ (x\ x)) \to_\beta^*</tex>
<tex>\lambda f\ .\ f\ ((\lambda x\ .\ f\ (x\ x))\ (\lambda x\ .\ f\ (x\ x)))</tex>

Рассмотрим функцию

<tex>\operatorname{fact'} = \lambda f\ .\ \lambda x\ .\ \operatorname{if}\ (\operatorname{isZero}\ x)\ \bar 1\ (\operatorname{mult}\ x\ (f\ (\operatorname{pred}\ x)))</tex>

Как было показано выше, <tex>\operatorname{fix} f \to_\beta^* f\ (\operatorname{fix} f)</tex>, то есть, <tex>\operatorname{fix}\ \operatorname{fact'} \to_\beta^* \operatorname{fact}</tex>, где <tex>\operatorname{fact}</tex> {{---}} искомая функция, считающая факториал.

<tex>\operatorname{fact} = \operatorname{fix}\ \operatorname{fact'}</tex>

Это даст функцию, которая посчитает факториал числа. Но делать она это будет мееедленно-меееедленно. Для того, чтобы посчитать <tex>5!</tex> потребовалось сделать 66066 <tex>\beta</tex>-редукций.

Наиболее известным комбинатором неподвижной точки является <tex>Y</tex>-комбинатор, введенный известным американским ученым Хаскеллом Карри как
:<tex>Y\ = \ \lambda f.(\lambda x.f(x\ x))\ (\lambda x.f(x\ x))</tex>

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

<tex>\operatorname{div'} = \lambda div\ .\ \lambda n\ .\ \lambda m\ .\ \operatorname{if}\ (\operatorname{less}\ n\ m)\ \bar 0\ (\operatorname{succ}\ (div\ (\operatorname{minus}\ n\ m)\ m))</tex>

<tex>\operatorname{div} = \operatorname{fix}\ \operatorname{div'}</tex>

И остатка от деления

<tex>\operatorname{mod'} = \lambda mod\ .\ \lambda n\ .\ \lambda m\ .\ \operatorname{if}\ (\operatorname{less}\ n\ m)\ n\ (mod\ (\operatorname{minus}\ n\ m)\ m)</tex>

<tex>\operatorname{mod} = \operatorname{fix}\ \operatorname{mod'}</tex>

===Проверка на простоту===

<tex>\operatorname{isPrimeHelp}</tex> {{---}} принимает число, которое требуется проверить на простоту и то, на что его надо опытаться поделить, перебирая это от 2 до <tex>p-1</tex>. Если на что-нибудь разделилось, то число {{---}} составное, иначе {{---}} простое.

<tex>\operatorname{isPrimeHelp'} =</tex><tex>\lambda f\ .\ \lambda p\ .\ \lambda i\ .\ \operatorname{if}\ (\operatorname{le}\ p\ i)\ \operatorname{true}\ (\operatorname{if}\ (\operatorname{isZero}\ (\operatorname{mod}\ p\ i))\ \operatorname{false}\ (f\ p\ (\operatorname{succ}\ i)))</tex>

<tex>\operatorname{isPrimeHelp} = \operatorname{fix}\ \operatorname{isPrimeHelp'}</tex>

<tex>\operatorname{isPrime} = \lambda p\ .\ \operatorname{isPrimeHelp}\ p\ \bar 2</tex>

Следующее простое число. <tex>\operatorname{nextPrime'}</tex> {{---}} следующее, больше либо равное заданного, <tex>\operatorname{nextPrime}</tex> {{---}} следующее, большее заданного.

<tex>\operatorname{nextPrime''} = \lambda f\ .\ \lambda p\ .\ \operatorname{if}\ (\operatorname{isPrime}\ p)\ p\ (f\ (\operatorname{succ}\ p)) </tex>

<tex>\operatorname{nextPrime'} = \operatorname{fix}\ \operatorname{nextPrime'}</tex>

<tex>\operatorname{nextPrime} = \lambda p\ .\ \operatorname{nextPrime'}\ (\operatorname{succ}\ p)</tex>

<tex>\operatorname{ithPrimeStep}</tex> пропрыгает <tex>i</tex> простых чисел вперёд. <tex>\operatorname{ithPrime}</tex> принимает число <tex>i</tex> и пропрыгивает столько простых чисел вперёд, начиная с двойки.

<tex>\operatorname{ithPrimeStep'} = \lambda f\ .\ \lambda p\ .\ \lambda i\ .\ \operatorname{if}\ (\operatorname{isZero}\ i)\ p\ (f\ (\operatorname{nextPrime}\ p)\ (\operatorname{pred}\ i))</tex>

<tex>\operatorname{ithPrimeStep} = \operatorname{fix}\ \operatorname{ithPrimeStep'}</tex>

<tex>\operatorname{ithPrime} = \lambda i\ .\ \operatorname{ithPrimeStep}\ \bar 2\ i</tex>

...и всего через 314007 <tex>\beta</tex>-редукций вы узнаете, что третье простое число {{---}} семь!

===Списки===

Для работы со списками чисел нам понадобятся следующие функции:
* <tex>\operatorname{empty}</tex> {{---}} возвращает пустой список
* <tex>\operatorname{cons}</tex> {{---}} принимает первый элемент и оставшийся список, склеивает их
* <tex>\operatorname{head}</tex> {{---}} вернуть голову списка
* <tex>\operatorname{tail}</tex> {{---}} вернуть хвост списка

Список будем хранить в следующем виде: <tex>\langle len, p_1^{a_1}p_2^{a_2}\ldots p_{len}^{a_{len}} \rangle</tex>. При этом, голова списка будет храниться как показатель степени при <tex>p_{len}</tex>.

<tex>\operatorname{empty} = \operatorname{pair}\ \operatorname{zero}\ \bar 1</tex>

<tex>\operatorname{cons} = \lambda h\ .\ \lambda t\ .\ \operatorname{pair}\ (\operatorname{succ}\ (\operatorname{fst}\ t))\ (\operatorname{mult}\ (\operatorname{snd}\ t)\ (\operatorname{power}\ (\operatorname{ithPrime}\ (\operatorname{fst}\ t))\ h))</tex>

<tex>\operatorname{head} = \lambda list\ .\ \operatorname{getExponent}\ (\operatorname{snd}\ list)\ (\operatorname{ithPrime}\ (\operatorname{pred}\ (\operatorname{fst}\ list)))</tex>

<tex>\operatorname{tail} = \lambda list\ .\ \operatorname{pair}\ (\operatorname{pred}\ (\operatorname{fst}\ list))
(\operatorname{eliminateMultiplier}\ (\operatorname{snd}\ list)\ (\operatorname{ithPrime}\ (\operatorname{pred}\ (\operatorname{fst}\ list))))</tex>

<tex>\operatorname{eliminateMultiplier'} =</tex><tex> \lambda f\ .\ \lambda n\ .\ \lambda m\ .\ \operatorname{if}\ (\operatorname{isZero}\ (\operatorname{mod}\ n\ m))\ (f\ (\operatorname{div}\ n\ m)\ m)\ n</tex>

<tex>\operatorname{eliminateMultiplier} = \operatorname{fix}\ \operatorname{eliminateMultiplier'}</tex>

<tex>\operatorname{getExponent'} =</tex><tex> \lambda f\ .\ \lambda n\ .\ \lambda m\ .\ \operatorname{if}\ (\operatorname{isZero}\ (\operatorname{mod}\ n\ m))\ (\operatorname{succ}\ (f\ (\operatorname{div}\ n\ m)\ m))\ \bar 0</tex>

<tex>\operatorname{getExponent} = \operatorname{fix}\ \operatorname{getExponent'}</tex>

==Выводы==

На основе этого всего уже можно реализовать эмулятор машины тьюринга: с помощью пар, списков чисел можно хранить состояния. С помощью рекурсии можно обрабатывать переходы. Входная строка будет даваться, например, закодированной аналогично списку: пара из длины и числа, характеризующего список степенями простых. Я бы продолжил это писать, но уже на операции <tex>\operatorname{head} [1, 2]</tex> я не дождался окончания выполнения. Скорость лямбда-исчисления как вычислителя печальна.

==Примеры (слабонервным не смотреть)==

====fact====
<tex>(\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda x.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> (x))</tex><tex> (\lambda s.\lambda z.s z)</tex><tex> ((\lambda n.\lambda m.\lambda s.n (m s))</tex><tex> (x)</tex><tex> (f ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex>((\lambda a.\lambda b.\lambda t.t a b)</tex><tex>(z)</tex><tex> z))) (x)))))</tex>
====head====
<tex>\lambda list.(\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda n.\lambda m.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda mod.\lambda n.\lambda m.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.\lambda m.(\lambda n.\lambda m.(\lambda n.n(\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m)) (n)</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) (m)))</tex><tex> (n)</tex><tex> m) n (mod ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m) m)) n m)) ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (f ((\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda div.\lambda n.\lambda m.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.\lambda m.(\lambda n.\lambda m.(\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m)) (n)</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) (m)))</tex><tex> (n)</tex><tex> m) (\lambda s.\lambda z.z)</tex><tex> ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (div ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m) m))) n m) m)) (\lambda s.\lambda z.z))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (list))</tex><tex> ((\lambda i.(\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda p.\lambda i.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> (i))</tex><tex> p (f ((\lambda p.(\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda p.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda p.(\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda p.\lambda i.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.\lambda m.(\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m)) (p)</tex><tex> i) (\lambda a.\lambda b.a)</tex><tex> ((\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda mod.\lambda n.\lambda m.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.\lambda m.(\lambda n.\lambda m.(\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m)) (n)</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) (m)))</tex><tex> (n)</tex><tex> m) n (mod ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m) m)) p i)) (\lambda a.\lambda b.b)</tex><tex> (f p ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (i)))))</tex><tex> p (\lambda s.\lambda z.s (s z)))</tex><tex> (p))</tex><tex> p (f ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (p))))</tex><tex> ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (p)))</tex><tex> (p))</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) (i))))</tex><tex> (\lambda s.\lambda z.s (s z))</tex><tex> i) ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (list))))</tex>

====tail====
<tex>\lambda list.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (list)))</tex><tex> ((\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda n.\lambda m.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda mod.\lambda n.\lambda m.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.\lambda m.(\lambda n.\lambda m.(\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m)) (n)</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) (m)))</tex><tex> (n)</tex><tex> m) n (mod ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m) m)) n m)) (f ((\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda div.\lambda n.\lambda m.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.\lambda m.(\lambda n.\lambda m.(\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m)) (n)</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) (m)))</tex><tex> (n)</tex><tex> m) (\lambda s.\lambda z.z)</tex><tex> ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (div ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m) m))) n m) m) n) ((\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (list))</tex><tex> ((\lambda i.(\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda p.\lambda i.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> (i))</tex><tex> p (f ((\lambda p.(\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda p.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda p.(\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda f.\lambda p.\lambda i.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.\lambda m.(\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m)) (p)</tex><tex> i) (\lambda a.\lambda b.a)</tex><tex> ((\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda f.(\lambda x.f (x x))</tex><tex> (\lambda x.f (x x)))</tex><tex> (\lambda mod.\lambda n.\lambda m.(\lambda p.\lambda t.\lambda e.p t e)</tex><tex> ((\lambda n.\lambda m.(\lambda n.\lambda m.(\lambda n.n (\lambda c.\lambda a.\lambda b.b)</tex><tex> (\lambda a.\lambda b.a))</tex><tex> ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m)) (n)</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) (m)))</tex><tex> (n)</tex><tex> m) n (mod ((\lambda n.\lambda m.m (\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) n) (n)</tex><tex> m) m)) p i)) (\lambda a.\lambda b.b)</tex><tex> (f p ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (i)))))</tex><tex> p (\lambda s.\lambda z.s (s z)))</tex><tex> (p))</tex><tex> p (f ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (p))))</tex><tex> ((\lambda n.\lambda s.\lambda z.s (n s z))</tex><tex> (p)))</tex><tex> (p))</tex><tex> ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) (i))))</tex><tex> (\lambda s.\lambda z.s (s z))</tex><tex> i) ((\lambda n.\lambda s.\lambda z.(\lambda p.p (\lambda a.\lambda b.b))</tex><tex> (n (\lambda p.(\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (s ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (p)))</tex><tex> ((\lambda a.\lambda b.\lambda t.t a b)</tex><tex> (z)</tex><tex> z))) ((\lambda p.p (\lambda a.\lambda b.a))</tex><tex> (list)))))</tex>

== См. также ==
*[[Неразрешимость задачи вывода типов в языке с зависимыми типами]]

==Источники информации==
* Lectures on the Curry Howard - Isomorphism
*[https://github.com/shd/tt2014 Д. Штукенберг. Лекции]
*[http://en.wikipedia.org/wiki/Lambda-calculus Английская Википедия]
*[http://ru.wikipedia.org/wiki/%D0%9B%D1%8F%D0%BC%D0%B1%D0%B4%D0%B0-%D0%B8%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5 Русская Википедия]
*[http://worrydream.com/AlligatorEggs Игра про крокодилов]

[[Категория: Теория формальных языков]]
[[Категория: Теория вычислимости]]

Задача об устойчивом паросочетании

2017-12-31T05:50:38Z

188.227.78.184: /* Анализ полученного алгоритмом паросочетания */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины незамужние.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m ещё не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

Время работы алгоритма {{---}} <tex>O(n^2)</tex>, так как количество итераций цикла <tex>\mathrm {while}</tex> не превосходит <tex>O(n^2)</tex>.

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда и некоторая женщина (<tex>a</tex>) незамужняя. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина незамужняя. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>. То есть для <tex>c</tex> есть мужчина, который более привлекателен, чем её муж.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются наименее привлекательными с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, то это будет означать, что она на самом деле осталась без пары.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача об устойчивом паросочетании

2017-12-30T13:57:05Z

188.227.78.184: /* Обобщения задачи */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины незамужние.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m ещё не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

Время работы алгоритма {{---}} <tex>O(n^2)</tex>, так как количество итераций цикла <tex>\mathrm {while}</tex> не превосходит <tex>O(n^2)</tex>.

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда и некоторая женщина (<tex>a</tex>) незамужняя. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина незамужняя. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются наименее привлекательными с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, то это будет означать, что она на самом деле осталась без пары.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача об устойчивом паросочетании

2017-12-30T13:54:57Z

188.227.78.184: /* Доказательство корректности */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины незамужние.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m ещё не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

Время работы алгоритма {{---}} <tex>O(n^2)</tex>, так как количество итераций цикла <tex>\mathrm {while}</tex> не превосходит <tex>O(n^2)</tex>.

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда и некоторая женщина (<tex>a</tex>) незамужняя. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина незамужняя. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача о динамической связности

2017-12-26T21:26:36Z

188.227.78.184: /* Реализация на C++ */

Задача о динамической связности

2017-12-26T21:20:09Z

188.227.78.184:

Задача о динамической связности

2017-12-26T20:48:29Z

188.227.78.184: /* Замечания */

{{Задача
|definition = Имеется [[Основные_определения:_граф,_ребро,_вершина,_степень,_петля,_путь,_цикл#Неориентированные_графы|неориентированный граф]] из <tex>n</tex> вершин, изначально не содержащий рёбер. Требуется обработать <tex>m</tex> запросов трёх типов:
* добавить ребро между вершинами <tex>u</tex> и <tex>v</tex>,
* удалить ребро между вершинами <tex>u</tex> и <tex>v</tex>,
* проверить, лежат ли вершины <tex>u</tex> и <tex>v</tex> в одной компоненте связности.
В графе могут быть кратные рёбра и петли.
}}
погодь

== Решение упрощённой задачи ==
Если нет удалений рёбер, задачу можно решить при помощи [[СНМ (реализация с помощью леса корневых деревьев)|системы непересекающихся множеств]]. Каждая компонента связности {{---}} одно множество в СНМ, и при добавлении рёбер они объединяются.

Время работы такого решения: <tex>O(m \cdot \alpha (n))</tex>, где <tex>\alpha</tex> {{---}} [[СНМ (реализация с помощью леса корневых деревьев)#Функция Аккермана|обратная функция Аккермана]].

== Алгоритм ==
=== Построение дерева отрезков ===
Рассмотрим массив запросов. Каждое ребро в графе существует на некотором отрезке запросов: начиная с запроса добавления и заканчивая запросом удаления (либо концом запросов, если ребро не было удалено). Для каждого ребра можно найти этот отрезок, пройдя по массиву запросов и запоминая, когда какое ребро было добавлено.

Пусть есть <tex>k</tex> рёбер, <tex>i</tex>-е соединяет вершины <tex>v_i</tex> и <tex>u_i</tex>, было добавлено запросом <tex>L_i</tex> и удалено запросом <tex>R_i</tex>.

Построим на массиве запросов [[Дерево отрезков. Построение|дерево отрезков]], в каждой его вершине будем хранить список пар. <tex>i</tex>-е рёбро графа нужно добавить на отрезок <tex>[L_i,R_i]</tex>. Это делается аналогично тому, как в дереве отрезков происходит добавление на отрезке (процесс описан в статье "[[Несогласованные поддеревья. Реализация массового обновления]]"), но без <tex>push</tex>: нужно спуститься по дереву от корня и записать пару <tex>u_i,v_i</tex> в вершины дерева отрезков.

Теперь чтобы узнать, какие рёбра существуют во время выполнения <tex>i</tex>-го запроса, достаточно посмотреть на путь от корня дерева отрезков до листа, который соответствует этому запросу {{---}} рёбра, записанные в вершинах этого пути, существуют во время выполнения запроса.

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

Для поддержания такого графа и ответа на запросы будем использовать [[СНМ (реализация с помощью леса корневых деревьев)|систему непересекающихся множеств]]. При добавлении рёбер в граф объединим соответствующие множества в СНМ. Откатывание состояния СНМ описано ниже.

=== СНМ с откатами ===
Для того, чтобы иметь возможность откатывать состояние СНМ, нужно при каждом изменении любого значения в СНМ записывать в специальный массив, что именно изменилось и какое было предыдущее значение. Это можно реализовать как массив пар (указатель, значение).

Чтобы откатить состояние СНМ, пройдём по этому массиву в обратном порядке и присвоим старые значения обратно. Для лучшего понимания ознакомьтесь с приведённой ниже реализацией.

Нужно заметить, что эвристику сжатия путей в этом случае применять не следует. Эта эвристика улучшает асимптотическое время работы, но это время работы не истинное, а амортизированное. Из-за наличия откатов к предыдущим состояниям эта эвристика не даст выигрыша. СНМ с ранговой эвристикой же работает за <tex>O(\log n)</tex> на запрос истинно.

Запоминание изменений и откаты не влияют на время работы, если оно истинное, а не амортизированное. Действительно: пусть в СНМ произошло <tex>r</tex> изменений. Каждое из них будет один раз занесено в массив и один раз отменено. Значит, запись в массив и откаты работают за <tex>\Theta(r)</tex>. Но и сами изменения заняли <tex>\Theta(r)</tex> времени, значит, откаты не увеличили асимптотическое время работы.

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

== Время работы ==
Каждое из <tex>O(m)</tex> рёбер записывается в <tex>O(\log m)</tex> вершин дерева отрезков. Поэтому операций <tex>\mathrm{union}</tex> в СНМ будет <tex>O(m \log m)</tex>. Каждая выполняется за <tex>O(\log n)</tex> (СНМ с ранговой эвристикой). Откаты не влияют на время работы.

Можно считать, что <tex>n = O(\log m)</tex>, так как в запросах используется не более <tex>2m</tex> вершин.

Время работы: <tex>O(m \log m \log n) = O(m \log^2 m)</tex>.

== Реализация на C++ ==
'''#include''' <bits/stdc++.h>

'''using''' '''namespace''' std;
'''typedef''' pair < '''int''' , '''int''' > ipair;
'''const''' '''int''' N = 100321;

// СНМ
'''int''' dsuP[N], dsuR[N];
// В этот массив записываются все изменения СНМ, чтобы их можно откатить
// При изменении какого-то значения в СНМ в hist записывается пара < указатель, старое значение >
vector < pair < '''int'''*, '''int''' > > hist;

// Для элемента из СНМ возвращает корень дерева, в котором он находится
'''int''' dsuRoot('''int''' v)
{
'''while''' (dsuP[v] != -1)
v = dsuP[v];
'''return''' v;
}

// Объединяет два множества. Используется ранговая эвристика.
// При любом изменении содержимого массивов dsuP и dsuR
// в hist записывается адрес и старое значение
'''void''' dsuMerge('''int''' a, '''int''' b)
{
a = dsuRoot(a);
b = dsuRoot(b);
'''if''' (a == b)
'''return''';
'''if''' (dsuR[a] > dsuR[b])
{
hist.emplace_back(&dsuP[b], dsuP[b]);
dsuP[b] = a;
} '''else''' '''if''' (dsuR[a] < dsuR[b])
{
hist.emplace_back(&dsuP[a], dsuP[a]);
dsuP[a] = b;
} '''else'''
{
hist.emplace_back(&dsuP[a], dsuP[a]);
hist.emplace_back(&dsuR[b], dsuR[b]);
dsuP[a] = b;
++dsuR[b];
}
}

'''struct''' Query
{
'''int''' t, u, v;
bool answer;
};
'''int''' n, m;
Query q[N];

// Дерево отрезков, в каждой вершине которого хранится список рёбер
vector < ipair > t[N*4];

// Эта функция добавляет ребро на отрезок
// [l r] - отрезок, на который добавляется ребро
// uv - ребро, c - текущая вершина дерева отрезков,
// [cl cr] - отрезок текущей вершины дерева отрезков
'''void''' addEdge('''int''' l, '''int''' r, ipair uv, '''int''' c, '''int''' cl, '''int''' cr)
{
'''if''' (l > cr || r < cl)
'''return''';
'''if''' (l <= cl && cr <= r)
{
t[c].push_back(uv);
'''return''';
}
'''int''' mid = (cl + cr) / 2;
addEdge(l, r, uv, c*2+1, cl, mid);
addEdge(l, r, uv, c*2+2, mid+1, cr);
}

// Обход дерева отрезков в глубину
'''void''' go('''int''' c, '''int''' cl, '''int''' cr)
{
'''int''' startSize = hist.size();
// Добавляем рёбра при входе в вершину
'''for''' (ipair uv : t[c])
dsuMerge(uv.first, uv.second);

'''if''' (cl == cr)
{
// Если эта вершина - лист, то отвечаем на запрос
'''if''' (q[cl].t == 3)
q[cl].answer = (dsuRoot(q[cl].u) == dsuRoot(q[cl].v));
} '''else''' {
'''int''' mid = (cl + cr) / 2;
go(c*2+1, cl, mid);
go(c*2+2, mid+1, cr);
}

// Откатываем изменения СНМ
'''while''' (('''int''')hist.size() > startSize)
{
*hist.back().first = hist.back().second;
hist.pop_back();
}
}

'''int''' main()
{
ios::sync_with_stdio('''false''');
// Формат входных данных:
// n и m, затем в m строках запросы: по три числа t, u, v
// t - тип (1 - добавить ребро, 2 - удалить, 3 - принадлежат ли одной компоненте)
// Нумерация вершин с нуля
cin >> n >> m;
'''for''' ('''int''' i = 0; i < n; ++i) // Инициализация СНМ
dsuP[i] = -1;

// В этом массиве для каждого ещё не удалённого ребра хранится
// на каком запросе оно было создано
set < pair < ipair, '''int''' > > edges;
'''for''' ('''int''' i = 0; i < m; ++i)
{
cin >> q[i].t >> q[i].u >> q[i].v;
// Поскольку рёбра неориентированные, u v должно означать то же самое, что и v u
'''if''' (q[i].u > q[i].v) swap(q[i].u, q[i].v);
// При добавлении ребра кладём его в set
'''if''' (q[i].t == 1)
edges.emplace(ipair(q[i].u, q[i].v), i);
// При удалении ребра берём из set время его добавления - так мы узнаём отрезок заросов,
// на котором оно существует. Если есть несколько одинаковых рёбер, можно брать любое.
'''else''' '''if''' (q[i].t == 2)
{
'''auto''' iter = edges.lower_bound(make_pair(ipair(q[i].u, q[i].v), 0));
addEdge(iter->second, i, iter->first, 0, 0, m - 1);
edges.erase(iter);
}
}
// Обрабатываем рёбра, которые не были удалены
'''for''' ('''auto''' e : edges)
addEdge(e.second, m - 1, e.first, 0, 0, m - 1);

// Запускаем dfs по дереву отрезков
go(0, 0, m - 1);
// Выводим ответ.
// При обходе дерева отрезков запросы обрабатываются в том же порядке, в котором они даны,
// поэтому ответ можно выводить прямо в go без заполнения answer
'''for''' ('''int''' i = 0; i < m; ++i)
'''if''' (q[i].t == 3)
{
'''if''' (q[i].answer)
cout << "YES\n";
'''else'''
cout << "NO\n";
}

'''return''' 0;
}

== См. также ==
* [[СНМ (реализация с помощью леса корневых деревьев)|Система непересекающихся множеств]]
* [[Дерево отрезков. Построение|Дерево отрезков]]
* [[Задача о динамической связности оффлайн]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Связность в графах]]

Задача об устойчивом паросочетании

2017-12-26T15:59:36Z

188.227.78.184: /* Доказательство корректности */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины незамужние.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m ещё не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

Время работы алгоритма {{---}} <tex>O(n^2)</tex>, так как количество итераций цикла <tex>\mathrm {while}</tex> не превосходит <tex>O(n^2)</tex>.

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда некоторая женщина (<tex>a</tex>) не замужем. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина незамужняя. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача об устойчивом паросочетании

2017-12-26T15:01:34Z

188.227.78.184: /* Доказательство корректности */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины незамужние.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m ещё не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

Время работы алгоритма {{---}} <tex>O(n^2)</tex>, так как количество итераций цикла <tex>\mathrm {while}</tex> не превосходит <tex>O(n^2)</tex>.

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда некоторая женщина (<tex>a</tex>) не замужем. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина не замужем. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача об устойчивом паросочетании

2017-12-26T15:00:18Z

188.227.78.184: /* Описание в псевдокоде */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины незамужние.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m ещё не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

Время работы алгоритма {{---}} <tex>O(n^2)</tex>, так как количество итераций цикла <tex>\mathrm {while}</tex> не превосходит <tex>O(n^2)</tex>.

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда некоторая женщина (<tex>a</tex>) не замужем. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина не замужем. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача об устойчивом паросочетании

2017-12-26T14:51:18Z

188.227.78.184: /* Асимптотика алгоритма */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины незамужние.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m ещё не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда некоторая женщина (<tex>a</tex>) не замужем. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина не замужем. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача о динамической связности

2017-12-25T21:01:35Z

188.227.78.184: new article

{{Задача
|definition = Имеется [[Основные_определения:_граф,_ребро,_вершина,_степень,_петля,_путь,_цикл#Неориентированные_графы|неориентированный граф]] из <tex>n</tex> вершин, изначально не содержащий рёбер. Требуется обработать <tex>m</tex> запросов трёх типов:
* добавить ребро между вершинами <tex>u</tex> и <tex>v</tex>,
* удалить ребро между вершинами <tex>u</tex> и <tex>v</tex>,
* проверить, лежат ли вершины <tex>u</tex> и <tex>v</tex> в одной компоненте связности.
В графе могут быть кратные рёбра и петли.
}}
погодь

== Решение упрощённой задачи ==
Если нет удалений рёбер, задачу можно решить при помощи [[СНМ (реализация с помощью леса корневых деревьев)|системы непересекающихся множеств]]. Каждая компонента связности {{---}} одно множество в СНМ, и при добавлении рёбер они объединяются.

Время работы такого решения: <tex>O(m \cdot \alpha (n))</tex>, где <tex>\alpha</tex> {{---}} [[СНМ (реализация с помощью леса корневых деревьев)#Функция Аккермана|обратная функция Аккермана]].

== Алгоритм ==
=== Построение дерева отрезков ===
Рассмотрим массив запросов. Каждое ребро в графе существует на некотором отрезке запросов: начиная с запроса добавления и заканчивая запросом удаления (либо концом запросов, если ребро не было удалено). Для каждого ребра можно найти этот отрезок, пройдя по массиву запросов и запоминая, когда какое ребро было добавлено.

Пусть есть <tex>k</tex> рёбер, <tex>i</tex>-е соединяет вершины <tex>v_i</tex> и <tex>u_i</tex>, было добавлено запросом <tex>L_i</tex> и удалено запросом <tex>R_i</tex>.

Построим на массиве запросов [[Дерево отрезков. Построение|дерево отрезков]], в каждой его вершине будем хранить список пар. <tex>i</tex>-е рёбро графа нужно добавить на отрезок <tex>[L_i,R_i]</tex>. Это делается аналогично тому, как в дереве отрезков происходит добавление на отрезке (процесс описан в статье "[[Несогласованные поддеревья. Реализация массового обновления]]"), но без <tex>push</tex>: нужно спуститься по дереву от корня и записать пару <tex>u_i,v_i</tex> в вершины дерева отрезков.

Теперь чтобы узнать, какие рёбра существуют во время выполнения <tex>i</tex>-го запроса, достаточно посмотреть на путь от корня дерева отрезков до листа, который соответствует этому запросу {{---}} рёбра, записанные в вершинах этого пути, существуют во время выполнения запроса.

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

Для поддержания такого графа и ответа на запросы будем использовать [[СНМ (реализация с помощью леса корневых деревьев)|систему непересекающихся множеств]]. При добавлении рёбер в граф объединим соответствующие множества в СНМ. Откатывание состояния СНМ описано ниже.

=== СНМ с откатами ===
Для того, чтобы иметь возможность откатывать состояние СНМ, нужно при каждом изменении любого значения в СНМ записывать в специальный массив, что именно изменилось и какое было предыдущее значение. Это можно реализовать как массив пар (указатель, значение).

Чтобы откатить состояние СНМ, пройдём по этому массиву в обратном порядке и присвоим старые значения обратно. Для лучшего понимания ознакомьтесь с приведённой ниже реализацией.

Нужно заметить, что эвристику сжатия путей в этом случае применять не следует. Эта эвристика улучшает асимптотическое время работы, но это время работы не истинное, а амортизированное. Из-за наличия откатов к предыдущим состояниям эта эвристика не даст выигрыша. СНМ с ранговой эвристикой же работает за <tex>O(\log n)</tex> на запрос истинно.

Запоминание изменений и откаты не влияют на время работы, если оно истинное, а не амортизированное. Действительно: пусть в СНМ произошло <tex>r</tex> изменений. Каждое из них будет один раз занесено в массив и один раз отменено. Значит, запись в массив и откаты работают за <tex>\Theta(r)</tex>. Но и сами изменения заняли <tex>\Theta(r)</tex> времени, значит, откаты не увеличили асимптотическое время работы.

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

== Время работы ==
Каждое из <tex>O(m)</tex> рёбер записывается в <tex>O(\log m)</tex> вершин дерева отрезков. Поэтому операций <tex>\mathrm{union}</tex> в СНМ будет <tex>O(m \log m)</tex>. Каждая выполняется за <tex>O(\log n)</tex> (СНМ с ранговой эвристикой). Откаты не влияют на время работы.

Можно считать, что <tex>n = O(\log m)</tex>, так как в запросах используется не более <tex>2m</tex> вершин.

Время работы: <tex>O(m \log m \log n) = O(m \log^2 m)</tex>.

== Реализация на C++ ==
'''#include''' <bits/stdc++.h>

'''using''' '''namespace''' std;
'''typedef''' pair < '''int''' , '''int''' > ipair;
'''const''' '''int''' N = 100321;

// СНМ
'''int''' dsuP[N], dsuR[N];
// В этот массив записываются все изменения СНМ, чтобы их можно откатить
// При изменении какого-то значения в СНМ в hist записывается пара < указатель, старое значение >
vector < pair < '''int'''*, '''int''' > > hist;

// Для элемента из СНМ возвращает корень дерева, в котором он находится
'''int''' dsuRoot('''int''' v)
{
'''while''' (dsuP[v] != -1)
v = dsuP[v];
'''return''' v;
}

// Объединяет два множества. Используется ранговая эвристика.
// При любом изменении содержимого массивов dsuP и dsuR
// в hist записывается адрес и старое значение
'''void''' dsuMerge('''int''' a, '''int''' b)
{
a = dsuRoot(a);
b = dsuRoot(b);
'''if''' (a == b)
'''return''';
'''if''' (dsuR[a] > dsuR[b])
{
hist.emplace_back(&dsuP[b], dsuP[b]);
dsuP[b] = a;
} '''else''' '''if''' (dsuR[a] < dsuR[b])
{
hist.emplace_back(&dsuP[a], dsuP[a]);
dsuP[a] = b;
} '''else'''
{
hist.emplace_back(&dsuP[a], dsuP[a]);
hist.emplace_back(&dsuR[b], dsuR[b]);
dsuP[a] = b;
++dsuR[b];
}
}

'''struct''' Query
{
'''int''' t, u, v;
bool answer;
};
'''int''' n, m;
Query q[N];

// Дерево отрезков, в каждой вершине которого хранится список рёбер
vector < ipair > t[N*4];

// Эта функция добавляет ребро на отрезок
// [l r] - отрезок, на который добавляется ребро
// uv - ребро, c - текущая вершина дерева отрезков,
// [cl cr] - отрезок текущей вершины дерева отрезков
'''void''' addEdge('''int''' l, '''int''' r, ipair uv, '''int''' c, '''int''' cl, '''int''' cr)
{
'''if''' (l > cr || r < cl)
'''return''';
'''if''' (l <= cl && cr <= r)
{
t[c].push_back(uv);
'''return''';
}
'''int''' mid = (cl + cr) / 2;
addEdge(l, r, uv, c*2+1, cl, mid);
addEdge(l, r, uv, c*2+2, mid+1, cr);
}

// Обход дерева отрезков в глубину
'''void''' go('''int''' c, '''int''' cl, '''int''' cr)
{
'''int''' startSize = hist.size();
// Добавляем рёбра при входе в вершину
'''for''' (ipair uv : t[c])
dsuMerge(uv.first, uv.second);

'''if''' (cl == cr)
{
// Если эта вершина - лист, то отвечаем на запрос
'''if''' (q[cl].t == 3)
q[cl].answer = (dsuRoot(q[cl].u) == dsuRoot(q[cl].v));
} '''else''' {
'''int''' mid = (cl + cr) / 2;
go(c*2+1, cl, mid);
go(c*2+2, mid+1, cr);
}

// Откатываем изменения СНМ
'''while''' (('''int''')hist.size() > startSize)
{
*hist.back().first = hist.back().second;
hist.pop_back();
}
}

'''int''' main()
{
ios::sync_with_stdio('''false''');
// Формат входных данных:
// n и m, затем в m строках запросы: по три числа t, u, v
// t - тип (1 - добавить ребро, 2 - удалить, 3 - принадлежат ли одной компоненте)
// Нумерация вершин с нуля
cin >> n >> m;
'''for''' ('''int''' i = 0; i < n; ++i) // Инициализация СНМ
dsuP[i] = -1;

// В этом массиве для каждого ещё не удалённого ребра хранится
// на каком запросе оно было создано
set < pair < ipair, '''int''' > > edges;
'''for''' ('''int''' i = 0; i < m; ++i)
{
cin >> q[i].t >> q[i].u >> q[i].v;
// Поскольку рёбра неориентированные, u v должно означать то же самое, что и v u
'''if''' (q[i].u > q[i].v) swap(q[i].u, q[i].v);
// При добавлении ребра кладём его в set
'''if''' (q[i].t == 1)
edges.emplace(ipair(q[i].u, q[i].v), i);
// При удалении ребра берём из set время его добавления - так мы узнаём отрезок заросов,
// на котором оно существует. Если есть несколько одинаковых рёбер, можно брать любое.
'''else''' '''if''' (q[i].t == 2)
{
'''auto''' iter = edges.lower_bound(make_pair(ipair(q[i].u, q[i].v), 0));
addEdge(iter->second, i, iter->first, 0, 0, m - 1);
edges.erase(iter);
}
}
// Обрабатываем рёбра, которые не были удалены
'''for''' ('''auto''' e : edges)
addEdge(e.second, m - 1, e.first, 0, 0, m - 1);

// Запускаем dfs по дереву отрезков
go(0, 0, m - 1);
// Выводим ответ.
// При обходе дерева отрезков запросы обрабатываются в том же порядке, в котором они даны,
// поэтому ответ можно выводить прямо в go без заполнения answer
'''for''' ('''int''' i = 0; i < m; ++i)
'''if''' (q[i].t == 3)
{
'''if''' (q[i].answer)
cout << "YES\n";
'''else'''
cout << "NO\n";
}

'''return''' 0;
}

== Замечания ==
* Дерево отрезков можно строить не на всех запросах, а только на запросах третьего типа. Это даст выигрыш по скорости и памяти, особенно если таких запросов немного по сравнению с общим числом запросов.
* Помимо проверки, лежат ли две вершины в одной компоненте связности, можно получать и другую информацию, которую можно получить из СНМ, напрмер:
** Размер компоненты связности, которая содержит вершину <tex>v</tex>
** Количество компонент связности
* Эту идею можно использовать и для других задач. Вместо СНМ можно использовать любую структуру данных, в которую можно добавлять, но не удалять.
** Например, динамический рюкзак: добавлять предмет в него можно за <tex>O(w)</tex> (<tex>w</tex> {{---}} максимальный вес), а удалять нельзя. Аналогично тому, как в dynamic connectivity offline добавляются и удаляются рёбра, можно удалять элементы из рюкзака.

== См. также ==
* [[СНМ (реализация с помощью леса корневых деревьев)|Система непересекающихся множеств]]
* [[Дерево отрезков. Построение|Дерево отрезков]]
* [[Задача о динамической связности оффлайн]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Связность в графах]]

Задача об устойчивом паросочетании

2017-12-25T14:23:58Z

188.227.78.184: /* Описание в псевдокоде */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины незамужние.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m ещё не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда некоторая женщина (<tex>a</tex>) не замужем. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина не замужем. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Асимптотика алгоритма ===

Не представляет проблемы реализовать внутренний цикл <tex>\mathrm{\mathbf{while}}</tex> за <tex>O(1)</tex> (с предварительным предпроцессингом не более, чем за <tex>O(n^2)</tex>). Таким образом, итоговая асимптотика составляет <tex>O(n^2)</tex>.

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача об устойчивом паросочетании

2017-12-25T14:09:49Z

188.227.78.184: /* Обобщения задачи */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины не замужем.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m еще не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда некоторая женщина (<tex>a</tex>) не замужем. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина не замужем. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Асимптотика алгоритма ===

Не представляет проблемы реализовать внутренний цикл <tex>\mathrm{\mathbf{while}}</tex> за <tex>O(1)</tex> (с предварительным предпроцессингом не более, чем за <tex>O(n^2)</tex>). Таким образом, итоговая асимптотика составляет <tex>O(n^2)</tex>.

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть) <ref>https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате Задача о соседях по комнате</ref>.

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача об устойчивом паросочетании

2017-12-25T13:16:56Z

188.227.78.184: /* Источники информации */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины не замужем.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m еще не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда некоторая женщина (<tex>a</tex>) не замужем. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина не замужем. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Асимптотика алгоритма ===

Не представляет проблемы реализовать внутренний цикл <tex>\mathrm{\mathbf{while}}</tex> за <tex>O(1)</tex> (с предварительным предпроцессингом не более, чем за <tex>O(n^2)</tex>). Таким образом, итоговая асимптотика составляет <tex>O(n^2)</tex>.

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть). (см.
[https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате задача о соседях по комнате])

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]
* [http://kek.ksu.ru/eos/Lerner/KnuthRu.pdf Устойчивость супружеских пар и другие комбинаторные задачи - Казанский государственный университет]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

Задача об устойчивом паросочетании

2017-12-24T18:15:23Z

188.227.78.184: /* Доказательство корректности */

{{Определение
|definition='''Устойчивое паросочетание''' (англ. ''stable matching'') — [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]] без неустойчивых пар.
}}
{{Задача
|definition=
Найти полное устойчивое паросочетание между элементами двух множеств размера <tex>N</tex>, имеющими свои предпочтения.}}

== Основная задача ==

Есть <tex>n</tex> мужчин и <tex>n</tex> женщин. Они обладают следующими особенностями:
# Каждый человек оценивает лишь людей противоположного пола (все гетеросексуальны);
# Каждый мужчина может отсортировать женщин от ''наименее привлекательной'' к ''наиболее привлекательной'', причем его предпочтения не меняются (у каждого мужчины своя функция оценки);
# Каждая женщина может отсортировать мужчин от ''наименее привлекательного'' к ''наиболее привлекательному'', причем её предпочтения не меняются (у каждой женщины своя функция оценки).

Очевидным образом по такому определению строится [[Двудольные_графы| полный двудольный граф]] (левая доля — мужчины, правая — женщины), назовем его МЖ.

Рассмотрим некоторое [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях| паросочетание]]
в МЖ.
{{Определение
|definition =
Пара <tex>\langle A, b\rangle</tex> называется '''неустойчивой''' (англ. ''unstable pair''), если:
# В паросочетании есть пары <tex>\langle A, a\rangle</tex> и <tex>\langle B, b\rangle</tex> (<tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>)
# <tex>A</tex> считает <tex>b</tex> ''привлекательней'', чем <tex>a</tex>
# <tex>b</tex> считает <tex>A</tex> ''привлекательней'', чем <tex>B</tex>
}}

== Алгоритм Гейла-Шепли ==

Решение задачи было описано в 1962 году математиками Девидом Гейлом (Университета Брауна) и Ллойдом Шепли (Принстонский университет) в статье «Поступление в колледж и стабильность браков» (College admissions and the stability of marriage) в журнале American Mathematical Monthly
<ref>https://ru.wikipedia.org/wiki/American_Mathematical_Monthly American Mathematical Monthly 69, 9-14, 1962.</ref>. Набор правил, следование которым всегда приводит к образованию стабильных пар, получил название алгоритма Гейла-Шепли или «алгоритма отложенного согласия» (алгоритм предложи-и-откажи).

=== Интуитивное описание ===

# Мужчины делают предложение наиболее предпочитаемой женщине.
# Каждая женщина из всех поступивших предложений выбирает наилучшее и отвечает на него «может быть» (помолвка), на все остальные отвечает «нет» (отказ).
# Мужчины, получившие отказ, обращаются к следующей женщине из своего списка предпочтений, мужчины, получившие ответ «может быть», ничего не делают.
# Если женщине пришло предложение лучше предыдущего, то она прежнему претенденту (которому ранее сказала «может быть») говорит «нет», а новому претенденту говорит «может быть».
# Шаги 1-4 повторяются, пока у всех мужчин не исчерпается список предложений, в этот момент женщины отвечают «да» на те предложения «может быть», которые у них есть в настоящий момент.

=== Описание в псевдокоде ===

Изначально все мужчины не женаты и все женщины не замужем.
'''while''' Существует m <- некоторый свободный мужчина, не делавший предложения всем женщинам
w <- первая женщина из списка m, которой m еще не делал предложения
'''if''' w свободна
помечаем m и w помолвленными
'''else if''' w предпочитает m своему "текущему" жениху m'
помечаем m и w помолвленными, m' — свободным
'''else'''
w отказывает m

=== Доказательство корректности ===

{{Утверждение
|id=observation1
|about=Наблюдение 1
|statement=Мужчины делают предложения женщинам в порядке убывания симпатии.
}}

{{Утверждение
|id=observation2
|about=Наблюдение 2
|statement=Как только женщина была помолвлена, она не может стать непомолвленной, она может только улучшить свой выбор (сказать «может быть» более предпочтительному кандидату).
}}

Для начала покажем, что алгоритм завершит свою работу.

{{Лемма
|id=lemma1
|about=Лемма 1
|statement=
Алгоритм завершается после максимум <tex>n^2</tex> итераций цикла <tex>\mathrm{\mathbf{while}}</tex>.
|proof=
На каждой итерации мужчина делает предложение очередной женщине. Но всего может быть не более <tex>n^2</tex> предложений.
}}

Теперь покажем, что по завершении алгоритма задача будет решена.

{{Лемма
|id=lemma2
|about=Лемма 2
|statement=
Все мужчины и женщины будут заняты.
|proof=
Предположим, что некоторый мужчина (<tex>A</tex>) не женат по завершении алгоритма. Тогда некоторая женщина (<tex>a</tex>) не замужем. По [[#observation2|наблюдению 2]], <tex>a</tex> не получала предложений. Но <tex>A</tex> сделал предложения всем женщинам, так как он остался не женат. Получаем противоречие. Таким образом, все мужчины заняты.

Аналогичные рассуждения применяем для женщин. Пусть какая-то женщина не замужем. Значит, есть мужчина, который остался не женат. Но мы доказали, что по завершении алгоритма все мужчины заняты. Снова пришли к противоречию.
}}

{{Лемма
|id=lemma3
|about=Лемма 3
|statement=
После завершения алгоритма не будет неустойчивых пар.
|proof=
Предположим <tex>\langle A, b\rangle</tex> (где <tex>A</tex>, <tex>B</tex> — мужчины; <tex>a</tex>, <tex>b</tex> — женщины; <tex>A</tex> женат на <tex>a</tex>, <tex>B</tex> женат на <tex>b</tex>) — нестабильная пара в паросочетании, найденном алгоритмом Гейла-Шепли. Рассмотрим два случая:
# <tex>A</tex> не делал предложения <tex>b</tex>. Значит, <tex>A</tex> находит <tex>a</tex> более привлекательной, чем <tex>b</tex>. Следовательно, <tex>\langle A, b\rangle</tex> — устойчивая пара.
# <tex>A</tex> делал предложение <tex>b</tex>. Тогда был такой момент, когда <tex>b</tex> отказала <tex>A</tex>, значит, <tex>b</tex> находит <tex>B</tex> более привлекательным, чем <tex>A</tex>. Снова получается, что <tex>\langle A, b\rangle</tex> — устойчивая пара

}}

=== Асимптотика алгоритма ===

Не представляет проблемы реализовать внутренний цикл <tex>\mathrm{\mathbf{while}}</tex> за <tex>O(1)</tex> (с предварительным предпроцессингом не более, чем за <tex>O(n^2)</tex>). Таким образом, итоговая асимптотика составляет <tex>O(n^2)</tex>.

=== Анализ полученного алгоритмом паросочетания ===

Алгоритм Гейла-Шепли гарантирует, что будет найдено некоторое решение задачи. Но решений может быть более одного. Зададимся вопросом, какими свойствами обладает решение, найденное алгоритмом.

{{Лемма
|id=lemma4
|about=man-optimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наилучшее для мужчин (каждый мужчина получает в жены женщину, наилучшую из всех возможных при условии корректности решения).
|proof=
Если женщина <tex>a</tex> вычёркивается из списка предпочтений мужчины <tex>A</tex>, то ни одно устойчивое паросочетание не будет содержать пары <tex>\langle A, a\rangle</tex>.
}}

{{Лемма
|id=lemma5
|about=woman-pessimality
|statement=
Из всех возможных решений алгоритмом Гейла-Шепли будет найдено решение, наихудшее для женщин.
|proof=
Пусть <tex>A</tex>, <tex>B</tex> — мужчины; <tex>c</tex>, <tex>d</tex> — женщины; <tex>A</tex> женат на <tex>d</tex>, <tex>B</tex> женат на <tex>c</tex>.

Предположим, <tex>\langle A, c\rangle</tex> — стабильная пара в паросочетании <tex>S'</tex>, найденном алгоритмом Гейла-Шепли, но <tex>A</tex> не самый худший выбор для <tex>c</tex>. Тогда существует стабильная пара в паросочетании <tex>S</tex>, в которой <tex>c</tex> замужем за <tex>B</tex>, который менее привлекателен, чем <tex>A</tex>. Тогда пусть мужем <tex>d</tex> будет <tex>A</tex> в паросочетании <tex>S</tex>. Получается <tex>A</tex> считает <tex>c</tex> более привлекательной, чем <tex>d</tex>. Соответственно <tex>\langle A, c\rangle</tex> {{---}} нестабильная пара в паросочетании <tex>S</tex>.

}}

== Обобщения задачи ==

Интересно, что данная задача не всегда имеет решение, если допустить однополые пары (устойчивого паросочетания может не быть). (см.
[https://ru.wikipedia.org/wiki/Задача_о_соседях_по_комнате задача о соседях по комнате])

Случай же, когда у нас есть <tex>N</tex> мужчин и <tex>M</tex> женщин (<tex>N \neq M</tex>) легко сводится к описанной выше задаче. Рассмотрим <tex>M > N</tex> (<tex>M < N</tex> аналогично). Добавим <tex>M - N</tex> фиктивных мужчин, которые являются ''наименее привлекательными'' с точки зрения каждой из женщин. Тогда если в найденном алгоритмом Гейла-Шепли паросочетании некоторая женщина будет замужем за таким фиктивным мужчиной, это будет де-факто означать, что она осталась не замужем.

Также интересна задача о выборе учебного заведения: вместо множества мужчин введем множество университетов, а вместо множества женщин — множество кандидатов, подающих заявления на поступление. Причем в каждом университете есть квота на количество студентов, которое университет может принять. Задача очевидно сводится к основной добавлением <tex>(K-1)</tex> "филиалов" для каждого университета (<tex>K</tex> — квота). И добавлением фиктивного университета (поступление в который означает, что кандидату придется попробовать поступить через год).

== Применения в реальной жизни ==

Задача о нахождении устойчивого паросочетания и её решение имеют множество применений в реальной жизни, лишь некоторые из них:
* Распределение студентов по коллеждам в США
* Распределение интернов по больницам
* Распределение донорских органов по нуждающимся в них людям

Решение данной задачи было отмечено при вручении Нобелевской премии по экономике в 2012 году за «теорию стабильного распределения и практическое применение рыночных моделей». Её получили один из создателей алгоритма, Ллойд Шепли, а также Элвин Рот, во многом развивший исследования Ллойда Шепли и Дэвида Гейла. Сам Гейл не был удостоен премии, вероятно, лишь в силу того, что умер в 2008 году.

== Примечания ==
<references/>

== См. также ==
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях|Паросочетания]]
== Источники информации ==

* [http://www.cs.princeton.edu/courses/archive/spring05/cos423/lectures/01stable-matching.pdf Stable matching, Prinston lecture's presentation]
* [http://en.wikipedia.org/wiki/Stable_marriage_problem Stable marriage problem]
* [http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BC%D0%B0%D1%80%D1%8C%D1%8F%D0%B6%D0%B5 Задача о марьяже]
* [http://ge.tt/api/1/files/4LU3zaD1/0/blob?download Устойчивость супружеских пар и другие комбинаторные задачи (Статья Дональда Кнута)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о паросочетании]]

1pi1sumwu

2017-12-17T13:00:29Z

188.227.78.184:

<tex dpi = "200"> 1 \mid p_{i}=1 \mid \sum\nolimits w_iU_i</tex>
А нельзя ли обозвать как-то по-другому?

{{Задача
|definition = Дано <tex> n </tex> работ и <tex> 1 </tex> станок. Для каждой работы известны её дедлайн <tex> d_{i} </tex> и вес <tex> w_{i} </tex>. Время выполнения всех работ <tex> p_i </tex> равно <tex> 1 </tex>. Требуется минимизировать <tex>\sum w_{i} U_{i}</tex>, то есть суммарный вес всех просроченных работ.
}}

== Алгоритм ==
Идея алгоритма состоит в том, чтобы на шаге <tex> k </tex> строить оптимальное расписание для первых <tex> k </tex> работ с наименьшими дедлайнами.

Будем считать, что работы отсортированны в порядке неуменьшения их дедлайнов.
Пусть мы уже рассмотрели первые <tex> k </tex> работ, тогда множество <tex> S_{k} </tex> содержит только те работы, которые мы успеваем выполнить в порядке неуменьшения их дедлайнов при оптимальном составлении расписания . Рассмотрим работу <tex> k + 1 </tex>. Если мы успеваем выполнить данную работу до ее дедлайна, то добавим ее во множество <tex> S_{k} </tex>, тем самым получив <tex> S_{k + 1} </tex>. Если же <tex> k + 1 </tex> работу выполнить до дедлайна мы не успеваем, то найдем в <tex> S_{k} </tex> работу <tex> l </tex> с наименьшим весом <tex> w_{l} </tex> и заменим ее на работу <tex> k + 1 </tex>.

Таким образом, рассмотрев все работы, мы получим <tex> S_{n} </tex> {{---}} множество работ, которые мы успеваем выполнить до наступления их дедлайнов, причем вес просроченных работ будет наименьшим. От порядка выполнения просроченных работ ничего не зависит, поэтому расположить в расписании их можно произвольным образом.

== Псевдокод ==
Предполагаем, что перед началом выполнения алгоритма выполняется, что <tex> 1 \leqslant d_{1} \leqslant d_{2} \leqslant ... \leqslant d_{n} </tex>. Все работы, дедлайн которых равен <tex> 0 </tex>, мы в любом случае выполнить без штрафа не успеем, поэтому их изначально можно отнести к просроченным.

В псевдокоде используются переменные:
*<tex> s </tex> {{---}} множество непросроченных работ
*<tex> t </tex> {{---}} текущее время

'''Set'''<'''int'''> p1sumwu('''int''' <tex>w[n]</tex>, '''int''' <tex>d[n]</tex>):
'''int''' <tex> t = 1</tex>
'''Set'''<'''int'''> <tex>s</tex> = <tex>\{\}</tex>
'''for''' <tex> i = 1 </tex> '''to''' <tex> n </tex>
<tex> s = s \cup \{i\} </tex>
'''if''' <tex> d_{i} \geqslant t </tex>
<tex> t = t + 1 </tex>
'''else'''
найти такое <tex> k </tex>, что <tex> w_{k} = \min \{ w_{j} \mid j \in s\} </tex>
<tex> s = s \setminus \{k\} </tex>
'''return''' <tex>s</tex>

== Доказательство корректности ==

{{Утверждение
|statement=Алгоритм строит корректное расписание.
|proof=Если мы успеваем выполнить очередную работу, то, очевидно, от ее добавления, расписание не может стать некорректным. В противном случае мы пытаемся заменить одну работу из множества <tex> S </tex> на текущую. Но это так же не может сделать наше расписание некорректным. Это следует из того, что мы рассматриваем работы в порядке неуменьшениях их дедлайнов. Пусть мы заменяем работу <tex> k </tex> на работу <tex> i </tex>. Но <tex> d_{k} \leqslant d_{i} </tex>, следовательно, если мы успевали выполнить работу <tex> k </tex>, то успеем выполнить и работу <tex> i </tex>.
}}

{{Утверждение
|statement=Построенное данным алгоритмом расписание оптимально.
|proof=Пусть <tex> S^* </tex> множество непросроченных работ в оптимальном расписании. Также пусть <tex> l </tex> {{---}} первая работа из множества <tex> S </tex>, которая не входит в <tex> S^* </tex>, а <tex> k </tex> {{---}} первая работа из <tex> S^* </tex>, не содержащаяся в <tex> S </tex>. Мы можем предполагать существование этих работ, потому что <tex> S^* </tex> не может содержать <tex> S </tex> как подмножество, иначе это противоречило бы построению <tex> S </tex>. С другой стороны, если <tex> S^* \subseteq S </tex>, то <tex> S </tex> должно быть тоже оптимальным, и правильность алгоритма доказана.

Для доказательства покажем, что мы можем заменить работу <tex> k </tex> на работу <tex> l </tex> в оптимальном расписании, не увеличивая минимизируемую функцию.

Рассмотрим два случая:

*<tex> l < k </tex>

:Так как работа <tex> k </tex> не содержится в <tex> S </tex>, то либо она не была добавлена при ее рассмотрении, либо была заменена работой, рассмотренной позднее. В любом случае это означает, что <tex> w_{k} \leqslant w_{l} </tex>. Так же по определению <tex> k </tex> все работы <tex> i \in S^* : i < k </tex> должны содержаться и в <tex> S </tex>. Но тогда заменив в оптимальном расписании <tex> k </tex> на <tex> l </tex>, мы сохраним корректность расписания и не увеличим минимизируемую функцию.

*<tex> k < l </tex>

:Так как мы рассматриваем работы в порядке неубывания их дедлайнов, то, следовательно, <tex> d_{k} \leqslant d_{l} </tex>, и замена работы <tex> k </tex> на <tex> l </tex> в оптимальном расписании <tex> S^* </tex> не может сделать его некорректным. Тогда для доказательства нам осталось показать, что <tex> w_{k} \leqslant w_{l} </tex>.

:Пусть <tex> k_{i_{0}} = k </tex> {{---}} работа, замененная работой <tex> i_{0} </tex> в процессе построения <tex> S </tex>, и пусть <tex> k_{i_{1}}, ..., k_{i_{r}} </tex> {{---}} последовательность работ, которые были исключены из <tex> S </tex> после замены <tex> k </tex>, причем работа <tex> k_{i_{v}} </tex> была заменена работой <tex> i_{v} </tex>. <tex> i_{0} < i_{1} < ... < i_{r} </tex>. Будем говорить, что "работа <tex> i_{v} </tex> подавляет <tex> i_{m} </tex>", где <tex> m < v </tex>, если <tex> k_{i_{v}} \leqslant i_{m} </tex>. В таком случае получаем, что <tex> w_{k_{i_{v}}} \geqslant w_{k_{i_{m}}}</tex>, потому что в противном случае работа <tex> k_{i_{v}} </tex> была бы исключена из <tex> S </tex> раньше чем <tex> k_{i_{m}} </tex>.

:Если в последовательности <tex> i_{0} < i_{1} < ... < i_{r} </tex> существует подпоследовательность <tex> j_{0} = i_{0} < j_{1} < ... < j_{s} </tex> такая, что <tex> j_{v + 1} </tex> подавляет <tex> j_{v} </tex> для всех <tex> v = 0,1, ..., s - 1 </tex> и <tex> j_{s - 1} < l \leqslant j_{s} </tex>, то получаем, что <tex> w_{l} \geqslant w_{k_{j_{s}}} \geqslant ... \geqslant w_{k_{j_{0}}} = w_{k} </tex>, что доказывает оптимальность расписания <tex> S </tex>.

:Покажем, что отсутствие такой подпоследовательности приведет нас к противоречию, из чего будет следовать ее существование.

:Предположим, что такой подпоследовательности не существует. Тогда найдем наименьшее <tex> t </tex> такое, что не существует работы <tex> i_{v} : v > t </tex>, которая бы подавляла работу <tex> i_{t} </tex>, и <tex> i_{t} </tex> было бы меньше <tex> l </tex>. По определению <tex> l </tex> и <tex> i_{t} </tex> и из факта, что <tex> i_{t} < l </tex>, получаем, что после добавления во множество <tex> S </tex> работы <tex> i_{t} </tex>, ни одна из работ, рассмотренных ранее, не будет удалена из <tex> S </tex>, а так же все эти работы содержатся и в оптимальном расписании <tex> S^* </tex>, поскольку <tex> i_t < l </tex>.

:Пусть <tex> S_t </tex> это множество <tex> S </tex> после замены работы <tex> k_{i_t} </tex> на <tex> i_t </tex>. Если <tex> k_{i_t} > k </tex>, то в оптимальном расписании <tex> S^* </tex> мы можем заменить работу <tex> k </tex> на <tex> k_{i_t} </tex>, поскольку <tex> d_{k_{i_t}} \geqslant d_k </tex>. Но так как <tex> S_t \subset S^* </tex>, то все работы из множества <tex> S_t \cup \{k_{i_t}\} </tex> могут быть выполнены до их дедлайнов, что противоречит построению <tex> S </tex>. Следовательно, <tex> k_{i_t} < k </tex>. Тогда аналогично предыдущему случаю получаем, что все работы из множества <tex> S_t \cup \{k\} </tex> могут быть выполнены вовремя. Кроме того, все работы из <tex> \{ j \in S_t | j < k \} \cup \{k_{i_t}\} </tex> так же могут быть выполнены вовремя, что следует из построения <tex> S_t </tex>. Но тогда получается, что все работы и из множества <tex> S_t \cup \{k_{i_t}\} </tex> так же могут быть выполнены вовремя, что опять приводит нас к противоречию с построением <tex> S </tex>.
}}

== Время работы ==
Время работы алгоритма зависит от того, насколько быстро мы будем добавлять и удалять работы из множества <tex> S </tex>, а также как быстро мы будем искать работу с минимальным весом. Если в качестве множества <tex> S </tex> использовать структуру данных, умеющую выполнять данные операции за <tex> O(\log n) </tex>, то время работы всего алгоритма будет составлять <tex> O(n\log n) </tex>. Например, такими структурами данных являются [[Двоичная куча | двоичная куча]] и [[Красно-черное дерево | красно-черное дерево]].

==Cм. также ==
* [[1ripipsumwu|<tex> 1 \mid r_i,p_i=p \mid \sum w_i U_i</tex>]]
* [[Ppi1sumwu|<tex>P \mid p_i=1 \mid \sum w_i U_i</tex>]]
* [[Fpij1sumwu|<tex>F \mid p_{ij} = 1 \mid \sum w_iU_i</tex>]]

== Источники информации ==
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 96 стр. {{---}} ISBN 978-3-540-69515-8

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Теория расписаний]]

Алгоритм Ахо-Корасик

2017-11-22T18:35:45Z

188.227.78.184: /* Пример реализации */

{{Задача
|definition = Дан набор строк в алфавите размера <tex>k</tex> суммарной длины <tex>m</tex>. Необходимо найти для каждой строки все ее вхождения в текст.
}}

==Алгоритм==
=== Шаг 1. Построение бора ===
Строим [[Бор|бор]] из строк. 
Построение выполняется за время <tex>O(m)</tex>, где <tex>m</tex> {{---}} суммарная длина строк.

====Пример построенного бора====
Бор для набора строк <tex> \{ \textbf{he},\ \textbf{she},\ \textbf{his},\ \textbf{hers}\} </tex>: 
[[Файл:Бор.jpg‎]]

=== Шаг 2. Преобразование бора ===
Обозначим за <tex>[u]</tex> слово, приводящее в вершину <tex>u</tex> в боре. 
Узлы бора можно понимать как состояния [[Детерминированные_конечные_автоматы | автомата]], а корень как начальное состояние. 
Узлы бора, в которых заканчиваются строки, становятся терминальными. 
Для переходов по автомату заведём в узлах несколько функций: 
*<tex>\mathrm{parent}(u)</tex> {{---}} возвращает родителя вершины <tex>u</tex>; 
*<tex>\pi(u) = \delta(\pi(\mathrm{parent}(u)), c)</tex> {{---}} '''суффиксная ссылка''', и существует переход из <tex>\mathrm{parent}(u)</tex> в <tex>u</tex> по символу <tex>c</tex>; 
*<tex>\delta(u, c) =
\begin{cases}
v, &\text{if $v$ is son by symbol $c$ in trie;}\\
root, &\text{if $u$ is root and $u$ has no child by symbol $c$ in trie}\\
\delta(\pi(u), c), &\text{else.}
\end{cases}</tex> {{---}} функция перехода.
Мы можем понимать рёбра бора как переходы в автомате по соответствующей букве. Однако одними только рёбрами бора нельзя ограничиваться. Если мы пытаемся выполнить переход по какой-либо букве, а соответствующего ребра в боре нет, то мы тем не менее должны перейти в какое-то состояние. Для этого нам и нужны суффиксные ссылки.
 Суффиксная ссылка <tex>\pi(u) = v</tex>, если <tex>[v]</tex> {{---}} максимальный суффикс <tex>[u]</tex>, <tex>[v]\neq[u]</tex>.
Функции перехода и суффиксные ссылки можно найти либо алгоритмом [[Обход в глубину, цвета вершин | обхода в глубину]] с ленивыми вычислениями, либо с помощью алгоритма [[Обход в ширину | обхода в ширину]].

Из определений выше можно заметить два следующих факта:
* функция перехода определена через суффиксную ссылку, а суффиксная ссылка {{---}} через функию переходов;
* для построения суффиксных ссылок небходимо знать информацию только выше по бору от текущей вершины до корня.
Это позволяет реализовать функции поиска переходов по символу и суффиксных ссылок ленивым образом при помощи взаимной рекурсии.

==== Пример автомата Ахо-Корасик ====
[[Файл:axo.jpg]] 
Пунктиром обозначены суффиксные ссылки. Из вершин, для которых они не показаны, суффиксные ссылки идут в корень.

Суффиксная ссылка для каждой вершины <tex>u</tex> — это вершина, в которой оканчивается наидлиннейший собственный суффикс строки, соответствующей вершине <tex>u</tex>. Единственный особый случай — корень бора: для удобства суффиксную ссылку из него проведём в себя же. Например, для вершины <tex>5</tex> с соответствующей ей строкой <tex>"she"</tex> максимальным подходящим суффиксом является строка <tex>"he"</tex>. Видим, что такая строка заканчивается в вершине <tex>2</tex>. Следовательно суффиксной ссылкой вершины для <tex>5</tex> является вершина <tex>2</tex> .

===Шаг 3. Построение сжатых суффиксных ссылок ===
При построении автомата может возникнуть такая ситуация, что ветвление есть не на каждом символе. Тогда можно маленький бамбук заменить одним ребром. Для этого и используются сжатые суффиксные ссылки.

<tex>up(u) =
\begin{cases}
\pi(u), &\text{if $\pi(u)$ is terminal;}\\
\varnothing,&\text{if $\pi(u)$ is root;}\\
up(\pi(u)), &\text{else.}
\end{cases}</tex>

где <tex>up</tex> {{---}} сжатая суффиксная ссылка, т.е. ближайшее допускающее состояние (терминал) перехода по суффиксным ссылкам. Аналогично обычным суффиксным ссылкам сжатые суффиксные ссылки могут быть найдены при помощи ленивой рекурсии.

== Использование автомата ==
Теперь нужно сказать немного слов о том, как мы будем использовать наш автомат. По очереди просматриваем символы текста. Для очередного символа <tex>c</tex> переходим из текущего состояния <tex>u</tex> в состояние, которое вернёт функция <tex>\delta(u, c)</tex>. Оказавшись в новом состоянии, отмечаем по сжатым суффиксным ссылкам строки, которые нам встретились и их позицию (если требуется). Если новое состояние является терминалом, то соответствующие ему строки тоже отмечаем. 

== Пример реализации ==
Ниже представлена реализация некоторых функций (используется ленивая рекурсия). 
<tex>k</tex> {{---}} размер алфавита.

'''Структура вершины:'''
'''struct''' Node:
'''Node''' son[k] // массив сыновей
'''Node''' go[k] // массив переходов (запоминаем переходы в ленивой рекурсии), используемый для вычисления суффиксных ссылок
'''Node''' parent // вершина родитель
'''Node''' suffLink // суффиксная ссылка (вычисляем в ленивой рекурсии)
'''Node''' up // сжатая суффиксная ссылка
'''char''' charToParent // символ, ведущий к родителю
'''bool''' isLeaf // флаг, является ли вершина терминалом
'''vector<int>''' leafPatternNumber // номера строк, за которые отвечает терминал

'''Функция для вычисления суффиксной ссылки:'''
'''Node''' getSuffLink('''Node''' v):
'''if''' v.suffLink == ''null'' // если суффиксная ссылка ещё не вычислена
'''if''' v == root '''or''' v.parent == root
v.suffLink = root
'''else'''
v.suffLink = getLink(getSuffLink(v.parent), v.charToParent)
'''return''' v.suffLink

'''Функция для вычисления перехода:'''
'''Node''' getLink('''Node''' v, '''char''' c):
'''if''' v.go[c] == ''null'' // если переход по символу c ещё не вычислен
'''if''' v.son[c]
v.go[c] = v.son[c]
'''else''' '''if''' v == root
v.go[c] = root
'''else'''
v.go[c] = getLink(getSuffLink(v), c)
'''return''' v.go[c]

'''Функция для вычисления сжатой суффиксной ссылки:'''
'''Node''' getUp('''Node''' v):
'''if''' v.up == ''null'' // если сжатая суффиксная ссылка ещё не вычислена
'''if''' getSuffLink(v).isLeaf
v.up = getSuffLink(v)
'''else''' '''if''' getSuffLink(v) == root
v.up = root
'''else'''
v.up = getUp(getSuffLink(v))
'''return''' v.up

'''Функция для добавления строки в бор:'''
'''fun''' addString('''string''' s, '''int''' patternNumber):
'''Node''' cur = root
'''for''' i = 0 '''to''' s.length - 1
'''char''' c = s[i]
'''if''' cur.son[c] == 0
cur.son[c] = Node
/* здесь также нужно обнулить указатели на переходы и сыновей */
cur.son[c].suffLink = 0
cur.son[c].up = 0
cur.son[c].parent = cur
cur.son[c].charToParent = c
cur.son[c].isLeaf = ''false''
cur = cur.son[c]
cur.isLeaf = ''true''
cur.leafPatternNumber.pushBack(patternNumber)
'''Функция для процессинга текста (поиск, встречается строка или нет):'''
'''fun''' processText('''string''' t):
'''Node''' cur = root
'''for''' i = 0 '''to''' t.length - 1
'''char''' c = t[i] - 'a'
cur = getLink(cur, c)
/* В этом месте кода должен выполняться переход по '''сжатой''' суффиксной ссылке getUp(cur). Для вершины,
обнаруженной по ней тоже ставим, что она найдена, затем повторяем для её сжатой суффиксной ссылки
и так до корня. */
Кроме этих функций требуется инициализация, но она имеет отношение только к кодированию, поэтому здесь приведена не будет.

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

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

== Поиск шаблонов с масками ==

{{Задача
|definition = Пусть <tex>\varphi</tex> {{---}} маска, обозначающая любой одиночный символ. Необходимо найти для каждого заданного шаблона с масками все его вхождения в текст. 
}}
Например, шаблон <tex>ab\varphi\varphi c\varphi</tex>, который содержит в себе три маски, встречается на позициях <tex>2</tex> и <tex>8</tex> строки <tex>xabvccababcax</tex>.

=== Алгоритм поиска ===

Для того чтобы найти все вхождения в текст заданного шаблона с масками <tex>Q</tex>, необходимо обнаружить вхождения в текст всех его безмасочных кусков. 
Пусть <tex>\{Q_1, \dots, Q_k \}</tex> {{---}} набор подстрок
<tex>Q</tex>, разделенных масками, и пусть <tex>\{ l_1, \dots, l_k \}</tex> {{---}} их стартовые позиции в <tex>Q</tex>. Например, шаблон <tex>ab\varphi\varphi c\varphi</tex> содержит две подстроки без масок <tex>ab</tex> и <tex>c</tex> и их стартовые позиции соответственно <tex>1</tex> и <tex>5</tex>. Для алгоритма понадобится массив <tex>C</tex>. <tex>C[i]</tex> {{---}} количество встретившихся в тексте безмасочных подстрок шаблона, который начинается в тексте на позиции <tex>i</tex>. Тогда появление подстроки <tex>Q_i</tex> в тексте на позиции <tex>j</tex> будет означать возможное появление шаблона на позиции <tex>j - l_i + 1</tex>. 
# Используя алгоритм Ахо-Корасик, находим безмасочные подстроки шаблона <tex>Q</tex>: когда находим <tex>Q_i</tex> в тексте <tex>T</tex> на позиции <tex>j</tex>, увеличиваем на единицу <tex>C[j - l_i + 1]</tex>. 
# Каждое <tex>i</tex>, для которого <tex>C[i] = k</tex>, является стартовой позицией появления шаблона <tex>Q</tex> в тексте. 
Рассмотрим подстроку текста <tex>T[i \dots i+n-1]</tex>. Равенство <tex>C[i] = k</tex> будет означать, что подстроки текста <tex> T[i + l_1 \dots i + l_1 + |Q_1| - 1], T[i + l_2 \dots i + l_2 + |Q_2| - 1]</tex> и так далее будут равны соответственно безмасочным подстрокам шаблона <tex>\{Q_1, \dots , Q_k \}</tex>. Остальная часть шаблона является масками, поэтому шаблон входит в текст на позиции <tex>i</tex>. 
Поиск подстрок заданного шаблона с помощью алгоритма Ахо-Корасик выполняется за время <tex>O(m+n+a)</tex>, где <tex>n</tex> {{---}} суммарная длина подстрок, то есть длина шаблона, <tex>m</tex> {{---}} длина текста, <tex>a</tex> {{---}} количество появлений подстрок шаблона. Далее просто надо пробежаться по массиву <tex>C</tex> и просмотреть значения ячеек за время <tex>O (m)</tex>.

==См. также==
* [[Алгоритм Бойера-Мура]]
* [[Алгоритм Кнута-Морриса-Пратта]]

== Источники информации ==
*[http://e-maxx.ru/algo/aho_corasick MAXimal :: algo :: Алгоритм Ахо-Корасик]
*[http://aho-corasick.narod.ru Сопоставление множеств и алгоритм Ахо-Корасик]
*[http://codeforces.com/blog/entry/14854?locale=ru Codeforces :: Алгоритм Ахо-Корасик]
*[https://habrahabr.ru/post/198682/ Habr :: Алгоритм Ахо-Корасик]
*[https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE_%E2%80%94_%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA Wiki :: Алгоритм Ахо-Корасик]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Поиск подстроки в строке]]
[[Категория: Точный поиск]]

Z-функция

2017-11-15T20:14:49Z

188.227.78.184: /* Описание алгоритма */

{{Определение
|definition = '''Z-функция''' (англ. ''Z-function'') от строки <tex>S</tex> и позиции <tex>x</tex> — это длина максимального префикса подстроки, начинающейся с позиции <tex>x</tex> в строке <tex>S</tex>, который одновременно является и префиксом всей строки <tex>S</tex>. Более формально, <tex>Z[i](s) = \max k \mid s[i\, \ldots \, i + k] = s[0 \ldots k]</tex>. 

Значение Z-функции от первой позиции не определено, поэтому его обычно приравнивают к нулю или к длине строки.
}}
'''Примечание:''' далее в конспекте символы строки нумеруются с нуля.

[[Файл:Zfunc-examp.png|мини|500px|Строка и её Z-функция]]

== Тривиальный алгоритм ==

Простая реализация за <tex>O(n^2)</tex>, где <tex>n</tex> — длина строки. Для каждой позиции <tex>i</tex> перебираем для неё ответ, начиная с нуля, пока не обнаружим несовпадение или не дойдем до конца строки.

=== Псевдокод ===
'''int'''[] zFunction(s : '''string'''):
'''int'''[] zf = '''int'''[n]
'''for''' i = 1 '''to''' n − 1
'''while''' i + zf[i] < n '''and''' s[zf[i]] == s[i + zf[i]]
zf[i]++
'''return''' zf

== Эффективный алгоритм поиска ==

Z-блоком назовем подстроку с началом в позиции <tex>i</tex> и длиной <tex>Z[i]</tex>. 
Для работы алгоритма заведём две переменные: <tex>left</tex> и <tex>right</tex> — начало и конец Z-блока строки <tex>S</tex> с максимальной позицией конца <tex>right</tex> (среди всех таких Z-блоков, если их несколько, выбирается наибольший). Изначально <tex>left=0</tex> и <tex>right=0</tex>.
Пусть нам известны значения Z-функции от <tex>0</tex> до <tex>i-1</tex>. Найдём <tex>Z[i]</tex>.
Рассмотрим два случая.

# <tex>i > right</tex>: Просто пробегаемся по строке <tex>S</tex> и сравниваем символы на позициях <tex>S[i+j]</tex> и <tex>S[j]</tex>.Пусть <tex>j</tex> первая позиция в строке <tex>S</tex> для которой не выполняется равенство <tex>S[i+j] = S[j]</tex>, тогда <tex>j</tex> это и Z-функция для позиции <tex>i</tex>. Тогда <tex>left = i, right = i + j - 1</tex>. В данном случае будет определено корректное значение <tex>Z[i]</tex> в силу того, что оно определяется наивно, путем сравнения с начальными символами строки.
# <tex>i \leqslant right</tex>: Сравним <tex>Z[i - left] + i</tex> и <tex>right</tex>. Если <tex>right</tex> меньше, то надо просто наивно пробежаться по строке начиная с позиции <tex>right</tex> и вычислить значение <tex>Z[i]</tex>. Корректность в таком случае также гарантирована.Иначе мы уже знаем верное значение <tex>Z[i]</tex>, так как оно равно значению <tex>Z[i - left]</tex>.
[[Файл:z-func.png]]

=== Время работы ===
Этот алгоритм работает за <tex>O(|S|)</tex>, так как каждая позиция пробегается не более двух раз: при попадании в диапазон от <tex>left</tex> до <tex>right</tex> и при высчитывании Z-функции простым циклом.

=== Псевдокод ===
'''int'''[] zFunction(s : '''string'''):
'''int'''[] zf = '''int'''[n]
'''int''' left = 0, right = 0
'''for''' i = 1 '''to''' n − 1
zf[i] = max(0, min(right − i, zf[i − left]))
'''while''' i + zf[i] < n '''and''' s[zf[i]] == s[i + zf[i]]
zf[i]++
'''if''' i + zf[i] > right
left = i
right = i + zf[i]
'''return''' zf

== Поиск подстроки в строке с помощью Z-функции ==
<tex>n</tex> — длина текста. <tex>m</tex> — длина образца. 
Образуем строку <tt>s = pattern + # + text</tt>, где <tt>#</tt> — символ, не встречающийся ни в <tt>text</tt>, ни в <tt>pattern</tt>. Вычисляем Z-функцию от этой строки.
В полученном массиве, в позициях в которых значение Z-функции равно <tex>|\texttt{pattern}|</tex>, по определению начинается подстрока, совпадающая с <tt>pattern</tt>.

=== Псевдокод ===
'''int''' substringSearch(text : '''string''', pattern : '''string'''):
'''int'''[] zf = zFunction(pattern + '#' + text)
'''for''' i = m + 1 '''to''' n + 1
'''if''' zf[i] == m
'''return''' i

==Построение строки по Z-функции==
{{Задача
|definition= Необходимо восстановить строку по Z-функции, считая алфавит ограниченным.
}}
===Описание алгоритма===
Пусть в массиве <tex>z</tex> хранятся значения Z-функции, в <tex>s</tex> будет записан ответ. Пойдем по массиву <tex>z</tex> слева направо.

Нужно узнать значение <tex>s[i]</tex>. Для этого посмотрим на значение <tex>z[i]</tex>: если <tex>z[i] = 0</tex>, тогда в <tex>s[i]</tex> запишем ещё не использованный символ или последний использованный символ алфавита, если мы уже использовали все символы. Если <tex>z[i] \neq 0</tex>, то нам нужно записать префикс длины <tex>z[i]</tex> строки <tex>s</tex>. Но если при посимвольном записывании этого префикса в конец строки <tex>s</tex> мы нашли такой <tex>j</tex> (индекс последнего символа строки), что <tex>z[j]</tex> больше, чем длина оставшейся незаписанной части префикса, то мы перестаём писать этот префикс и пишем префикс длиной <tex>z[j]</tex> строки <tex>s</tex>.

Для правильной работы алгоритма будем считать значение <tex>z[0]</tex> равным нулю.

Заметим, что не всегда удастся восстановить строку с ограниченным алфавитом неподходящего размера. Например, для строки <tex>abacaba</tex> массив Z-функций будет <tex>[0, 0, 1, 0, 3, 0, 1]</tex>. Используя двоичный алфавит, мы получим строку <tex>abababa</tex>, но её массив Z-функций отличается от исходного. Ошибка восстановления строки возникла, когда закончились новые символы алфавита.

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

=== Время работы ===
Этот алгоритм работает за O(|S|), так как мы один раз проходим по массиву Z-функций.
=== Реализация ===
'''string''' buildFromZ(z : '''int'''[], alphabet : '''char'''[]):
'''string''' s = ""
'''int''' prefixLength = 0 // длина префикса, который мы записываем
'''int''' j // позиция символа в строке, который будем записывать
'''int''' newCharacter = 0 // индекс нового символа
'''for''' i = 0 '''to''' z.length - 1
// мы не пишем какой-то префикс и не будем писать новый
'''if''' z[i] = 0 '''and''' prefixLength = 0
if newCharacter < alphabet.length
s += alphabet[newCharacter]
newCharacter++
else
s += alphabet[newCharacter - 1]
// нам нужно запомнить, что мы пишем префикс 
'''if''' z[i] > prefixLength
prefixLength = z[i]
j = 0
// пишем префикс
'''if''' prefixLength > 0
s += s[j]
j++
prefixLength--
'''return''' s

===Доказательство корректности алгоритма===

Докажем, что если нам дали корректную Z-функцию, то наш алгоритм построит строку с такой же Z-функцией.

Пусть <tex>z</tex> — данная Z-функция, строку <tex>s</tex> построил наш алгоритм, <tex>q</tex> — массив значений Z-функции для <tex>s</tex>. Покажем, что массивы <tex>q</tex> и <tex>z</tex> будут совпадать.

[[Файл: Запись_префикса.png|330px|thumb|right|Записали префикс, начинающийся в <tex>i</tex>. После пишем префикс, начинающийся в <tex>j</tex>. Этот префикс не изменит символы первого префикса.]]

Рассмотрим похожий алгоритм, но с более худшей асимптотикой. Отличие будет в том, что при <tex>z[i] > 0</tex> мы будем писать префикс полностью и возвращаться в позицию <tex>i + 1</tex>. Рассмотрим каждый шаг этого алгоритма. Если <tex>z[i] = 0</tex>, то мы пишем символ, отличный от первого символа строки, поэтому <tex>q[i] = 0</tex>, а значит <tex>q[i] = z[i]</tex>. Если <tex>z[i] > 0</tex>, то при записи <tex>s[i]</tex> мы будем получать <tex>q[i] = z[i]</tex>, потому что мы переписали префикс строки. Но далее мы можем переписать этот префикс другим префиксом. Заметим, что новый префикс будет содержаться и в префиксе самой строки, поэтому пересечение двух префиксов будет состоять из одинаковых символов. Значит, префикс не будет изменяться, как и значение <tex>q[i]</tex>. Тогда массив <tex>q</tex> совпадает с <tex>z</tex>.

Покажем, что этот алгоритм эквивалентен нашему алгоритму. Когда мы пишем разные префиксы, то возможны три варианта: они не пересекаются (начало и конец одного префикса не принадлежат другому), один лежит внутри другого (начало и конец префикса принадлежит другому), они пересекаются (начало одного префикса пренадлежит другому, но конец не принадлежит).
* Если префиксы не пересекаются, то в алгоритме они не влияют друг на друга.
[[Файл: Префиксы1.png|400px]]
* Если префикс лежит внутри другого префикса, то записав большой префикс мы запишем и малый, поэтому не нужно возвращаться к началу малого префикса.
[[Файл: Префиксы2.png|400px]]
* Если префиксы пересекаются, то нам нужно переписать часть префикса, который начинается раньше, и начать писать другой префикс (начало этого префикса запишет конец префикса, начинающегося раньше). Если полностью переписать префикс, начинающийся раньше, то мы не сможем восстановить префикс, который начинался раньше конца первого префикса.
[[Файл: Префиксы3.png|400px]]

Таким образом, алгоритмы эквивалентны и наш алгоритм тоже корректен.

==Построение Z-функции по префикс-функции==

{{Задача
|definition= Дан массив с корректной [[Префикс-функция | префикс-функцией]] для строки <tex>s</tex>. Требуется получить массив с Z-функцией для строки <tex>s</tex>.
}}[[Файл:Case one.png|300px|thumb|right|'''Случай первый''']]
[[Файл:Case two.png|300px|thumb|right|'''Случай второй''']]
[[Файл:Case three.png|300px|thumb|right|'''Случай третий''']]

 

===Описание алгоритма===
 
Пусть префикс функция хранится в массиве <tex>P[0 \ldots n - 1]</tex>. Z-функцию будем записывать в массив <tex>Z[0 \ldots n-1]</tex>. Заметим, что если <tex>P[i]>0</tex>, то мы можем заявить, что <tex>Z[i-P[i]+1]</tex> будет не меньше, чем <tex>P[i]</tex>.
 
 
Так же заметим, что после такого прохода в <tex>Z[1]</tex> будет максимальное возможное значение. Далее будем поддерживать инвариант: в <tex>Z[i]</tex> будет максимальное возможное значение.
 
 
Пусть в <tex>Z[i] = z > 0</tex>, рассмотрю <tex>j<z</tex>, <tex>Z[j]=k</tex> и <tex>Z[i+j]=k_1</tex>. Пусть <tex>b_1=s[0 \ldots k-1]</tex>, <tex>b_2=s[j \ldots j+k-1]</tex>, <tex>b_3=s[0 \ldots z-1]</tex>. Тогда заметим, что <tex>b_3 = s[i \ldots i+z-1]</tex> и тогда возможны три случая:

# <tex>k<k_1</tex>.
#: Тогда <tex>b_1 \subset s[0 \ldots k_1-1]=s[i+j \ldots i+j+k_1-1]</tex> и тогда очевидно, что мы не можем увеличить значение <tex>Z[i+j]</tex> и надо рассматривать уже <tex>i=i+j</tex>.
# <tex>k<z-j</tex> и <tex>k>k_1</tex>.
#: Тогда <tex>b_1 = b_2 \subset b_3 = s[i \ldots i+z-1] \Rightarrow b_1 = s[i+j \ldots i+j+k-1]</tex> и тогда очевидно, что <tex>Z[i+j]</tex> можно увеличить до <tex>k</tex>.
# <tex>k>z-j</tex> и <tex>k>k_1</tex>.
#: Тогда <tex>b_1 = b_2 </tex>, но <tex>b_2</tex> не является подстрокой строки <tex>b_3</tex> (так как<tex>j+k-1 > z</tex>). Так как известно, что <tex>s[z] \ne s[i+z]</tex>, то <tex>s[0 \ldots z-j] = s[i+j \ldots i+z-1]</tex> и тогда понятно, что <tex>Z[i+j]=z-j</tex>.

 
 
 
 
 
 

===Псевдокод===
'''int[]''' buildZFunctionFromPrefixFunction(P : '''int'''[n])
'''int'''[] Z = '''int'''[n]
'''for''' i = 1 '''to''' n - 1
'''if''' P[i] > 0
Z[i - P[i] + 1] = P[i]
Z[0] = n
'''int''' i = 1
'''while''' i < n
'''int''' t = i
'''if''' Z[i] > 0
'''for''' j = 1 '''to''' Z[i] - 1
'''if''' Z[i + j] > Z[j]
'''break'''
Z[i + j] = min(Z[j], Z[i] - j)
t = i + j
i = t + 1
'''return''' Z

===Время работы===
Внешний цикл <tex>\mathrm{while}</tex> отработает за <tex>O(n)</tex> итераций, так как внутри него <tex>i</tex> увеличивается не менее чем на <tex>1</tex>. А внутренний цикл выполнит суммарно не более <tex>O(n)</tex> итераций, так как после него <tex>i</tex> увеличится на количество итераций внутреннего цикла, но <tex>i</tex> не может увеличиться более чем на <tex>n</tex>, так как каждое значение <tex>Z[i]</tex> не может превзойти <tex>n</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Алгоритм Кнута-Морриса-Пратта]]

== Источники информации ==
* [http://habrahabr.ru/post/113266/ Поиск подстроки и смежные вопросы — Хабр] 
* [[wikipedia:ru:Z-функция | Википедия — Z-функция]] 
* [http://codeforces.ru/blog/entry/9612/ Codeforces — Переход между Z- и префикс- функциями]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Поиск подстроки в строке]]
[[Категория:Точный поиск]]

Атрибутные транслирующие грамматики

2017-10-27T03:51:47Z

188.227.78.184: /* Атрибуты в ANTLR */

Часто, осуществляя разбор, мы хотим извлечь какие-то данные или произвести какие-то действия, а не просто выяснить, разбирается ли текст в данной грамматике.
Вообще говоря, сначала можно получить [[Контекстно-свободные_грамматики,_вывод,_лево-_и_правосторонний_вывод,_дерево_разбора#Дерево_разбора|дерево разбора]], а потом уже, обходя его, выполнять эти действия.
В этом случае происходит дублирование функционала: промежуточное сохранение данных в виде дерева разбора не нужно, а иногда его просто слишком расточительно хранить в памяти целиком.
В связи с этим хочется какие-то действия производить уже на этапе разбора.

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

Такой подход называется '''синтаксически управляемой трансляцией'''.

==Синтаксически управляемая трансляция==
<wikitex>
{{Определение
|definition =
'''Синтаксически управляемое определение''' ''(англ. syntax-directed definition)'' является [[Контекстно-свободные_грамматики,_вывод,_лево-_и_правосторонний_вывод,_дерево_разбора|контекстно-свободной]] грамматикой с атрибутами и правилами. Атрибуты связаны с грамматическими символами, а правила — с продукциями.
}}

{{Определение
|definition =
'''Синтаксически управляемая трансляция''' ''(англ. syntax-directed translation)'' {{---}} это трансляция, при которой в [[Предиктивный_синтаксический_анализ| процессе разбора]] строки сразу выполняются какие-то действия, без использования промежуточного представления в виде дерева разбора.
}}

Синтаксически управляемая трансляция вводит две новые сущности: '''атрибут''' и '''транслирующий символ'''.

{{Определение
|definition =
'''Атрибут''' ''(англ. attribute)'' {{---}} дополнительные данные, ассоциированные с грамматическими символами. Если $X$ представляет собой символ, а $a$ — один из его атрибутов, то значение $a$ в некотором узле дерева разбора, помеченном $X$, записывается как $X.a$. Если узлы дерева разбора реализованы в виде записей или объектов, то атрибуты $X$ могут быть реализованы как поля данных в записях, представляющих узлы $X$. Атрибуты могут быть любого вида: числами, типами, таблицами ссылок или строками.
}}

{{Определение
|definition =
Дерево разбора, в каждом узле которого атрибуты уже вычислены, называется '''аннотированным''' ''(англ. annotated)'', а процесс вычисления этих атрибутов {{---}} '''аннотированием''' дерева разбора.
}}

{{Определение
|id = tr_char
|definition =
'''Транслирующий символ''' {{---}} нетерминал, который раскрывается в $\varepsilon$ и в момент раскрытия выполняет связанное с ним действие. Действия пишутся в фигурных скобках рядом с транслирующим символом.
}}

Будем рассматривать в качестве примера грамматику для арифметических выражений с операторами $+$ и $*$:

$
S \to E \\
E \to E + T \mid T \\
T \to T * F \mid F \\
F \to n \mid (E)
$

Стоит отметить, что не существует гарантии наличия даже одного порядка обхода дерева разбора, при котором вычислятся все атрибуты в узлах. Рассмотрим для примера следующие нетерминалы $A$ и $B$:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Продукция
!style="background-color:#EEE"| Семантические правила
|-
|style="background-color:#FFF;padding:2px 30px"| $A \to B$
|style="background-color:#FFF;padding:2px 30px"| $A.s = B.i \\ B.i = A.s+1$
|}
Данные правила циклические: невозможно вычислить ни $A.s$ в узле, ни $B.i$ в дочернем узле, не зная значение другого атрибута.
Далее будет рассмотрено два класса синтаксически управляемых грамматик, для которых можно однозначно определить порядок вычисления атрибутов.
</wikitex>

==Синтезируемые атрибуты==
<wikitex>
{{Определение
|definition =
'''Атрибут''', значение которого зависит от значений атрибутов детей данного узла или от других атрибутов этого узла, то атрибут называется '''синтезируемым''' ''(англ. synthesized attribute)''.
}}

{{Определение
|definition =
Грамматика называется '''S-атрибутной''' ''(англ. S-attributed definition)'', если с атрибутами выполняются только операции присваивания значений других атрибутов, а внутри транслирующих символов происходят обращения только к атрибутам этого транслирующего символа. То есть в грамматике используются только синтезируемые атрибуты. Дерево разбора для такой грамматике всегда может быть аннотировано путем выполнения семантических правил снизу вверх, от листьев к корню.
}}
</wikitex>
===Пример S-атрибутной грамматики===
<wikitex>
Выпишем синтаксически управляемое определение для грамматики арифметических выражений с операторами $+$ и $*$ (здесь $\{ADD {{...}} \}$ и $\{MUL {{...}} \}$ {{---}} [[Атрибутные_транслирующие_грамматики#tr_char|транслирующие символы]]. Если в продукции несколько раз встречается одинаковый нетерминал, будем добавлять к нему индексы, считая от начала продукции.):

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Продукция
!style="background-color:#EEE"| Семантические правила
!style="background-color:#EEE"| Пояснения
|-
|style="background-color:#FFF;padding:2px 30px"| $S \to E$
|style="background-color:#FFF;padding:2px 30px"| $S.val=E.val$
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| $E_0 \to E_1 + T\ \{ADD\ res = op_1 + op_2\}$
|style="background-color:#FFF;padding:2px 30px"| $ADD.op_1=E_1.val \\ ADD.op_2=T.val \\ E_0.val=ADD.res $
|style="background-color:#FFF;padding:2px 30px"| В фигурных скобках {{---}} действия транслирующего символа ADD. $op_1$, $op_2$ и $res$ {{---}} атрибуты транслирующего символа.
|-
|style="background-color:#FFF;padding:2px 30px"| $E \to T$
|style="background-color:#FFF;padding:2px 30px"| $E.val=T.val$
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| $T_0 \to T_1 * F \ \{MUL\ res = op_1 \times op_2\}$
|style="background-color:#FFF;padding:2px 30px"| $MUL.op_1=T.val \\ MUL.op_2=F.val \\ T_0.val=MUL.res$
|style="background-color:#FFF;padding:2px 30px"| В фигурных скобках {{---}} действия транслирующего символа MUL. $op_1$, $op_2$ и $res$ {{---}} атрибуты транслирующего символа.
|-
|style="background-color:#FFF;padding:2px 30px"| $T \to F$
|style="background-color:#FFF;padding:2px 30px"| $T.val=F.val$
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| $F \to n$
|style="background-color:#FFF;padding:2px 30px"| $F.val=n.val$
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| $F \to (E)$
|style="background-color:#FFF;padding:2px 30px"| $F.val=E.val$
|style="background-color:#FFF;padding:2px 30px"|
|}

В нашем примере видно, что $val$ зависит только от детей в дереве разбора, то есть это синтезируемый атрибут. Результат умножителя ($MUL.res$) зависит только от атрибутов атрибутов самого умножителя ($MUL.op_1$ и $MUL.op_2$), а значит тоже является синтезируемым(аналогично с сумматором $ADD$).

[[Файл:3mul5add4.png|500px|thumb|center|Аннотированное дерево разбора для '''$3*5+4$''']]

После такого разбора в $S.val$ будет лежать вычисленное значение выражения. Можно, например сразу напечатать его, добавив к нему правило $\{print(S.val)\}$.

</wikitex>

==Наследуемые атрибуты==

<wikitex>
{{Определение
|definition =
'''Атрибут''', значение которого зависит от значений атрибутов братьев узла или атрибутов родителя, называется '''наследуемым''' ''(англ. inherited attribute)''.
}}

{{Определение
|definition =
Грамматика называется '''L-атрибутной''' ''(англ. L-attributed definition)'', если значения наследуемых атрибутов зависят только от родителей и братьев слева (то есть не зависят от значений атрибутов братьев справа).
}}
</wikitex>
===Пример L-атрибутной грамматики===
<wikitex>
Для наглядности рассмотрим грамматику объявления переменных
(в начале строки идет тип, затем через запятую имена переменных. Примеры строк, разбираемых в ней: '''int a''' или '''real x,y,z''' и подобные):

$
D \to TL \\
T \to int \mid real \\
L \to L,id \mid id
$

Выпишем продукции (с транслирующими символами) и ассоциируем с ними семантические правила
(здесь $\{ENTRY {{...}} \}$ {{---}} [[Атрибутные_транслирующие_грамматики#tr_char|транслирующий символ]]. Если в продукции несколько раз встречается одинаковый нетерминал, будем добавлять к нему индексы, считая от начала продукции.):

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Продукция
!style="background-color:#EEE"| Семантические правила
|-
|style="background-color:#FFF;padding:2px 30px"| $D \to TL$
|style="background-color:#FFF;padding:2px 30px"| $L.inh = T.type$
|-
|style="background-color:#FFF;padding:2px 30px"| $T \to int$
|style="background-color:#FFF;padding:2px 30px"| $T.type = integer$
|-
|style="background-color:#FFF;padding:2px 30px"| $T \to real$
|style="background-color:#FFF;padding:2px 30px"| $T.type = real$
|-
|style="background-color:#FFF;padding:2px 30px"| $L_0 \to L_1,id\ \{ENTRY addtype(key, value)\}$
|style="background-color:#FFF;padding:2px 30px"| $L_1.inh = L0.inh \\ ENTRY.key=id.text \\ ENTRY.value=L_0.inh$
|-
|style="background-color:#FFF;padding:2px 30px"| $L \to id\ \{ENTRY addtype(key, value)\}$
|style="background-color:#FFF;padding:2px 30px"| $ENTRY.key=id.text \\ ENTRY.value=L.inh$
|}

Семантическое правило $L.inh = T.type$, связанное с продукцией $D \to TL$, определяет наследуемый атрибут $L.inh$ как тип объявления. Затем приведенные правила распространяют этот тип вниз по дереву разбора с использованием атрибута $L.inh$. Транслирующий символ $ENTRY$, связанный с продукциями для $L$, вызывает процедуру $addtype$ для добавления типа каждого идентификатора к его записи в таблице символов (по ключу, определяемому атрибутом $text$).

[[Файл:Real_id1,_id2,_id3.png|600px|center|thumb|Аннотированное дерево разбора для '''$\mathbf{real}\ id1,\ id2,\ id3$'''|600px]]
</wikitex>

==Пример работы с атрибутами в нисходящем разборе==
<wikitex>
Рассмотрим работы с атрибутами на примере LL(1)-грамматики арифметических выражений, которая уже была разобрана [[Построение FIRST и FOLLOW#Пример | ранее]] и расширим код [[Предиктивный_синтаксический_анализ | разборщика]] для нее:

$
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to * FT' \mid \varepsilon \\
F \to n \mid (E)
$

В данной реализации рекурсивные функции от нетерминалов получают на вход (если необходимо) наследуемые атрибуты узла и возвращают вершины дерева разбора, в атрибутах которых записан результат вычислений соответствующего подвыражения. Однако этот код легко изменить, чтобы он только вычислял значение выражения и не строил дерево разбора. Как мы видим, $val$ {{---}} синтезируемый атрибут, $acc$ {{---}} наследуемый атрибут, $ADD$ {{---}} транслирующий символ. Синим подсвечены строки, отвечающие за работу с атрибутами.

Здесь <tex>\mathtt{Node}</tex> {{---}} структура следующего вида:
'''struct''' Node
children : '''map<String, Node>'''
name : '''string'''
val : '''int''' // атрибут нетерминала
'''function''' addChild('''Node''') // функция, подвешивающая поддерево к данному узлу

E() : '''Node'''
Node res = Node("E")
'''switch''' (curToken)
'''case''' n, '(' :
res.addChild(T()) // подвешиваем левого сына
temp = res.children["T"].val // атрибут левого сына
Node rightSon = E'(temp) // отдадим атрибут левого сына правому как наследуемый атрибут
res.addChild(rightSon) // подвешиваем правого сына сына
res.val = res.children["E'"].val
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

E'(acc) : '''Node'''
Node res = Node("E'")
'''switch''' (curToken)
'''case''' '+' :
consume('+')
res.addChild(Node("+"))
res.addChild(T())
temp = res.children["T"].val
ADD.res = ADD(acc, temp) // ADD проведет вычисления из наследуемого атрибута add и атрибута ребенка "T"
res.addChild(E'(ADD.res)) // результат вычислений будет передан правому ребенку как наследуемый атрибут
res.val = res.children["E'"].val
'''break'''
'''case''' '$', ')' :
res.val = acc
'''break'''
'''default''' :
error("unexpected char")
'''return''' res

F() : '''Node'''
Node res = Node("F")
'''switch''' (curToken)
'''case''' n :
consume(n)
res.addChild(Node(curToken))
res.val = n.val
'''break'''
'''case''' '(' :
consume('(')
res.addChild(Node("("))
res.addChild(E())
rev.val = res.children["E"].val
consume(')')
res.addChild(Node(")"))
'''default''' :
error("unexpected char")
'''return''' res

Функции для $T$ и $T'$ строятся аналогично.

[[Файл:2add3add7.png|600px|center|thumb| Дерево разбора для '''$2\ +\ 3\ +\ 7$''']]
</wikitex>

==Атрибуты в ANTLR==

Общедоступный генератор разборщиков ANTLR<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator]</ref> поддерживает синтаксически управляемое определение.

Рассмотрим для той же грамматики арифметических выражений с операторами <tex>+,\ *</tex>, скобками и выводом результата выражениая пример на ANTLR.

grammar Expression;
'''@header''' { package ru.ifmo.ctddev.wiki; }

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

Стартовый нетерминал печатает результат:
s : expr { System.out.println($expr.value); };

В продукции для нетерминала <code>expr</code> определяется возвращаемое значение (<code>['''int''' value]</code>). Обращение к этому атрибуту имеет вид <code>$expr.value</code>. В фигурных скобках записаны семантические правила.

Разобранные нетерминалы возвращают результат, вычисленный в поддереве(<code>returns [int val]</code>) как свой синтезируемый атрибут, процесс вычисления которого описан в фигурных скобках <code>{ $val = $exprP.val; }</code>.

Наследуемые атрибуты передаются нетерминалу как параметр(<code>exprP[$term.val]</code>).

expr '''returns''' ['''int''' val]
: term exprP[$term.val] { $val = $exprP.val; }
;

exprP['''int''' i] '''returns''' ['''int''' val]
: { $val = $i; } // <tex>\varepsilon</tex>-правило
| '+' term expr = exprP[$i + $term.val] { $val = $expr.val; }
;

term '''returns''' ['''int''' val]
: fact termP[$fact.val] { $val = $termpP.val; }
;

termP['''int''' i] '''returns''' '''[int''' val]
: { $val = $i; }
| '*' fact expr = termP[$i * $fact.val] { $val = $expr.val; }
;

fact '''returns''' ['''int''' val]
: '(' expr ')' { $val = $expr.val; }
| NUM { $val = Integer.parseInt($NUM.text); }
;

Техническая деталь для ANTLR, правила для лексического анализатора:
WS : [ \t \r \n]+ -> skip ;
NUM : [0-9]+ ;

== Примечания ==
<references/>

== Источники информации ==
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Первое издание. 2003. Стр. 279 {{---}} 305.
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс. Второе издание. 2008. Стр. 383 {{---}} 398.
* [https://theantlrguy.atlassian.net/wiki/display/ANTLR4/Parser+Rules#ParserRules ANTLR Documentation {{---}} Rule Attribute Definitions]
* [http://www.amazon.com/The-Definitive-ANTLR-4-Reference/dp/1934356999| The Definitive ANTLR 4 Reference]

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Список заданий по ДМ 2к 2017 осень

2017-10-26T19:50:20Z

188.227.78.184:

<wikitex>
# Постройте граф с $n$ вершинами и $m$ ребрами. Здесь и далее "постройте граф с $n$ вершинами, ..." означает, что вы должны рассказать способ для любого $n$ построить искомый граф, либо рассказать, для каких $n$ такой граф существует и указать способ его построить, а для остальных $n$ доказать, что такого графа не существует. Аналогично следует поступить с другими параметрами, указанными в условии задачи.
# Обозначим как $N(u)$ множество соседей вершины $u$. Постройте граф с $n$ вершинами, в котором множества $N(u)$ совпадают для всех вершин $u$.
# Обозначим как $N[u]$ множество, содержащее вершину $u$, а также соседей вершины $u$. Постройте граф с $n$ вершинами, в котором множества $N[u]$ совпадают для всех вершин $u$.
# Постройте граф с $n$ вершинами, где каждая вершина имеет степень $d$.
# Докажите, что любой граф, содержащий хотя бы две вершины, имеет две вершины одинаковой степени.
# Обозначим как $\delta(G)$ минимальную степень вершины в графе, как $\Delta(G)$ - максимальную степень вершины в графе. Постройте граф с $n$ вершинами, в котором $\delta(G) + \Delta(G) > n$.
# Постройте двудольный граф с $n$ вершинами, в котором $\delta(G) + \Delta(G) > n$.
# Пусть для двудольного графа выполнено условие: для любой пары не соединенных ребром вершин есть вершина, связанная с обеими этими вершинами. Как устроен такой граф?
# Докажите, что для любого графа $G$ можно записать в каждой вершине $u$ такое число $d(u)$, что числа $d(u)$ и $d(v)$ имеют общий делитель, отличный от 1, тогда и только тогда, когда в графе $G$ есть ребро $uv$.
# Граф называется кубическим, если степень всех вершин равна 3. Три вершины графа образуют треугольник, если они попарно соединены ребром. Постройте кубический граф с $n$ вершинами, не содержащий треугольников.
# Граф называется самодополнительным, если он изоморфен своему дополнению. Приведите примеры самодополнительных графов с 4 и 5 вершинами. Докажите, что если граф является самодополнительным, то он содержит либо $4n$ либо $4n+1$ вершину для некоторого целого положительного $n$.
# Докажите, что для любого целого положительного $n$ существует самодополнительный граф, содержащий $4n$ вершин, а также самодополнительный граф, содержащий $4n+1$ вершину.
# Граф $G$ с $n$ вершинами называется графом пересечений, если можно найти такие множества $U_i$, $i$ от 1 до $n$, что вершины $i$ и $j$ связаны ребром тогда и только тогда, когда $U_i \cap U_j \ne \varnothing$. Докажите, что любой граф является графом пересечений.
# Числом пересечения графа $\omega(G)$ называется минимальная возможная мощность множества $S$, что граф $G$ является графом пересечений для множеств $U_i \subset S$. Опишите графы с $\omega(G) = 1$.
# Приведите пример графа с $\omega(G) = 2$.
# Приведите пример графа с $n$ вершинами, для которого $\omega(G) > n$.
# Докажите, что для любого графа с $n$ вершинами, где $n \ge 4$, выполнено $\omega(G) \le n^2/4$.
# Обозначим как $C_n$ цикл из $n$ вершин. Найдите $\omega(C_n)$.
# Найдите асимптотическое поведение $\omega(\overline{C_n})$.
# Колесом $C_n + K_1$ называется граф, состоящий из цикла, содержащего $n$ вершин, и еще одной вершины $u$, причем все вершины цикла соединены с $u$. Найдите $\omega(C_n + K_1)$.
# Докажите, что каждый циклический путь нечетной длины содержит простой цикл.
# Докажите или опровергните, что объединение двух любых простых путей из вершины $u$ в вершину $v$ содержит цикл.
# Докажите, что граф связен тогда и только тогда когда для любого разбиения его множества вершин $V$ на два непустых непересекающихся множества $X$ и $Y$ существует ребро, соединяющее эти множества.
# Докажите, что в связном графе любые два самых длинных простых пути имеют общую вершину.
# Докажите или опровергните, что в связном графе все самые длинные простые пути имеют общую вершину.
# Обозначим как $\delta(G)$ минимальную степень вершины в графе. Докажите, что если в графе с $n$ вершинами $\delta(G) > (n - 1) / 2$, то он связен.
# Докажите, что либо граф $G$, либо его дополнение $\overline{G}$ связен.
# Будем говорить, что $G$ связан короткими путями, если между любыми двумя вершинами в $G$ есть путь длины не более 3. Докажите, что либо $G$, либо $\overline G$ связан короткими путями.
# Найдите максимальное число ребер в графе с $n$ вершинами, не содержащем четных простых циклов.
# Докажите, что граф с $n$ вершинами и $n + 4$ ребрами содержит два простых цикла, не имеющих общих ребер.
# Доказать или опровергнуть, что если ребро $uv$ - мост, то $u$ и $v$ - точки сочленения.
# Доказать или опровергнуть, что если $u$ и $v$ - точки сочленения, то $uv$ - мост.
# Какое максимальное число точек сочленения может быть в графе с $n$ вершинами?
# Рассмотрим отношение на рёбрах - $R$. $ab R cd$, если 1) $ab$ и $cd$ имеют общую вершину; 2) $ab$ и $cd$ лежат на цикле. Доказать, что вершинная двусвязность - это $R^*$.
# Доказать, что ребро $uv$ - мост тогда и только тогда, когда $uv$ вершинно двусвязно только с самим собой.
# Каждое дерево является двудольным графом. А какие деревья являются полными двудольными графами?
# Доказать, что следующие четыре утверждения для связного графа $G$ эквивалентны: (1) любое ребро является мостом (2) $G$ является деревом (3) любой блок $G$ является $K_2$ (4) любое непустое пересечение связных подграфов $G$ связно.
# Доказать, что следующие четыре утверждения для связного графа $G$ эквивалентны: (1) $G$ содержит ровно один простой цикл (2) число вершин и ребер $G$ совпадает (3) $G$ можно превратить в дерево удалением ровно одного ребра (4) множество ребер $G$, которые не являются мостами, образуют один простой цикл.
# Обозначим как $\lambda(G)$ минимальное число ребер, которое нужно удалить в графе, чтобы он потерял связность, $\kappa(G)$ - минимальное число вершин, которое нужно удалить в графе, чтобы он потерял связность (для полного графа полагаем $\kappa(G)=n-1$). Докажите, что $\kappa(G) \le \lambda(G) \le \delta(G)$.
# Докажите. что для любых $1 \le \kappa(G) \le \lambda(G) \le \delta(G)$ существует граф $G$ с такими параметрами.
# Докажите, что не существует графов с $\kappa(G) = 3$ и 7 ребрами.
# Докажите, что любой кубический граф, который содержит точку сочленения, содержит также мост.
# Пусть $G$ - полный двудольный граф, за исключением $K_{2,2}$. Докажите $\lambda(G)=\delta(G)$, почем единственный способ удалить $\lambda(G)$ ребер, чтобы граф потерял связность - удалить все ребра, инцидентные одной из вершин.
# Докажите, что если в связном графе любой блок эйлеров, то и весь граф эйлеров.
# Граф называется произвольно вычерчиваемым из вершины $u$, если следующая процедура всегда приводит к эйлеровому циклу: начиная с вершины $u$, переходим каждый раз по любому исходящему из текущей вершины ребру, по которому ранее не проходили. Докажите, что эйлеров граф является произвольно вычерчиваемым из $u$, если любой его простой цикл содержит $u$.
# Докажите, что если граф $G$ является произвольно вычерчиваемым из $u$, то $u$ имеет максимальную степень в $G$.
# Докажите, что если граф $G$ является произвольно вычерчиваемым из $u$, то либо $u$ - единственная точка сочленения в $G$, либо в $G$ нет точек сочленения.
# Доказать или опровегнуть, что если $G$ содержит порожденный тета-подграф (две вершины, соединенные тремя путями), то $G$ не гамильтонов.
# Обозначим как $G^3$ граф, в котором две вершины соединены, если они соединены в $G$ путем длины не более 3. Докажите, что если $G$ связен, то $G^3$ гамильтонов.
# Граф называется произвольно гамильтоновым, если следующая процедура всегда приводит к гамильтонову циклу: начиная с произвольной вершины $u$, переходим каждый раз по любому исходящему из текущей вершины ребру, другой конец которого мы ранее не посещали, либо обратно в вершину $u$, если непосещенных соседей нет. Опишите все произвольно гамильтоновы графы.
# Теорема "Антихватала". Докажите, что если не выполнено условие теоремы Хватала, то найдется граф с такой степенной последовательностью, не содержащий гамильтонова цикла.
# Докажите, что если сумма степеней любых двух несмежных вершин графа $G$ не меньше $n+1$, то любые две различные вершины $G$ можно соединить гамильтоновым путем.
# Докажите, что для любого $k$ существует негамильтонов граф с $\kappa(G)=k$.
# Обозначим как $G^2$ граф, в котором две вершины соединены, если они соединены в $G$ путем длины не более 2. Докажите, что если $G$ вершинно двусвязен, то $G^2$ гамильтонов.
# Докажите теорему Гуйя-Ури: если в ориентированном графе у любой вершины как входящая, так и исходящая степень хотя бы $n/2$, то он гамильтонов.
# Докажите усиленную версию теоремы Редеи-Камеона: в любом сильно связном турнире с $n$ вершинами есть простой цикл любой длины от $3$ до $n$.
# Докажите, что различные деревья имеют различные коды Прюфера.
# Докажите, что наименьшее число вершин в кубическом графе, в котором есть мост, равно 10.
# Докажите, что если $v$ {{---}} точка сочленения в $G$, то $v$ не точка сочленения в $\overline G$.
# Опишите все деревья с диаметром 2.
# Опишите все деревья с диаметром 3.
# Реберным графом для графа $G$ называется граф $G_E$, множество вершин которого совпадает с множеством ребер исходного графа, два ребра $e$ и $f$ соединены ребром в реберном графе, если у них есть общая инцидентная вершина. Докажите или опровергните, что если $G$ является эйлеровым, то реберный граф является гамильтоновым.
# Докажите или опровергните, что если $G_E$ является гамильтоновым, то граф $G$ является эйлеровым.
# В каком случае ребра реберного графа можно разбить на полные подграфы таким образом, чтобы каждая вершина принадлежала в точности двум из подграфов?
# Выразите число треугольников в реберном графе $G_E$ через число треугольников графа $G$ и набор его степеней.
# В каком случае связный граф $G$ имеет регулярный реберный граф?
# Постройте граф $G$ с $n \ge 4$ вершинами, для которого граф $G_E$ не эйлеров, а граф $G_E^2$ эйлеров.
# Докажите, что если $G$ содержит $n \ge 5$ вершин, то если $G_E^2$ эйлеров, то и $G_E^3$ эйлеров.
# Постройте минимальный по числу вершин реберный граф, в котором нет гамильтонова цикла.
# Докажите, что $G_E$ гамильтонов тогда и только тогда, когда граф $G$ содержит циклический реберно простой путь, содержащий хотя бы одну вершину, инцидентную каждому ребру графа $G$.
# Докажите, что число помеченных неподвешенных деревьев есть $n^{n-2}$, используя теорему Кирхгофа.
# Сколько остовных деревьев у полного двудольного графа $K_{n,m}$?
# Докажите или опровергните, что если в связном графе любой максимальный по включению простой путь (путь, к которому нельзя добавить ребро в начало или в конец) является диаметром, то такой граф является деревом.
# Опишите дерево с кодом Прюфера $(i, i,\ldots , i)$.
# Опишите деревья, в коде Прюфера которых нет одинаковых чисел.
# Зафиксируем дерево $T$. Рассмотрим функцию от вершины $x$: $d(x) = \sum_v dist(x, v)$, где $dist(x, v)$ - расстояние между вершинами $x$ и $v$ в ребрах. Пусть $y$ и $z$ - различные соседи вершины $x$. Докажите, что $2d(x) < d(y) + d(z)$.
# Центром дерева называется вершина $x$, для которой $max_v(dist(x, v))$ минимален. Докажите, что у дерева 1 или 2 центра, и любой центр дерева лежит на его любом диаметре.
# Барицентром дерева называется вершина $x$, для которой $\sum_v(dist(x, v))$ минимальная. Докажите, что у дерева 1 или 2 барицентра.
# Докажите, что для любого $k$ существует дерево, для которого расстояние между центром и барицентром не меньше $k$.
# Докажите, что если в связном графе есть реберно простой цикл длины $k$, то у графа есть не менее $k$ остовных деревьев.
# Приведите пример графа с двумя непересекающимися остовными деревьями.
# Какое максимальное количество попарно непересекающихся остовных деревьев может быть в графе с $n$ вершинами?
# Пусть связный граф $G$ имеет диаметр $d$. Докажите или опровергните, что у $G$ есть остовное дерево с диаметром $d$.
# Рассмотрим множество остовных деревьев связного графа $G$. Построим граф $S_G$, вершинами которого являются остовные деревья $G$, а две вершины $T_1$ и $T_2$ соединены ребром, если дерево $T_2$ можно получить из $T_1$ удалением одного ребра и добавлением другого. Докажите, что $S_G$ является связным.
# Докажите, что две вершины $T_1$ и $T_2$ в $S_G$ соединены ребром тогда и только тогда, когда их объединение содержит ровно один простой цикл.
# Пусть связный граф $G$ содержит $n$ вершин, докажите, что диаметр $S_G$ не превышает $n - 1$.
# Приведите пример связного графа $G$, содержащего $n$ вершин, для которого граф $S_G$ имеет диаметр $n - 1$.
# Докажите, что для любого $1 \le k \le n - 1$ существует связный граф $G$, содержащий $n$ вершин, такой что диаметр $S_G$ не превышает $n - k$.
# Графы $G_1$, содержащий $n_1$ вершин и $m_1$ ребер, и $G_2$, содержащий $n_2$ вершин и $m_2$ ребер, гомеоморфны. Докажите, что $n_1+m_2 = n_2+m_1$.
# Докажите, что планарный эйлеров граф содержит эйлеров цикл, не имеющий самопересечений.
# Пусть планарный граф $G$ без петель и параллельных ребер содержит $n$ вершин. Какое максимальное число ребер он может содержать?
# Приведите пример духсвязного планарного графа, который не является гамильтоновым.
# Докажите, что планарный четырехсвязный граф гамильтонов.
# Пусть $G$ - планарный граф, в котором каждый треугольник ограничивает область, не содержащую ребер, причем добавление любого ребра нарушает это свойство. Докажите, что $G$ гамильтонов.
# Докажите или опровергните, что циклы вокруг конечных граней образуют базис циклического пространства планарного графа.
# Докажите, что любой трехсвязный планарный граф имеет остов, у которого наибольшая степень равна 3.
# Докажите, что все колеса самодвойственны.
# Найдите максимальное $k$, что граф $K_k$ можно уложить на торе.
# Найдите максимальное $k$, что граф $K_k$ можно уложить на сфере с двумя ручками.
# Докажите, что для любого $m$ существует $k$, такое что граф с $K_k$ нельзя уложить на сфере с $m$ ручками.
</wikitex>

Деревья Эйлерова обхода

2017-10-25T18:37:16Z

188.227.78.184: /* Представление деревьев в виде эйлерова графа */

==Задача о динамической связности==
{{Задача
|definition = Для динамически изменяющегося дерева выполнить следующие запросы:
* '''<tex>\mathrm{link(u, w)}</tex>''' {{---}} добавить ребро <tex>(u, w)</tex> (при условии, что вершины <tex>u</tex> и <tex>w</tex> принадлежат разным деревьям),
* '''<tex>\mathrm{cut(u, w)}</tex>''' {{---}} разрезать ребро <tex>(u, w)</tex> (при условии, что ребро <tex>(u, w)</tex> принадлежит дереву),
* '''<tex>\mathrm{isConnected(u, w)}</tex>''' {{---}} определить принадлежат ли вершины <tex>u</tex> и <tex>w</tex> одной компоненте связности.
}}

Для решения поставленной задачи будем представлять дерево в виде его [[Эйлеровость графов|эйлерова графа]], а затем будем работать с [[Эйлеровость графов|эйлеровым обходом]] (англ.''Euler tour tree'') этого графа. Это позволит выполнять указанные запросы за <tex>O(\log n)</tex>.

==Представление деревьев в виде эйлерова графа==

[[Файл:Tree.png|300px|thumb|left|Пример дерева]]
[[Файл:Euler graph.png|300px|thumb|right|Соответствующий эйлеров граф]]

Для представления [[Дерево, эквивалентные определения|дерева]] в виде [[Эйлеровость графов|эйлерового графа]] заменим каждое ребро <tex>\{u, v\} \</tex> дерева на два ребра <tex>(u, v)</tex> и <tex>(v, u)</tex>.

Получившийся [[Основные определения теории графов|ориентированный граф]] будет эйлеровым согласно [[Эйлеровость графов|критерию]].
 
 
 
 
 
 
 
 

Представим дерево в виде последовательности вершин, посещенных в порядке эйлерова обхода, начиная с вершины <tex>a</tex>.
[[Файл:Tour1.png|thumb|320px|center]]

==Операции c эйлеровыми обходами==

===Добавление ребра===

Для добавления ребра <tex>(c, g)</tex>:
*Выберем любое вхождение вершины <tex>c</tex> в эйлеров обход дерева <tex>T1</tex>.
*Разрежем эйлеров обход <tex>T1</tex> на две части:
*: <tex>A1</tex> {{---}} часть обхода до выбранного вхождения вершины <tex>c</tex>, включая ее.
*: <tex>A2</tex> {{---}} часть обхода после выбранного вхождения вершины <tex>c</tex>, включая ее.
*Аналогично, выберем любое вхождение вершины <tex>g</tex> в эйлеров обход дерева <tex>T2</tex> и разрежем его на две части <tex>B1</tex> и <tex>B2</tex>.
*Соберем результирующий эйлеров обход в порядке <tex>A1, B2, B1</tex> (без первой повторяющейся вершины), <tex>A2</tex>.

Чтобы быстро находить место, где разрезать эйлеровы обходы деревьев <tex>T1</tex> и <tex>T2</tex>, будем хранить эйлеровы обходы в двоичных деревьях поиска.
Ключом вершины для построения дерева поиска будет время посещения этой вершины эйлеровым обходом.
Для каждой вершины дерева <tex>(T1, T2)</tex> будем хранить указатель на вершину в дереве поиска, которая соответствует вхождению вершины дерева в эйлеров обход.
Тогда за <tex>O(1)</tex> переходим от вершины дерева к вершине дерева поиска, по которой за <tex>O(\log n)</tex> можно будет разделить дерево поиска на две части.

[[Файл:Link22.png |thumb|400px|center|Рис.1a Исходный лес Рис.1b Эйлеровы обходы деревьев Рис.1с Двоичные деревья поиска для хранения эйлеровых обходов Рис.1d Результирующий эйлеров обход]]

===Разрезание ребра===

Для удаления ребра <tex>(g, j)</tex>:
*Найдем в эйлеровом обходе дерева <tex>T</tex> две пары посещений концов удаляемого ребра <tex>g,j</tex> и <tex>j,g</tex>, которые соответствуют прохождениям по ребру <tex>(g, j)</tex> в дереве <tex>T</tex>.
*Разрежем эйлеров обход дерева по этим парам на три части: <tex>A1, A2, A3</tex>.
*Соединив <tex>A1</tex> и <tex>A3</tex> (без повторяющейся первой вершины), получим эйлеров обход первого дерева, а <tex>A2</tex> дает эйлеров обход второго дерева.

Чтобы быстро находить места в эйлеровом обходе, которые соответствуют прохождению удаляемого ребра в дереве, будем для каждого ребра в дереве хранить ссылку на те места эйлерова обхода, где последовательно посещаем концы удаляемого ребра.
Так, для ребра <tex>(g, j)</tex> храним ссылки на узлы дерева поиска, соответствующие парам посещений концов этого ребра.

[[Файл:Link23.png |thumb|400px|center|Рис.1a Исходное дерево Рис.1b Эйлеров обход исходного дерева Рис.1с Двоичное дерево поиска для хранения эйлерового обхода Рис.1d Эйлеровы обходы получившихся деревьев]]

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

==Способы реализации структуры==

===Сбалансированное дерево поиска===

Будем хранить последовательность вершин эйлерова обхода в виде сбалансированного двоичного дерева поиска, например, в виде [[Красно-черное дерево|красно-черного дерева]]. При построении дерева ключом вершины будет время посещения этой вершины эйлеровым обходом.

Операции объединения и разделения красно-черных деревьев выполняется за <tex>O(\log n)</tex><ref>[http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.109.4875&rep=rep1&type=pdf Ron Wein {{---}} Efficient Implementation of Red-Black Trees.]</ref>.

===Декартово дерево по неявному ключу===

Также, можем хранить последовательности вершин эйлерова обхода в [[Декартово_дерево_по_неявному_ключу|декартовом дереве по неявному ключу]]. Глубина декартового дерева, построенного на массиве из <tex>n</tex> вершин, будет поддерживаться равной <tex>O(\log n)</tex>.

Операции объединения и разделения так же выполняются за <tex>O(\log n)</tex>.

==См. также==
* [[Link-Cut Tree]]

== Примечания ==
<references/>

==Источники информации==
* [https://en.wikipedia.org/wiki/Euler_tour_technique Wikipedia {{---}} Euler tour technique]
* [http://courses.csail.mit.edu/6.851/spring07/scribe/lec05.pdf Advanced Data Structures {{---}} Euler tour trees]
* [http://codeforces.com/blog/entry/18369?mobile=true&locale=en CodeForces {{---}} On Euler tour trees]
* [http://logic.pdmi.ras.ru/csclub/node/2819 Лекториум{{---}} Лекция Павла Маврина об эйлеровых обходах]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Обходы графов]]
[[Категория: Эйлеровы графы]]

Построение FIRST и FOLLOW

2017-05-28T14:49:34Z

188.227.78.184: /* Псевдокод */

Для данной [[LL(k)-грамматики, множества FIRST и FOLLOW#defLLK | LL(1)-грамматики]] оказывается возможным построить нисходящий рекурсивный парсер, который по слову сможет построить его дерево разбора в грамматике или сказать, что слово не принадлежит языку грамматики. Более того, становится возможной даже автоматическая генерация парсеров для таких грамматик<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator] </ref>.

Чтобы написать парсер для LL(1)-грамматики, необходимо построить [[LL(k)-грамматики, множества FIRST и FOLLOW#deffirst | множества]] <tex> \mathrm{FIRST} </tex> и <tex> \mathrm{FOLLOW} </tex>, после чего по ним можно составить таблицу синтаксического анализатора.
== Построение FIRST ==
Для построения <tex> \mathrm{FIRST} </tex> воспользуемся несколькими леммами, которые следуют прямо из определения. Пусть <tex> \alpha, \beta </tex> {{---}} цепочки из терминалов и нетерминалов, <tex> c </tex> {{---}} символ из алфавита.
{{Лемма
|id=lemmafirst1
|author=1
|statement=<tex> \mathrm{FIRST}(\alpha \beta) = \mathrm{FIRST}(\alpha) \cup (\mathrm{FIRST}(\beta)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha)) </tex>
}}
Рассмотрим лемму подробней. Пусть правило из нетерминала <tex> A </tex> имеет вид <tex> A \to X_1 X_2 \dots X_k </tex>, где <tex> X_i,\ (1 \leqslant i \leqslant k) </tex> {{---}} произвольный терминал или нетерминал. Тогда по лемме в <tex> \mathrm{FIRST}[A] </tex> нужно добавить <tex> \mathrm{FIRST}(X_i) </tex>, если для всех <tex> 1 \leqslant j верно, что <tex> X_j \Rightarrow^* \varepsilon </tex>.
{{Лемма
|id=lemmafirst2
|author=2
|statement=
<tex> \mathrm{FIRST}(c \alpha) = \{c\}</tex> 
<tex> \mathrm{FIRST}(\varepsilon) = \{\varepsilon \}</tex>
}}
=== Псевдокод ===
Алгоритм строит для каждого нетерминала грамматики <tex>\Gamma = \langle \Sigma, N, S, P \rangle</tex> отображение в множество символов. Перед запуском алгоритма необходимо избавиться от [[Удаление бесполезных символов из грамматики | бесполезных символов]]. Изначально каждое правило отображается в пустое множество.
<code>
'''function''' constructFIRST():
'''for''' <tex>( A \in N )</tex>
<tex>\mathrm{FIRST}[A] = \varnothing </tex>
changed = ''true''
'''while''' changed
changed = ''false''
'''for''' <tex>( A \to \alpha \in P )</tex>
<tex> \mathrm{FIRST}[A]\ \cup =\ \mathrm{FIRST}(\alpha) </tex>
changed = ''true'' '''if''' <tex> \mathrm{FIRST}[A] </tex> изменился
</code>
{{Утверждение
|id=proposalfirstcorrect
|statement=Приведённый алгоритм правильно строит множество <tex> \mathrm{FIRST} </tex> для данной грамматики.
|proof=

<tex> \Leftarrow </tex>

Алгоритм на каждом шаге использует [[#lemmafirst1 | леммы]], чтобы построить списки <tex> \mathrm{FIRST} </tex> для каждого нетерминала. Поэтому он добавит только те терминалы, которые на самом деле лежат в <tex> \mathrm{FIRST} </tex>.

<tex> \Rightarrow </tex>

Покажем, что алгоритм найдёт все символы из множества <tex> \mathrm{FIRST} </tex>.

Предположим, что в грамматике возможен вывод <tex> A \Rightarrow^* c \gamma </tex>, и алгоритм не включил <tex> c </tex> в <tex> \mathrm{FIRST}[A] </tex>. Докажем индукцией по числу шагов <tex> \mathrm{while} </tex>, что этого не может быть.

Пусть за <tex> k </tex> шагов алгоритм добавит символы <tex> c </tex> в множество <tex> \mathrm{FIRST} </tex> для каждого нетерминала <tex> A </tex>, если <tex> A \Rightarrow^k c \gamma </tex>. База индукции для числа шагов <tex> 0 </tex> верна, если считать, что для всех терминалов нам известны <tex> \mathrm{FIRST} </tex>. Если алгоритм корректно отрабатывает на <tex>(k-1)</tex>-ом шаге, то он правильно отработает их на <tex>k</tex>-ом шаге, потому что

<tex> A \Rightarrow \beta \Rightarrow^{k-1} c \gamma </tex>

Для <tex> \beta </tex> алгоритм правильно построил <tex> \mathrm{FIRST} </tex> по предположению индукции, а для <tex> A </tex> он правильно построит по [[#lemmafirst1 | леммам]], следовательно, переход доказан.

К тому же, алгоритм завершится за конечное число шагов, так как в <tex> \mathrm{FIRST} </tex> для каждого нетерминала не может добавиться больше символов, чем есть в алфавите.
}}

== Построение FOLLOW ==
Сформулируем похожие утверждения для построения <tex> \mathrm{FOLLOW} </tex>.
{{Лемма
|id=lemmafollow1
|author=3
|statement=Для каждого правила <tex> A \to \alpha B \beta </tex> верно, что <tex>(\mathrm{FIRST}(\beta) \setminus \{\varepsilon\}) \subset \mathrm{FOLLOW}(B) </tex>
}}
{{Лемма
|id=lemmafollow2
|author=4
|statement=Для каждого правила вида <tex> A \to \alpha B </tex> или <tex> A \to \alpha B \beta,\ \varepsilon \in \mathrm{FIRST}(\beta)</tex> верно, что <tex>\mathrm{FOLLOW}(A) \subset \mathrm{FOLLOW}(B) </tex>
}}
=== Псевдокод ===
Реализация построения <tex> \mathrm{FOLLOW} </tex> получается сразу из [[#lemmafollow1 | лемм]]. Для алгоритма сначала требуется выполнить построение <tex> \mathrm{FIRST} </tex> для грамматики.
<code>
'''function''' constructFOLLOW():
'''for''' <tex>( A \in N )</tex>
<tex>\mathrm{FOLLOW}[A] = \varnothing </tex>
<tex>\mathrm{FOLLOW}[S] = \{\$\} </tex> // в стартовый нетерминал помещается символ конца строки 
changed = ''true''
'''while''' changed
changed = ''false''
'''for''' <tex>( A \to \alpha \in P )</tex>
'''for''' <tex>( B : \alpha = \beta B \gamma)</tex>
<tex> \mathrm{FOLLOW}[B]\ \cup =\ \mathrm{FIRST}(\gamma) \setminus \{\varepsilon\} </tex>
'''if''' <tex> \varepsilon \in \mathrm{FIRST}(\gamma) </tex>
<tex> \mathrm{FOLLOW}[B]\ \cup =\ \mathrm{FOLLOW}[A]</tex>
changed = ''true'' '''if''' <tex> \mathrm{FOLLOW}[B] </tex> изменился
</code>
Корректность данного алгоритма доказывается точно так же, как и корректность алгоритма конструирования <tex> \mathrm{FIRST} </tex>.

== Пример ==
Рассмотрим, как будут строиться множества <tex> \mathrm{FIRST} </tex> и <tex> \mathrm{FOLLOW} </tex> на примере грамматики арифметических выражений. Ограничимся только операциями сложения, умножения и наличием скобок. Числа будем обозначать одной буквой <tex> n </tex> для простоты. Интуитивная грамматика для арифметических выражений выглядит следующим образом:

<tex> E \to E + E \mid E \times E \mid (E) \mid n </tex>

Однако данная грамматика содержит [[Устранение левой рекурсии | левую рекурсию]], [[LL(k)-грамматики, множества FIRST и FOLLOW#Теорема о связи LL(1)-грамматики с множествами FIRST и FOLLOW | правое ветвление]] и является [[Существенно неоднозначные языки#defambigous |неоднозначной]]. Чтобы избавиться от данных проблем неявно, можно придумать более удачную грамматику для рассматриваемого языка. Например, она может иметь следующий вид:

<tex>
E \to T + E \mid T \\
T \to F \times T \mid F \\
F \to n \mid (E)
</tex>

Данная грамматика содержит только правое ветвление, от которого можно избавиться левой факторизацией, после чего грамматика примет вид:

<tex>
E \to TE' \\
E' \to +E \mid \varepsilon \\
T \to FT' \\
T' \to \times T \mid \varepsilon \\
F \to n \mid (E)
</tex>

А затем для простоты анализирования раскрыть нетерминалы <tex> E </tex> и <tex> T </tex> в правилах для <tex> E' </tex> и <tex> T' </tex>.

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to \times FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

=== Конструирование FIRST для арифметических выражений ===
Рассмотрим, как будет выглядеть множество <tex> \mathrm{FIRST} </tex> после очередной итераций цикла <tex> \mathrm{while} </tex>.

'''После 1ой итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|}
'''После 2ой итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|}
'''После 3eй итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|}
Далее никаких изменений происходить не будет, и на этом алгоритм завершит свою работу.
=== Конструирование FOLLOW для арифметических выражений ===
Теперь рассмотрим построение таблицы <tex> \mathrm{FOLLOW} </tex> после каждой итераций цикла <tex> \mathrm{while} </tex>. Стартовым нетерминалом будет <tex> E </tex>, поэтому в него добавим сразу <tex> \$ </tex>.

'''До цикла while:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$ \ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|}
'''После 1ой итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$ \ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ \} </tex>
|}
'''После 2ой итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ \} </tex>
|}
'''После 3ей итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}
На этом построение множества <tex> \mathrm{FOLLOW} </tex> для грамматики закончится.

=== Итоговая таблица ===
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}

Используя [[LL(k)-грамматики, множества FIRST и FOLLOW#Теорема о связи LL(1)-грамматики с множествами FIRST и FOLLOW | теорему]], можно убедиться, что грамматика арифметических выражений на самом деле является LL(1)-грамматикой.

== См. также ==
* [[LL(k)-грамматики, множества FIRST и FOLLOW]]
== Примечания ==
<references/>
== Источники информации ==
* [http://en.wikipedia.org/wiki/LL_parser Wikipedia {{---}} LL parser]
* [http://citforum.ru/programming/theory/serebryakov/4.shtml СitForum {{---}} Синтаксический анализ]
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс, 2003. ISBN 5-8459-0189-8

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Построение FIRST и FOLLOW

2017-05-28T14:48:54Z

188.227.78.184: /* Псевдокод */

Для данной [[LL(k)-грамматики, множества FIRST и FOLLOW#defLLK | LL(1)-грамматики]] оказывается возможным построить нисходящий рекурсивный парсер, который по слову сможет построить его дерево разбора в грамматике или сказать, что слово не принадлежит языку грамматики. Более того, становится возможной даже автоматическая генерация парсеров для таких грамматик<ref>[http://www.antlr.org/ ANTLR {{---}} Parser generator] </ref>.

Чтобы написать парсер для LL(1)-грамматики, необходимо построить [[LL(k)-грамматики, множества FIRST и FOLLOW#deffirst | множества]] <tex> \mathrm{FIRST} </tex> и <tex> \mathrm{FOLLOW} </tex>, после чего по ним можно составить таблицу синтаксического анализатора.
== Построение FIRST ==
Для построения <tex> \mathrm{FIRST} </tex> воспользуемся несколькими леммами, которые следуют прямо из определения. Пусть <tex> \alpha, \beta </tex> {{---}} цепочки из терминалов и нетерминалов, <tex> c </tex> {{---}} символ из алфавита.
{{Лемма
|id=lemmafirst1
|author=1
|statement=<tex> \mathrm{FIRST}(\alpha \beta) = \mathrm{FIRST}(\alpha) \cup (\mathrm{FIRST}(\beta)\ \mathrm{if}\ \varepsilon \in \mathrm{FIRST}(\alpha)) </tex>
}}
Рассмотрим лемму подробней. Пусть правило из нетерминала <tex> A </tex> имеет вид <tex> A \to X_1 X_2 \dots X_k </tex>, где <tex> X_i,\ (1 \leqslant i \leqslant k) </tex> {{---}} произвольный терминал или нетерминал. Тогда по лемме в <tex> \mathrm{FIRST}[A] </tex> нужно добавить <tex> \mathrm{FIRST}(X_i) </tex>, если для всех <tex> 1 \leqslant j верно, что <tex> X_j \Rightarrow^* \varepsilon </tex>.
{{Лемма
|id=lemmafirst2
|author=2
|statement=
<tex> \mathrm{FIRST}(c \alpha) = \{c\}</tex> 
<tex> \mathrm{FIRST}(\varepsilon) = \{\varepsilon \}</tex>
}}
=== Псевдокод ===
Алгоритм строит для каждого терминала грамматики <tex>\Gamma = \langle \Sigma, N, S, P \rangle</tex> отображение в множество символов. Перед запуском алгоритма необходимо избавиться от [[Удаление бесполезных символов из грамматики | бесполезных символов]]. Изначально каждое правило отображается в пустое множество.
<code>
'''function''' constructFIRST():
'''for''' <tex>( A \in N )</tex>
<tex>\mathrm{FIRST}[A] = \varnothing </tex>
changed = ''true''
'''while''' changed
changed = ''false''
'''for''' <tex>( A \to \alpha \in P )</tex>
<tex> \mathrm{FIRST}[A]\ \cup =\ \mathrm{FIRST}(\alpha) </tex>
changed = ''true'' '''if''' <tex> \mathrm{FIRST}[A] </tex> изменился
</code>
{{Утверждение
|id=proposalfirstcorrect
|statement=Приведённый алгоритм правильно строит множество <tex> \mathrm{FIRST} </tex> для данной грамматики.
|proof=

<tex> \Leftarrow </tex>

Алгоритм на каждом шаге использует [[#lemmafirst1 | леммы]], чтобы построить списки <tex> \mathrm{FIRST} </tex> для каждого нетерминала. Поэтому он добавит только те терминалы, которые на самом деле лежат в <tex> \mathrm{FIRST} </tex>.

<tex> \Rightarrow </tex>

Покажем, что алгоритм найдёт все символы из множества <tex> \mathrm{FIRST} </tex>.

Предположим, что в грамматике возможен вывод <tex> A \Rightarrow^* c \gamma </tex>, и алгоритм не включил <tex> c </tex> в <tex> \mathrm{FIRST}[A] </tex>. Докажем индукцией по числу шагов <tex> \mathrm{while} </tex>, что этого не может быть.

Пусть за <tex> k </tex> шагов алгоритм добавит символы <tex> c </tex> в множество <tex> \mathrm{FIRST} </tex> для каждого нетерминала <tex> A </tex>, если <tex> A \Rightarrow^k c \gamma </tex>. База индукции для числа шагов <tex> 0 </tex> верна, если считать, что для всех терминалов нам известны <tex> \mathrm{FIRST} </tex>. Если алгоритм корректно отрабатывает на <tex>(k-1)</tex>-ом шаге, то он правильно отработает их на <tex>k</tex>-ом шаге, потому что

<tex> A \Rightarrow \beta \Rightarrow^{k-1} c \gamma </tex>

Для <tex> \beta </tex> алгоритм правильно построил <tex> \mathrm{FIRST} </tex> по предположению индукции, а для <tex> A </tex> он правильно построит по [[#lemmafirst1 | леммам]], следовательно, переход доказан.

К тому же, алгоритм завершится за конечное число шагов, так как в <tex> \mathrm{FIRST} </tex> для каждого нетерминала не может добавиться больше символов, чем есть в алфавите.
}}

== Построение FOLLOW ==
Сформулируем похожие утверждения для построения <tex> \mathrm{FOLLOW} </tex>.
{{Лемма
|id=lemmafollow1
|author=3
|statement=Для каждого правила <tex> A \to \alpha B \beta </tex> верно, что <tex>(\mathrm{FIRST}(\beta) \setminus \{\varepsilon\}) \subset \mathrm{FOLLOW}(B) </tex>
}}
{{Лемма
|id=lemmafollow2
|author=4
|statement=Для каждого правила вида <tex> A \to \alpha B </tex> или <tex> A \to \alpha B \beta,\ \varepsilon \in \mathrm{FIRST}(\beta)</tex> верно, что <tex>\mathrm{FOLLOW}(A) \subset \mathrm{FOLLOW}(B) </tex>
}}
=== Псевдокод ===
Реализация построения <tex> \mathrm{FOLLOW} </tex> получается сразу из [[#lemmafollow1 | лемм]]. Для алгоритма сначала требуется выполнить построение <tex> \mathrm{FIRST} </tex> для грамматики.
<code>
'''function''' constructFOLLOW():
'''for''' <tex>( A \in N )</tex>
<tex>\mathrm{FOLLOW}[A] = \varnothing </tex>
<tex>\mathrm{FOLLOW}[S] = \{\$\} </tex> // в стартовый нетерминал помещается символ конца строки 
changed = ''true''
'''while''' changed
changed = ''false''
'''for''' <tex>( A \to \alpha \in P )</tex>
'''for''' <tex>( B : \alpha = \beta B \gamma)</tex>
<tex> \mathrm{FOLLOW}[B]\ \cup =\ \mathrm{FIRST}(\gamma) \setminus \{\varepsilon\} </tex>
'''if''' <tex> \varepsilon \in \mathrm{FIRST}(\gamma) </tex>
<tex> \mathrm{FOLLOW}[B]\ \cup =\ \mathrm{FOLLOW}[A]</tex>
changed = ''true'' '''if''' <tex> \mathrm{FOLLOW}[B] </tex> изменился
</code>
Корректность данного алгоритма доказывается точно так же, как и корректность алгоритма конструирования <tex> \mathrm{FIRST} </tex>.

== Пример ==
Рассмотрим, как будут строиться множества <tex> \mathrm{FIRST} </tex> и <tex> \mathrm{FOLLOW} </tex> на примере грамматики арифметических выражений. Ограничимся только операциями сложения, умножения и наличием скобок. Числа будем обозначать одной буквой <tex> n </tex> для простоты. Интуитивная грамматика для арифметических выражений выглядит следующим образом:

<tex> E \to E + E \mid E \times E \mid (E) \mid n </tex>

Однако данная грамматика содержит [[Устранение левой рекурсии | левую рекурсию]], [[LL(k)-грамматики, множества FIRST и FOLLOW#Теорема о связи LL(1)-грамматики с множествами FIRST и FOLLOW | правое ветвление]] и является [[Существенно неоднозначные языки#defambigous |неоднозначной]]. Чтобы избавиться от данных проблем неявно, можно придумать более удачную грамматику для рассматриваемого языка. Например, она может иметь следующий вид:

<tex>
E \to T + E \mid T \\
T \to F \times T \mid F \\
F \to n \mid (E)
</tex>

Данная грамматика содержит только правое ветвление, от которого можно избавиться левой факторизацией, после чего грамматика примет вид:

<tex>
E \to TE' \\
E' \to +E \mid \varepsilon \\
T \to FT' \\
T' \to \times T \mid \varepsilon \\
F \to n \mid (E)
</tex>

А затем для простоты анализирования раскрыть нетерминалы <tex> E </tex> и <tex> T </tex> в правилах для <tex> E' </tex> и <tex> T' </tex>.

<tex>
E \to TE' \\
E' \to +TE' \mid \varepsilon \\
T \to FT' \\
T' \to \times FT' \mid \varepsilon \\
F \to n \mid (E)
</tex>

=== Конструирование FIRST для арифметических выражений ===
Рассмотрим, как будет выглядеть множество <tex> \mathrm{FIRST} </tex> после очередной итераций цикла <tex> \mathrm{while} </tex>.

'''После 1ой итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|}
'''После 2ой итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|}
'''После 3eй итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|}
Далее никаких изменений происходить не будет, и на этом алгоритм завершит свою работу.
=== Конструирование FOLLOW для арифметических выражений ===
Теперь рассмотрим построение таблицы <tex> \mathrm{FOLLOW} </tex> после каждой итераций цикла <tex> \mathrm{while} </tex>. Стартовым нетерминалом будет <tex> E </tex>, поэтому в него добавим сразу <tex> \$ </tex>.

'''До цикла while:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$ \ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \}</tex>
|}
'''После 1ой итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$ \ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ \} </tex>
|}
'''После 2ой итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ \} </tex>
|}
'''После 3ей итерации:'''
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}
На этом построение множества <tex> \mathrm{FOLLOW} </tex> для грамматики закончится.

=== Итоговая таблица ===
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Правило
!style="background-color:#EEE"| FIRST
!style="background-color:#EEE"| FOLLOW
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>E'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \$,\ )\ \} </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>T'</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times,\ \varepsilon\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ +,\ \$\ ,\ )\ \}</tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>F</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ n,\ (\ \} </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\ \times, \ +,\ \$\ ,\ )\ \} </tex>
|}

Используя [[LL(k)-грамматики, множества FIRST и FOLLOW#Теорема о связи LL(1)-грамматики с множествами FIRST и FOLLOW | теорему]], можно убедиться, что грамматика арифметических выражений на самом деле является LL(1)-грамматикой.

== См. также ==
* [[LL(k)-грамматики, множества FIRST и FOLLOW]]
== Примечания ==
<references/>
== Источники информации ==
* [http://en.wikipedia.org/wiki/LL_parser Wikipedia {{---}} LL parser]
* [http://citforum.ru/programming/theory/serebryakov/4.shtml СitForum {{---}} Синтаксический анализ]
* Альфред Ахо, Рави Сети, Джеффри Ульман. Компиляторы. Принципы, технологии, инструменты. Издательство Вильямс, 2003. ISBN 5-8459-0189-8

[[Категория: Методы трансляции]]
[[Категория: Нисходящий разбор]]

Математическое ожидание случайной величины

2017-05-21T21:12:54Z

188.227.78.184: /* Пример 2 */ Karlukova Marina (darkblack1997) \dfrac

==Математическое ожидание случайной величины==
{{Определение
|definition='''Математическое ожидание''' (англ. ''mean value'') (<tex>E\xi</tex>) {{---}} мера среднего значения случайной величины, равна <tex>E\xi = \sum \xi(\omega)p(\omega)</tex>
}}

{{Теорема
|statement= <tex>\sum\limits_{\omega\epsilon\Omega} \xi(\omega)p(\omega) = \sum\limits_a a p(\xi = a)</tex>
|proof= <tex>\sum\limits_a \sum\limits_{\omega|\xi(\omega) = a} \xi(\omega)p(\omega) = \sum\limits_a a \sum\limits_{\omega|\xi(\omega)=a}p(\omega) = \sum\limits_a a p(\xi = a)</tex>
}}

===Пример===
Пусть наше вероятностное пространство {{---}} «честная кость»

<tex> \xi(i) = i </tex>

<tex> E\xi = 1\cdot \genfrac{}{}{1pt}{0}{1}{6}+2\cdot \genfrac{}{}{1pt}{0}{1}{6} \dots +6\cdot \genfrac{}{}{1pt}{0}{1}{6} = 3.5</tex>

==Свойства математического ожидания==
{{Утверждение
|about=о матожидании константы
|statement=<tex>E(a) = a</tex>, где <tex>a \in R</tex> {{---}} константа.
}}

{{Утверждение
|about=о матожидании неравенств
|statement=Если <tex>0 \leqslant \xi \leqslant \eta</tex>, и <tex>\eta</tex> {{---}} случайная величина с конечным математическим ожиданием, то математическое ожидание случайной величины <tex>\xi</tex> также конечно, и <tex>0 \leqslant E(\xi) \leqslant E(\eta)</tex>.
}}

{{Утверждение
|about=о матожидании случайной величины на событии вероятности нуль
|statement=Если <tex>\xi = \eta</tex>, то <tex>E(\xi) = E(\eta)</tex>.
}}

{{Утверждение
|about=о матожидании двух независимых случайных величин
|statement=Если <tex>\xi</tex> и <tex>\eta</tex> {{---}} две независимые случайные величины, то <tex>E(\xi \cdot \eta) = E(\xi) \cdot E(\eta)</tex>
}}
==Линейность математического ожидания==

{{Теорема
|statement=
Математическое ожидание <tex>E</tex> линейно.
|proof=
# <tex>E(\xi + \eta) = {\sum_w \limits}(\xi(w) + \eta(w))p(w) = {\sum_w \limits}\xi(w)p(w) + {\sum_w \limits}\eta(w)p(w) = E(\xi) + E(\eta) </tex>
# <tex>E(\alpha\xi) = {\sum_w \limits}\alpha\xi(w) = \alpha{\sum_w \limits}\xi(w) = \alpha E(\xi)</tex>, где <tex>\alpha</tex> {{---}} действительное число

}}

==Использование линейности==
Рассмотрим три примера

===Пример 1===
Найти математическое ожидание суммы цифр на случайной кости домино.

Пусть <tex> \xi </tex> {{---}} случайная величина, которая возвращает первое число на кости домино, а <tex> \eta </tex> {{---}} возвращает второе число.
Очевидно, что <tex> E(\xi)= E(\eta)</tex>.
Посчитаем <tex>E(\xi)</tex>.

<tex>E(\xi)={\sum_{i=0}^6 \limits}i \cdot p(\xi=i)={\sum_{i=0}^6 \limits}i \cdot \genfrac{}{}{1pt}{0}{1}{7}=3</tex>

Получаем ответ
<tex>E(\xi+\eta)=2E(\xi)=6</tex>

===Пример 2===
Пусть у нас есть строка <tex>s</tex>. Строка <tex>t</tex> генерируется случайным образом так, что два подряд идущих символа неравны. Какое математическое ожидание количества совпавших символов? Считать что размер алфавита равен <tex>k</tex>, а длина строки <tex>n</tex>.

Рассмотрим случайные величины <tex>\xi^i</tex> {{---}} совпал ли у строк <tex> i </tex>-тый символ.
Найдем математическое ожидание этой величины
<tex>E(\xi^i)=0 \cdot p(\xi^i=0)+1 \cdot p(\xi^i=1)=p(s[i]=t[i])</tex> где <tex>s[i],t[i]</tex> {{---}} <tex>i</tex>-тые символы соответствующих строк.
Так как появление каждого символа равновероятно, то <tex>p(s[i]=t[i])=\dfrac{}{}{1pt}{0}{1}{k}</tex>.

Итоговый результат: <tex>E(\xi)={\sum_{i=1}^n \limits}E(\xi^i)=\dfrac{}{}{1pt}{0}{n}{k} </tex>

===Пример 3===
Найти математическое ожидание количества инверсий на всех перестановках чисел от <tex>1</tex> до <tex>n</tex>.

Пусть <tex> \xi </tex> {{---}} случайная величина, которая возвращает количество инверсий в перестановке.

Очевидно, что вероятность любой перестановки равна <tex> \genfrac{}{}{1pt}{0}{1}{n!} </tex>

Тогда <tex> E\xi = \genfrac{}{}{1pt}{0}{1}{n!}\cdot{\sum_{i=1}^{n!} \limits}E(\xi^i) </tex>

Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является перестановкой чисел <tex> 1, 2,\dots, n</tex>.

Тогда <tex> A = (p_n, p_{n-1}, \dots, p_1) </tex> является перевернутой перестановкой <tex> P </tex>.

Докажем, что количество инверсий в этих двух перестановках равно <tex> \genfrac{}{}{1pt}{0}{n\cdot(n-1)}{2} </tex>

Рассмотрим все пары <tex> 1 \leqslant i < j \leqslant n </tex>, таких пар всего <tex> \genfrac{}{}{1pt}{0}{n\cdot(n-1)}{2} </tex>. Тогда пара этих чисел образуют инверсию или в <tex>P</tex>, или в <tex>A</tex>. Если <tex>j</tex> стоит раньше <tex>i</tex> в перестановке <tex>P</tex>, то <tex>j</tex> будет стоять после <tex>i</tex> и уже не будет давать инверсию. Аналогично, если <tex>j</tex> стоит раньше <tex>i</tex> в перестановке <tex>A</tex>.

Всего таких пар из перестановки и перевернутой перестановки будет <tex> \genfrac{}{}{1pt}{0}{n!}{2} </tex>.

Итого: <tex> E\xi = \genfrac{}{}{1pt}{0}{1}{n!}\cdot\genfrac{}{}{1pt}{0}{n\cdot(n-1)}{2}\cdot\genfrac{}{}{1pt}{0}{n!}{2} = \genfrac{}{}{1pt}{0}{n\cdot(n-1)}{4} </tex>

==Примеры распределений==

===Распределение Бернулли===
Случайная величина <tex>\xi</tex> имеет распределение Бернулли, если она принимает всего два значения: <tex>1</tex> и <tex>0</tex> с вероятностями <tex>p</tex> и <tex>q \equiv 1-p</tex> соответственно. Таким образом:

:<tex>P(\xi = 1) = p</tex>
:<tex>P(\xi = 0) = q</tex>

Тогда несложно догадаться, чему будет равно математическое ожидание:
:<tex>E(\xi) = 1 \cdot p + 0 \cdot q = p</tex>

===Гипергеометрическое распределение===
Гипергеометрическое распределение в теории вероятностей моделирует количество удачных выборок без возвращения из конечной совокупности.

Пусть имеется конечная совокупность, состоящая из <tex>N</tex> элементов. Предположим, что <tex>D</tex> из них обладают нужным нам свойством. Оставшиеся <tex>N-D</tex> этим свойством не обладают. Случайным образом из общей совокупности выбирается группа из <tex>n</tex> элементов. Пусть <tex>a</tex> {{---}} случайная величина, равная количеству выбранных элементов, обладающих нужным свойством. Тогда функция вероятности <tex>a</tex> имеет вид:

:<tex>P_\xi(k) \equiv P(\xi = k) = \genfrac{}{}{1pt}{0}{C_D^k \cdot C_{N-D}^{n-k}}{C_N^n}</tex>,
где <tex>C_n^k \equiv \genfrac{}{}{1pt}{0}{n!}{k! \cdot (n-k)!}</tex> обозначает биномиальный коэффициент.

Гипергеометрическое распределение обозначается <tex> \xi \sim \mathrm{HG}(D,N,n)</tex>.

Формула математического ожидания для гипергеометрического распределения имеет вид:
:<tex>E(\xi) = \genfrac{}{}{1pt}{0}{n \cdot D}{N}</tex>

==Смотри также==
* [[Дисперсия случайной величины]]

== Источники информации ==
* [http://ru.wikipedia.org/wiki/Математическое_ожидание Wikipedia {{---}} Математическое ожидание]
* [https://ru.wikipedia.org/wiki/Гипергеометрическое_распределение Wikipedia {{---}} Гипергеометрическое распределение]
* [https://ru.wikipedia.org/wiki/Распределение_Бернулли Wikipedia {{---}} Распределение Бернулли]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Теория вероятности]]

Дерево поиска, наивная реализация

2017-01-18T22:40:44Z

188.227.78.184: /* Восстановление дерева по результату обхода preorderTraversal */

[[Файл:Binary_search_tree.svg.png|right|300px|thumb|Бинарное дерево поиска из 9 элементов]]'''Бинарное дерево поиска''' (англ. ''binary search tree, BST'') {{---}} структура данных для работы с [[Упорядоченное множество|упорядоченными множествами]].
Бинарное дерево поиска обладает следующим свойством: если <tex>x</tex> {{---}} узел бинарного дерева с ключом <tex>k</tex>, то все узлы в левом поддереве должны иметь ключи, меньшие <tex>k</tex>, а в правом поддереве большие <tex>k</tex>.
== Операции в бинарном дереве поиска ==
Для представления бинарного дерева поиска в памяти будем использовать следующую структуру:
'''struct''' Node:
'''T''' key // ключ узла
'''Node''' left // указатель на левого потомка
'''Node''' right // указатель на правого потомка
'''Node''' parent // указатель на предка

=== Обход дерева поиска ===
Есть три операции обхода узлов дерева, отличающиеся порядком обхода узлов:
* <tex>\mathrm{inorderTraversal}</tex> {{---}} обход узлов в отсортированном порядке,
* <tex>\mathrm{preorderTraversal}</tex> {{---}} обход узлов в порядке: вершина, левое поддерево, правое поддерево,
* <tex>\mathrm{postorderTraversal}</tex> {{---}} обход узлов в порядке: левое поддерево, правое поддерево, вершина.
'''func''' inorderTraversal(x : '''Node'''):
'''if''' x != ''null''
inorderTraversal(x.left)
'''print''' x.key
inorderTraversal(x.right)
При выполнении данного обхода вершины будут выведены в следующем порядке: ''1 3 4 6 7 8 10 13 14''.

'''func''' preorderTraversal(x : '''Node''')
'''if''' x != ''null''
'''print''' x.key
preorderTraversal(x.left)
preorderTraversal(x.right)
При выполнении данного обхода вершины будут выведены в следующем порядке: ''8 3 1 6 4 7 10 14 13''.

'''func''' postorderTraversal(x : '''Node''')
'''if''' x != ''null''
postorderTraversal(x.left)
postorderTraversal(x.right)
'''print''' x.key
При выполнении данного обхода вершины будут выведены в следующем порядке: ''1 4 7 6 3 13 14 10 8''.

Данные алгоритмы выполняют обход за время <tex>O(n)</tex>, поскольку процедура вызывается ровно два раза для каждого узла дерева.

=== Поиск элемента ===
[[Файл:Bst search.png|frame|right|318px|Поиск элемента 4]]
Для поиска элемента в бинарном дереве поиска можно воспользоваться следующей функцией, которая принимает в качестве параметров корень дерева и искомый ключ. Для каждого узла функция сравнивает значение его ключа с искомым ключом. Если ключи одинаковы, то функция возвращает текущий узел, в противном случае функция вызывается рекурсивно для левого или правого поддерева. Узлы, которые посещает функция образуют нисходящий путь от корня, так что время ее работы <tex>O(h)</tex>, где <tex>h</tex> {{---}} высота дерева.
<div style="width: 65%">
'''Node''' search(x : '''Node''', k : '''T'''):
'''if''' x == ''null'' '''or''' k == x.key
'''return''' x
'''if''' k < x.key
'''return''' search(x.left, k)
'''else'''
'''return''' search(x.right, k)
</div>

=== Поиск минимума и максимума ===
Чтобы найти минимальный элемент в бинарном дереве поиска, необходимо просто следовать указателям <tex>left</tex> от корня дерева, пока не встретится значение <tex>null</tex>. Если у вершины есть левое поддерево, то по свойству бинарного дерева поиска в нем хранятся все элементы с меньшим ключом. Если его нет, значит эта вершина и есть минимальная. Аналогично ищется и максимальный элемент. Для этого нужно следовать правым указателям.
'''Node''' minimum(x : '''Node'''):
'''if''' x.left == ''null''
'''return''' x
'''return''' minimum(x.left)

'''Node''' maximum(x : '''Node'''):
'''if''' x.right == ''null''
'''return''' x
'''return''' maximum(x.right)
Данные функции принимают корень поддерева, и возвращают минимальный (максимальный) элемент в поддереве. Обе процедуры выполняются за время <tex>O(h)</tex>.

=== Поиск следующего и предыдущего элемента ===
====Реализация с использованием информации о родителе====
Если у узла есть правое поддерево, то следующий за ним элемент будет минимальным элементом в этом поддереве. Если у него нет правого поддерева, то нужно следовать вверх, пока не встретим узел, который является левым дочерним узлом своего родителя. Поиск предыдущего выполнятся аналогично. Если у узла есть левое поддерево, то следующий за ним элемент будет максимальным элементом в этом поддереве. Если у него нет левого поддерева, то нужно следовать вверх, пока не встретим узел, который является правым дочерним узлом своего родителя.
'''Node''' next(x : '''Node'''):
'''if''' x.right != ''null''
'''return''' minimum(x.right)
y = x.parent
'''while''' y != ''null'' '''and''' x == y.right
x = y
y = y.parent
'''return''' y

'''Node''' prev(x : '''Node'''):
'''if''' x.left != ''null''
'''return''' maximum(x.left)
y = x.parent
'''while''' y != ''null'' '''and''' x == y.left
x = y
y = y.parent
'''return''' y
Обе операции выполняются за время <tex>O(h)</tex>.
====Реализация без использования информации о родителе====
Рассмотрим поиск следующего элемента для некоторого ключа <tex>x</tex>. Поиск будем начинать с корня дерева, храня текущий узел <tex>current</tex> и узел <tex>successor</tex>, последний посещенный узел, ключ которого больше <tex>x</tex>. 
Спускаемся вниз по дереву, как в алгоритме поиска узла. Рассмотрим ключ текущего узла <tex>current</tex>. Если <tex>current.key \leqslant x</tex>, значит следующий за <tex>x</tex> узел находится в правом поддереве (в левом поддереве все ключи меньше <tex>current.key</tex>). Если же <tex>x < current.key</tex>, то <tex>x < next(x) \leqslant current.key</tex>, поэтому <tex>current</tex> может быть следующим для ключа <tex>x</tex>, либо следующий узел содержится в левом поддереве <tex>current</tex>. Перейдем к нужному поддереву и повторим те же самые действия. 
Аналогично реализуется операция поиска предыдущего элемента.
'''Node''' next(x : '''T'''):
'''Node''' current = root, successor = ''null'' // root {{---}} корень дерева
'''while''' current != ''null''
'''if''' current.key > x
successor = current
current = current.left
'''else'''
current = current.right
'''return''' successor
=== Вставка ===
Операция вставки работает аналогично поиску элемента, только при обнаружении у элемента отсутствия ребенка нужно подвесить на него вставляемый элемент.
====Реализация с использованием информации о родителе====
'''func''' insert(x : '''Node''', z : '''Node'''): // x {{---}} корень поддерева, z {{---}} вставляемый элемент
'''while''' x != ''null''
'''if''' z.key > x.key
'''if''' x.right != ''null''
x = x.right
'''else'''
z.parent = x
x.right = z
'''break'''
'''else if''' z.key < x.key
'''if''' x.left != ''null''
x = x.left
'''else'''
z.parent = x
x.left = z
'''break'''
====Реализация без использования информации о родителе====
'''Node''' insert(x : '''Node''', z : '''T'''): // x {{---}} корень поддерева, z {{---}} вставляемый ключ
'''if''' x == ''null''
'''return''' Node(z) // подвесим Node с key = z
'''else if''' z < x.key
x.left = insert(x.left, z)
'''else if''' z > x.key
x.right = insert(x.right, z)
'''return''' x

Время работы алгоритма для обеих реализаций {{---}} <tex>O(h)</tex>.

=== Удаление ===
====Нерекурсивная реализация====
Для удаления узла из бинарного дерева поиска нужно рассмотреть три возможные ситуации. Если у узла нет дочерних узлов, то у его родителя нужно просто заменить указатель на <tex>null</tex>. Если у узла есть только один дочерний узел, то нужно создать новую связь между родителем удаляемого узла и его дочерним узлом. Наконец, если у узла два дочерних узла, то нужно найти следующий за ним элемент (у этого элемента не будет левого потомка), его правого потомка подвесить на место найденного элемента, а удаляемый узел заменить найденным узлом. Таким образом, свойство бинарного дерева поиска не будет нарушено. Данная реализация удаления не увеличивает высоту дерева. Время работы алгоритма {{---}} <tex>O(h)</tex>.
{| border="1" cellpadding="5" cellspacing="0"
!Случай
!Иллюстрация
|-
|'''Удаление листа'''
| [[Файл:Bst_del1.png |581px]]
|-
|'''Удаление узла с одним дочерним узлом'''
| [[Файл:Bst_del2.png |604px]]
|-
|'''Удаление узла с двумя дочерними узлами'''
| [[Файл:Bst_del3.png‎|900px]]
|}
'''func''' delete(t : '''Node''', v : '''Node'''): // <tex>t</tex> {{---}} дерево, <tex>v</tex> {{---}} удаляемый элемент
p = v.parent // предок удаляемого элемента
'''if''' v.left == ''null'' '''and''' v.right == ''null'' // первый случай: удаляемый элемент - лист
'''if''' p.left == v
p.left = ''null''
'''if''' p.right == v
p.right = ''null''
'''else if''' v.left == ''null'' '''or''' v.right == ''null'' // второй случай: удаляемый элемент имеет одного потомка
'''if''' v.left == ''null''
'''if''' p.left == v
p.left = v.right
'''else'''
p.right = v.right
v.right.parent = p
'''else'''
'''if''' p.left == v
p.left = v.left
'''else'''
p.right = v.left
v.left.parent = p
'''else''' // третий случай: удаляемый элемент имеет двух потомков
successor = next(v, t)
v.key = successor.key
'''if''' successor.parent.left == successor
successor.parent.left = successor.right
'''if''' successor.right != ''null''
successor.right.parent = successor.parent
'''else'''
successor.parent.right = successor.right
'''if''' successor.right != ''null''
successor.right.parent = successor.parent

====Рекурсивная реализация====
При рекурсивном удалении узла из бинарного дерева нужно рассмотреть три случая: удаляемый элемент находится в левом поддереве текущего поддерева, удаляемый элемент находится в правом поддереве или удаляемый элемент находится в корне. В двух первых случаях нужно рекурсивно удалить элемент из нужного поддерева. Если удаляемый элемент находится в корне текущего поддерева и имеет два дочерних узла, то нужно заменить его минимальным элементом из правого поддерева и рекурсивно удалить минимальный элемент из правого поддерева. Иначе, если удаляемый элемент имеет один дочерний узел, нужно заменить его потомком. Время работы алгоритма {{---}} <tex>O(h)</tex>.
Рекурсивная функция, возвращающая дерево с удаленным элементом <tex>z</tex>:
'''Node''' delete(root : '''Node''', z : '''T'''): // корень поддерева, удаляемый ключ
'''if''' root == ''null''
'''return''' root
'''if''' z < root.key
root.left = delete(root.left, z)
'''else if''' z > root.key
root.right = delete(root.right, z)
'''else if''' root.left != ''null'' '''and''' root.right != ''null''
root.key = minimum(root.right).key
root.right = delete(root.right, root.right.key)
'''else'''
'''if''' root.left != ''null''
root = root.left
'''else'''
root = root.right
'''return''' root

==Задачи о бинарном дереве поиска==

===Проверка того, что заданное дерево является деревом поиска===

{{Задача
|definition = Определить, является ли заданное двоичное дерево деревом поиска.
}}
[[Файл:Not_Enough.png|right|thumb|291px|Пример дерева, для которого недостаточно проверки лишь его соседних вершин]]
Для того чтобы решить эту задачу, применим [[Обход в глубину, цвета вершин|обход в глубину]]. Запустим от корня рекурсивную логическую функцию, которая выведет <tex>\mathtt{true}</tex>, если дерево является BST и <tex>\mathtt{false}</tex> в противном случае. Чтобы дерево не являлось BST, в нём должна быть хотя бы одна вершина, которая не попадает под определение дерева поиска. То есть достаточно найти всего одну такую вершину, чтобы выйти из рекурсии и вернуть значение <tex>\mathtt{false}</tex>. Если же, дойдя до листьев, функция не встретит на своём пути такие вершины, она вернёт значение <tex>\mathtt{true}</tex>.

Функция принимает на вход исследуемую вершину, а также два значения: <tex>\mathtt{min}</tex> и <tex>\mathtt{max}</tex>, которые до вызова функции равнялись <tex> \infty </tex> и <tex> -\infty </tex> соответственно, где <tex> \infty </tex> — очень большое число, т.е. ни один ключ дерева не превосходит его по модулю. Казалось бы, два последних параметра не нужны. Но без них программа может выдать неверный ответ, так как сравнения только вершины и её детей недостаточно. Необходимо также помнить, в каком поддереве для более старших предков мы находимся. Например, в этом дереве вершина с номером <tex>8</tex> находится левее вершины, в которой лежит <tex>5</tex>, чего не должно быть в дереве поиска, однако после проверки функция бы вернула <tex>\mathtt{true}</tex>.

'''bool''' isBinarySearchTree(root: '''Node'''): // Здесь root — корень заданного двоичного дерева.

'''bool''' check(v : '''Node''', min: '''T''', max: '''T'''): // min и max — минимально и максимально допустимые значения в вершинах поддерева.
'''if''' v == ''null'' '''return''' ''true''
'''if''' v.key <= min '''or''' max <= v.key '''return''' ''false''
'''return''' check(v.left, min, v.key) '''and''' check(v.right, v.key, max)

'''return''' check(root, <tex> -\infty </tex>, <tex> \infty </tex>)

Время работы алгоритма {{---}} <tex>O(n)</tex>, где <tex>n</tex> {{---}} количество вершин в дереве.

===Задачи на поиск максимального BST в заданном двоичном дереве===

{{Задача
|definition = Найти в данном дереве такую вершину, что она будет корнем поддерева поиска с наибольшим количеством вершин.
}}
Если мы будем приведённым выше способом проверять каждую вершину, мы справимся с задачей за <tex>O(n^2)</tex>. Но её можно решить за <tex>O(n)</tex>, идя от корня и проверяя все вершины по одному разу, основываясь на следующих фактах:
* Значение в вершине больше максимума в её левом поддереве;
* Значение в вершине меньше минимума в её правом поддереве;
* Левое и правое поддерево являются деревьями поиска.

Введём <tex>\mathtt{v.min}</tex> и <tex>\mathtt{v.max}</tex>, которые будут хранить минимум в левом поддереве вершины и максимум в правом. Тогда мы должны будем проверить, являются ли эти поддеревья деревьями поиска и, если да, лежит ли ключ вершины <tex>\mathtt{v}</tex> между этими значениями <tex>\mathtt{v.min}</tex> и <tex>\mathtt{v.max}</tex>. Если вершина является листом, она автоматически становится деревом поиска, а её ключ {{---}} минимумом или максимумом для её родителя (в зависимости от расположения вершины). Функция <tex>\mathtt{cnt}</tex> записывает в <tex>\mathtt{v.kol}</tex> количество вершин в дереве, если оно является деревом поиска или <tex>\mathtt{-1}</tex> в противном случае. После выполнения функции ищем за линейное время вершину с наибольшим значением <tex>\mathtt{v.kol}</tex>.

'''int''' count(root: '''Node'''): // root — корень заданного двоичного дерева.

'''int''' cnt(v: '''Node'''):
'''if''' v == ''null''
v.kol = 0
'''return''' = 0
'''if''' cnt(v.left) != -1 '''and''' cnt(v.right) != -1
'''if''' v.left == ''null'' '''and''' v.right == ''null''
v.min = v.key
v.max = v.key
v.kol = 1
'''return''' 1
'''if''' v.left == ''null''
'''if''' v.right.max > v.key
v.min = v.key
v.kol = cnt(v.right) + 1
'''return''' v.kol
'''if''' v.right == ''null''
'''if''' v.left.min < v.key
v.max = v.key
v.kol = cnt(v.left) + 1
'''return''' v.kol
'''if''' v.left.min < v.key '''and''' v.right.max > v.key
v.min = v.left.min
v.max = v.right.max
v.kol = v.left.kol + v.right.kol + 1
v.kol = cnt(v.left) + cnt(v.right) + 1
'''return''' v.kol
'''return''' -1

'''return''' cnt(root)

Алгоритм работает за <tex>O(n)</tex>, так как мы прошлись по дереву два раза за время, равное количеству вершин.

===Восстановление дерева по результату обхода preorderTraversal===

{{Задача
|definition = Восстановить дерево по последовательности, выведенной после выполнения процедуры <tex>\mathrm{preorderTraversal}</tex>.
}}
[[Файл:BST_from_seq.gif|right|thumb|257px|Восстановление дерева поиска по последовательности ключей]]

Как мы помним, процедура <tex>\mathrm{preorderTraversal}</tex> выводит значения в узлах поддерева следующим образом: сначала идёт до упора влево, затем на каком-то моменте делает шаг вправо и снова движется влево. Это продолжается до тех пор, пока не будут выведены все вершины. Полученная последовательность позволит нам однозначно определить расположение всех узлов поддерева. Первая вершина всегда будет в корне. Затем, пока не будут использованы все значения, будем последовательно подвешивать левых сыновей к последней добавленной вершине, пока не найдём номер, нарушающий убывающую последовательность, а для каждого такого номера будем искать вершину без правого потомка, хранящую наибольшее значение, не превосходящее того, которое хотим поставить, и подвешиваем к ней элемент с таким номером в качестве правого сына. Когда мы, желая найти такую вершину, встречаем какую-нибудь другую, уже имеющую правого сына, проходим по ветке вправо. Мы имеем на это право, так как если такая вершина стоит, то процедура обхода в ней уже побывала и поворачивала вправо, поэтому спускаться в другую сторону смысла не имеет. Вершину с максимальным ключом, с которой будем начинать поиск, будем запоминать. Она будет обновляться каждый раз, когда появится новый максимум.

Процедура восстановления дерева работает за <tex>O(n)</tex>.

Разберём алгоритм на примере последовательности <tex>\mathtt{8}</tex> <tex>\mathtt{2}</tex> <tex>\mathtt{1}</tex> <tex>\mathtt{4}</tex> <tex>\mathtt{3}</tex> <tex>\mathtt{5}</tex>.

Будем выделять красным цветом вершины, рассматриваемые на каждом шаге, чёрным жирным {{---}} их родителей, курсивом {{---}} убывающие подпоследовательности (в случаях, когда мы их рассматриваем) или претендентов на добавление к ним правого ребёнка (когда рассматривается вершина, нарушающая убывающую последовательность).
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Состояние
последовательности
!style="background-color:#EEE"| Действие
!style="background-color:#EEE"| Пояснение
|-
|style="background-color:#FFF;padding:2px 10px"| '''8''' 2 1 4 3 5
|style="background-color:#FFF;padding:2px 10px"| Делаем вершину корнем.
|style="background-color:#FFF;padding:2px 10px"| ''Первая вершина всегда будет корнем, так как вывод начинался с него.''
|-
|style="background-color:#FFF;padding:2px 10px"| '''''8''''' '''''2''''' ''1'' 4 3 5
|rowspan=2 style="background-color:#FFF;padding:2px 10px"|Находим убывающую подпоследовательность. Каждую вершину подвешиваем к последней из взятых ранее в качестве левого сына.
|rowspan=2 style="background-color:#FFF;padding:2px 10px"| ''Каждая последующая вершина становится левым сыном предыдущей, так как выводя ключи, мы двигались по дереву поиска влево, пока есть вершины.''
|-
| style="background-color:#FFF;padding:2px 10px"| ''8 '''2''''' '''''1''''' 4 3 5
|-
|style="background-color:#FFF;padding:2px 10px"| ''8 '''2''''' 1 '''4''' 3 5
|style="background-color:#FFF;padding:2px 10px"| Для вершины, нарушившей убывающую последовательность, ищем максимальное значение, меньшее его. В данном случае оно равно <tex>\mathtt{2}</tex>. Затем добавляем вершину.
|style="background-color:#FFF;padding:2px 10px"| ''На моменте вывода следующего номера процедура обратилась уже к какому-то из правых поддеревьев, так как влево идти уже некуда. Значит, нам необходимо найти узел, для которого данная вершина являлась бы правым сыном. Очевидно, что в её родителе не может лежать значение, которое больше её ключа. Но эту вершину нельзя подвесить и к меньшим, иначе нашёлся бы более старший предок, также хранящий какое-то значение, которое меньше, чем в исследуемой. Для этого предка вершина бы попала в левое поддерево. И тогда возникает противоречие с определением дерева поиска. Отсюда следует, что родитель определяется единственным образом {{---}} он хранит максимум среди ключей, не превосходящих значения в подвешиваемой вершине, что и требовалось доказать.''
|-
|style="background-color:#FFF;padding:2px 10px"| 8 2 1 '''''4''''' '''''3''''' 5
|style="background-color:#FFF;padding:2px 10px"| Находим убывающую подпоследовательность. Каждую вершину подвешиваем к последней из взятых ранее в качестве левого сына.
|style="background-color:#FFF;padding:2px 10px"| ''Зайдя в правое поддерево, процедура обхода снова до упора начала двигаться влево, поэтому действуем аналогичным образом.''
|-
|style="background-color:#FFF;padding:2px 10px"| ''8'' 2 1 '''''4''''' 3 '''5'''
|style="background-color:#FFF;padding:2px 10px"| Для этой вершины ищем максимальное значение, меньшее его. Затем добавляем вершину.
|style="background-color:#FFF;padding:2px 10px"| ''Здесь процедура снова обратилась к правому поддереву. Рассуждения аналогичны. Ключ родителя этой вершины равен <tex>\mathtt{4}</tex>.''
|}

==См. также==
* [[Поисковые структуры данных]]
* [[Рандомизированное бинарное дерево поиска]]
* [[Красно-черное дерево]]

==Источники информации==
* [https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0 Википедия {{---}} Двоичное дерево поиска]
* [https://en.wikipedia.org/wiki/Binary_search_tree Wikipedia {{---}} Binary search tree]
* Кормен, Т., Лейзерсон, Ч., Ривест, Р., Штайн, К. Алгоритмы: построение и анализ = Introduction to Algorithms / Под ред. И. В. Красикова. — 2-е изд. — М.: Вильямс, 2005. — 1296 с. — ISBN 5-8459-0857-4

[[Категория: Деревья поиска]]
[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Структуры данных]]

Реализация булевой функции схемой из функциональных элементов

2017-01-07T14:37:12Z

188.227.78.184: /* Источники */

== Логические элементы ==
{{Определение
|definition=
'''Функциональный элемент''' (англ. ''Combinational element'') — устройство, предназначенное для обработки информации в цифровой форме. Функциональный элемент имеет ''входы'' и ''выходы''.
Сигналы на входах функционального элемента — аргументы функции, которую реализует функциональный элемент, сигналы на выходах — значение функции от аргументов.
}}
{{Определение
|definition=
Если входные и выходные сигналы — являются нулями и единицами, элемент называется '''логическим''' (англ. ''logic gate'').
При подаче на входы логического элемента любой комбинации двоичных сигналов, на выходах также возникает сигнал — значение [[Определение булевой функции|булевой функции]].
}}

Отождествление переменных осуществляется при помощи ветвления проводников.[[File:Отождествление.png|thumb|200px|Отождествление переменных]]

Чтобы осуществить подстановку одной функции в другую нужно выход логического элемента, который реализует первую функцию, направить на вход логического элемента, который реализует вторую функцию.
[[File:Подстановка.png|thumb|200px|Подстановка]]

== Изображение логических элементов на схемах ==

{| class = "wikitable" border = "1"
!Тип элемента
!-align="center" |И
!-align="center" |ИЛИ
!-align="center" |НЕ
!Штрих Шеффера
!Стрелка Пирса
|-
!Традиционная форма
|[[Image:AND_logic_element.png]]
|[[Image:OR_logic_element.png]]
|[[Image:NOT_logic_element.png]]
|[[Image:NAND_logic_element.png]]
|[[Image:NOR_logic_element.png]]
|-
!Прямоугольная форма
|[[Image:AND_logic_relement.png]]
[[Image:AND_logic_relement2.png]]
|[[Image:OR_logic_relement.png]]

[[Image:OR_logic_relement2.png]]
|[[Image:NOT_logic_relement.png]]
|[[Image:NAND_logic_relement.png]]

[[Image:NAND_logic_relement2.png]]
|[[Image:NOR_logic_relement.png]]
[[Image:NOR_logic_relement2.png]]
|}

== Схемная сложность ==
{{Определение

|definition= '''Схемная сложность''' (англ. ''Circuit complexity'') функции <tex>f</tex> относительно базиса <tex>B</tex> — это минимальное количество функциональных элементов из набора <tex>B</tex>, необходимое для реализации функции <tex>f</tex> в базисе <tex>B</tex>.
Схемную сложность функции <tex>f</tex> в базисе <tex>B</tex> обозначают так: <tex>size_B(f)</tex>
}}

{{Теорема
|statement =
Для любых базисов <tex>~B_1</tex>, <tex>~B_2</tex> и функции <tex>~f</tex> верно неравенство <tex>~size_{B_2}(f) \le C_{(B_1,\;B_2)}size_{B_1}(f)</tex>, где константа <tex>~C</tex> зависит только от базисов <tex>~B_1</tex> и <tex>~B_2</tex>.
|proof =
Пусть базис <tex>~B_2</tex> состоит из функций <tex>~g_1, g_2, \ldots, g_n</tex>. Каждый функциональный элемент базиса <tex>~B_2</tex> можно собрать с помощью не более чем <tex>~size_{B_1}(g_i)</tex> элементов из базиса <tex>~B_1</tex>. Собрать <tex>f</tex> в базисе <tex>B_1</tex> можно следующим образом: заменить каждый элемент схемы <tex>f</tex> в базисе <tex>B_2</tex> на схему соответствующей функции в базисе <tex>B_1</tex>. Такая сборка использует не более чем в <tex>~C = \overset{n}{\underset{i=1}{\max}} \ size_{B_1}(g_i)</tex> раз больше функциональных элементов, чем соответствующая схема в <tex>B_2</tex>. Параметр <tex>~C</tex> зависит только от выбранных базисов.
}}

== Глубина схемы ==
{{Определение

|definition= '''Глубина схемы''' для функции <tex>f</tex> относительно базиса <tex>B</tex> (англ. ''Circuit depth'') — это максимальная длина пути от входа до выхода по схеме соответствующей функции <tex>f</tex>, состоящей из элементов набора <tex>B</tex>, где за единицу длины принимается один элемент схемы.
Глубину схемы для функции <tex>f</tex> в базисе <tex>B</tex> обозначают <tex>depth_B(f)</tex>
}}
Примечание: понятие глубины имеет смысл только для схем с ограниченной степенью входа (''bounded fan-in'').

{{Теорема
|about=аналогична теореме про схемную сложность
|statement =
Для любых базисов <tex>~B_1</tex>, <tex>~B_2</tex> и функции <tex>~f</tex> верно неравенство <tex>~depth_{B_2}(f) \leq C_{(B_1,\;B_2)}depth_{B_1}(f)</tex>, где константа <tex>~C</tex> зависит только от базисов <tex>~B_1</tex> и <tex>~B_2</tex>.
}}
Доказательство аналогично доказательству предыдущей теоремы.

== См. также ==
* [[Простейшие методы синтеза схем из функциональных элементов]]
* [[Сумматор]]
* [[Каскадный сумматор]]
* [[Контактная схема]]

== Источники информации==

* Кормен, Т., Лейзерсон, Ч., Ривест, Р. Алгоритмы: построение и анализ — 960 с. — ISBN 5-900916-37-5
* [http://en.wikipedia.org/wiki/Logic_gate Wikipedia — Lodic gate]
* [http://www.intuit.ru/department/calculate/lancalc/2/ Лекция "Схемы из функциональных элементов" в НОУ "ИНТУИТ"]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Схемы из функциональных элементов ]]