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

Статические выпуклые оболочки: Джарвис, Грэхем, Эндрю, Чен, QuickHull

2014-02-22T11:11:49Z

194.85.161.34:

{{ready}}
{{Определение
|definition=Выпуклой оболочкой множества точек называется пересечение всех выпуклых множеств, содержащих все заданные точки.}}

Еще одно определение:
{{Определение
|definition=Выпуклой оболочкой множества точек называется линейная комбинация минимального набора точек, дающая все остальные точки.}}

Ниже приводятся основные алгоритмы построения выпуклых оболочек статического множества. Используются обозначения: <tex>n</tex> - размер входных данных, <tex>k</tex> - размер оболочки.

= Алгоритм Джарвиса =

По-другому "Gift wrapping algorithm" (Заворачивание подарка).
Он заключается в том, что мы ищем выпуклую оболочку последовательно, против часовой стрелки, начиная с определенной точки.

== Описание Алгоритма ==
[[File:Graham1.png|thumb|250px|Промежуточный шаг алгоритма. Для точки <tex>p_i</tex> ищем следующую перебором.]] 
1) Возьмем самую правую нижнюю точку <tex>p_0</tex> нашего множества. Добавляем ее в ответ.

2) На каждом следующем шаге для последнего добавленного <tex>p_i</tex> ищем <tex>p_{i + 1}</tex> среди всех недобавленных точек и <tex>p_0</tex> с максимальным полярным углом относительно <tex>p_i</tex> (Если углы равны, надо сравнивать по расстоянию). Добавляем <tex>p_{i + 1}</tex> в ответ. Если <tex>p_{i + 1} == p_0</tex> , заканчиваем алгоритм.

 

== Корректность ==

Точка <tex>p_0</tex>, очевидно, принадлежит оболочке. На каждом последующем шаге алгоритма мы получаем прямую <tex>p_{i-1}p_i</tex>, по построению которой все точки множества лежат слева от нее. Значит, выпуклая оболочка состоит из <tex>p_{i}</tex>-ых и только из них.

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

Inplace-реализация алгоритма. <tex>S[1..n]</tex> - исходное множество, <tex>n > 2</tex>

Jarvis(S)
find i such that S[i] has the lowest y-coordinate and highest x-coordinate
p0 = S[i]
pi = p0
k = 0
do
k++
for i = k..n
if S[i] has lower angle and higher distance than S[k] in relation to pi
swap(S[i], S[k])
pi = S[k]
while pi != p0
return k

== Сложность ==

Добавление каждой точки в ответ занимает <tex>O(n)</tex> времени, всего точек будет <tex>k</tex>, поэтому итоговая сложность <tex>O(nk)</tex>. В худшем случае, когда оболочка состоит из всех точек сложность <tex>O(n^2)</tex>.

== Ссылки ==

* [http://en.wikipedia.org/wiki/Gift_wrapping_algorithm Английская статья — Wikipedia]
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%94%D0%B6%D0%B0%D1%80%D0%B2%D0%B8%D1%81%D0%B0 Русская статья — Wikipedia]

= Алгоритм Грэхема =

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

== Описание Алгоритма ==

[[File:Graham2.png|thumb|400px|Промежуточный шаг алгоритма. Зелеными линиями обозначена текущая выпуклая оболочка, синими - промежуточные соединения точек, красными - те отрезки, которые раньше входили в оболочку, а сейчас нет. На текущем шаге при добавлении точки <tex>p</tex> последовательно убираем из оболочки точки с <tex>i+3</tex>-ей до <tex>i+1</tex>-ой]]

1)Находим самую правую нижнюю точку множества <tex>p_0</tex>, добавляем в ответ.

2)Сортируем все остальные точки по полярному углу относительно <tex>p_0</tex>.

3)Добавляем в ответ <tex>p_1</tex> - самую первую из отсортированных точек.

4)Берем следующую по счету точку <tex>t</tex>. Пока <tex>t</tex> и две последних точки в текущей оболочке <tex>p_i</tex> и <tex>p_{i-1}</tex> образуют неправый поворот (вектора <tex>p_i t</tex> и <tex>p_{i-1} p_i</tex>), удаляем из оболочки <tex>p_i</tex>.

5)Добавляем в оболочку <tex>t</tex>.

6)Делаем п.5, пока не закончатся точки.

== Корректность ==

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

1)База. Для трех первых точек утверждение, очевидно, выполняется.

2)Переход. Пусть для <tex>i-1</tex> точек оболочки совпадают. Докажем, что и для <tex>i</tex> точек они совпадут.

Рассмотрим истинную оболочку <tex>ch(S \cup {i}) = ch(S) \cup i \setminus P</tex>, где <tex>P</tex> - множество всех точек из <tex>ch(S)</tex>, видимых из <tex>i</tex>. Так как мы добавляли точки в нашу оболочку против часовой стрелки и так как <tex>i</tex>-тая точка лежит в <tex>ch(S \cup i)</tex>, то <tex>P</tex> состоит из нескольких подряд идущих последних добавленных в оболочку точек, и именно их мы удаляем на текущем шаге. Поэтому наша оболочка и истинная для <tex>i</tex> точек совпадают.

Тогда по индукции оболочки совпадают и для <tex>i = n</tex>.

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

Inplace-реализация алгоритма. <tex>S[1..n]</tex> - исходное множество, <tex>n > 2</tex>

Graham(S)
find i such that S[i] has the lowest y-coordinate and highest x-coordinate
swap(S[i], S[1])
sort S[2..n] by angle in relation to S[1]
k = 2
for p = 3..n
while S[k - 1], S[k], S[p] has non-right orientation
k--
swap(S[p], S[k + 1])
return k + 1

== Сложность ==

Сортировка точек занимает <tex>O(n \log n)</tex> времени. При обходе каждая точка добавляется в ответ не более одного раза, поэтому сложность этой части - <tex>O(n)</tex>. Суммарное время - <tex>O(n \log n)</tex>.

== Ссылки ==

* [http://en.wikipedia.org/wiki/Graham_scan Английская статья — Wikipedia]
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%93%D1%80%D1%8D%D1%85%D0%B5%D0%BC%D0%B0 Русская статья — Wikipedia]

= Алгоритм Эндрю =

Алгоритм, очень похожий на алгоритм Грехема. Он заключается в том, что мы находим самую левую и самую правую точки, ищем для точек над и под этой прямой выпуклую оболочку Грехемом - для них начальные точки будут лежать на <tex>\pm inf</tex>, а сортировка по углу относительно далекой точки аналогична сортировке по координате; после этого объединяем две оболочки в одну.

== Описание Алгоритма ==
[[File:andrew1.png|thumb|400px|Промежуточный шаг алгоритма. Зелеными линиями обозначена текущая выпуклая оболочка, синими - промежуточные соединения точек, красными - те отрезки, которые раньше входили в оболочку, а сейчас нет. На текущем шаге при добавлении точки <tex>p</tex> последовательно убираем из оболочки точки с <tex>i+3</tex>-ей до <tex>i+1</tex>-ой]]
1)Находим самую левую и самую правую точки множества - <tex>p_0</tex> и <tex>p_1</tex>.

2)Делим множество на две части: точки над и под прямой.

3)Для каждой половины ищем выпуклую оболочку Грехемом с условием, что сортируем не по полярному углу, а по координате.

4)Сливаем получившиеся оболочки.

 

== Корректность ==

 
См. доказательство алгоритма Грехема.
 

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

Inplace-реализация алгоритма. <tex>S[1..n]</tex> - исходное множество, <tex>n > 2</tex>

Andrew(S)
sort S[1..n] by x-coordinate backward(than by y backward)
k = 2
for p = 3..n
while S[k - 1], S[k], S[p] has non-right orientation
k--
swap(S[p], S[k + 1])
k++
sort S[k + 1..n] by x-coordinate (than by y)
for p = k + 1..n
while S[k - 1], S[k], S[p] has non-right orientation
k--
swap(S[p], S[k + 1])
return k + 1

== Сложность ==

Сортировка точек занимает <tex>O(n \log n)</tex> времени. При обходе каждая точка добавляется в ответ не более одного раза, поэтому сложность двух обходов - <tex> 2 \cdot O(n)</tex>. Суммарное время - <tex>O(n \log n)</tex>.

== Ссылки ==

* [http://en.wikipedia.org/wiki/Graham_scan#Notes Одно предложение о нем]

= Алгоритм Чена =

Является комбинацией двух алгоритмов - Джарвиса и Грехема. Недостатком Грэхема является необходимость сортировки всех точек по полярному углу, что занимает достаточно много времени <tex>O(n \log n)</tex>. Джарвис требует перебора всех точек для каждой из <tex>k</tex> точек оболочки, что в худшем случае занимает <tex>O(n^2)</tex>.

== Описание Алгоритма ==

1)Разобьем все множество на произвольные группы по <tex>m</tex> штук в каждой. Будем считать, что <tex>m</tex> нам известно. Тогда всего групп окажется <tex>r = n / m</tex>.

2)Для каждой группы запускаем Грехема.

3)Начиная с самой нижней точки ищем саму выпуклую оболочку Джарвисом, но перебираем не все точки, а по одной из каждой группы.

== Сложность ==

На втором шаге алгоритма в каждой группе оболочка ищется за <tex>O(m \log m)</tex>, общее время - <tex>O(r m \log m) = O(n \log m)</tex>. На третьем шаге поиск каждой следующей точки в каждой группе занимает <tex>O(\log m)</tex>, так как точки уже отсортированы, и мы можем найти нужную бинпоиском. Тогда поиск по всем группам займет <tex dpi="130">O(r \log m) = O(\frac{n}{m} \log m)</tex>. Всего таких шагов будет <tex>k</tex>, значит общее время - <tex dpi="130">O(\frac{kn}{m} \log m)</tex>.
Итоговое время - <tex>O(n (1 + \frac{k}{m}) \log m)</tex>. Несложно видеть, что минимум достигается при <tex>m = k</tex>. В таком случае сложность равна <tex>O(n \log k)</tex>.

== Поиск <tex>m</tex> ==

Как заранее узнать <tex>k</tex>? Воспользуемся следующим методом. Положим <tex>m = 2^{2^t}</tex>. Начиная с маленьких <tex>m</tex> будем запускать наш алгоритм, причем если на третьем шаге Джарвис уже сделал <tex>m</tex> шагов, то мы выбрали наше <tex>m</tex> слишком маленьким, будем увеличивать, пока не станет <tex>m \ge k</tex>.
Тогда общее время алгоритма - <tex> \sum_{t=0}^{O(\log\log k)} O\left(n \log(2^{2^t})\right) = O(n) \sum_{t=0}^{O(\log\log k)} O(2^t) = O\left(n \cdot 2^{1+O(\log\log k)}\right) = O(n \log k).</tex>

== Ссылки ==

* [http://en.wikipedia.org/wiki/Chan%27s_algorithm Английская статья — Wikipedia]
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A7%D0%B0%D0%BD%D0%B0 Русская статья — Wikipedia]

= Алгоритм QuickHull =

== Описание Алгоритма ==
[[File:hull.png|thumb|250px|Промежуточный шаг алгоритма. Для прямой <tex>p_i p_1</tex> нашли точку <tex>p</tex>. Над прямыми <tex>p_i p</tex> и <tex>p p_1</tex> точек нет, поэтому переходим к следующей прямой <tex>p_0 p_i</tex>.]]

1)Найдем самую левую точку <tex>p_0</tex> и самую правую точку <tex>p_1</tex> (Если таких несколько, выберем среди таких нижнюю и верхнюю соответственно).

2)Возьмем все точки выше прямой <tex>p_0 p_1</tex>.

3)Найдем среди этого множества точку <tex>p_i</tex>, наиболее отдаленную от прямой (если таких несколько, взять самую правую).

4)Рекурсивно повторить шаги 2-3 для прямых <tex>p_0 p_i</tex> и <tex>p_i p_1</tex>, пока есть точки.

5)Добавить в ответ точки <tex>p_0 .. p_i .. p_1</tex>, полученные в п. 3.

6)Повторить пункты 2-5 для <tex>p_1 p_0</tex> (то есть для "нижней" половины).

7)Ответ - объединение списков из п. 5 для верхней и нижней половины.

 

== Корректность ==

[[File:hull1.png|thumb|200px|]]

Очевидно, что выпуклая оболочка всего множества является объединением выпуклых оболочек для верхнего и нижнего множества. Докажем, что алгоритм верно строит оболочку для верхнего множества, для нижнего рассуждения аналогичны.
Точки <tex>p_0</tex> и <tex>p_1</tex> принадлежат оболочке.

* Пусть какая-то точка входит в нашу оболочку, но не должна.

Назовем эту точку <tex>t</tex>. По алгоритму эта точка появилась как самая удаленная от некой прямой <tex>t_1 t_2</tex>. Так как <tex>t</tex> не входит в оболочку, то существует прямая <tex>t_3 t_4</tex> из настоящей выпуклой оболочки, что <tex>t</tex> лежит снизу от прямой. Тогда какая-то из <tex>t_3</tex> и <tex>t_4</tex> удалена от прямой дальше <tex>t</tex>, что противоречит алгоритму.

* Наоборот, пусть какой-то точки <tex>t</tex> в нашей оболочке нет, а должна быть.

Пойдем вниз рекурсии в те ветки, где есть <tex>t</tex>. В какой-то момент <tex>t</tex> окажется внутри некоторого треугольника. Но тогда возникает противоречие с тем, что <tex>t</tex> принадлежит выпуклой оболочке.

Таким образом, наша оболочка совпадает с истинной, а значит алгоритм корректен.

== Реализация ==

Заметим, что длина высоты, опущенная из точки <tex>t</tex> на отрезок <tex>ab</tex>, пропорциональна векторному произведению <tex>[bt \cdot ba]</tex>, поэтому для сравнения можно использовать именно это.

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

Inplace-реализация алгоритма. <tex>S[1..n]</tex> - исходное множество. <tex>quick\_hull()</tex> - рекурсивная функция, находящая оболочку подмножества <tex>S</tex>. В реализации в конце каждого подмножества находятся эл-ты, точно не принадлежащие оболочке.

QuickHull(S)
find i such that S[i] has the highest x-coordinate and lowest y-coordinate
swap(S[1], S[i])
find i such that S[i] has the lowest x-coordinate and lowest y-coordinate
swap(S[n], S[i])
k = partition1(S) // разбиваем на те эл-ты, которые лежат над прямой и на остальные
a = quick_hull(S, 1, k)
b = quick_hull(S, k + 1, n);
swap(S[a..k], S[k + 1, b])
return start + (a - 1) + (b - k - 1) 
quick_hull(S, start, end)
find i such that S[i], S[start], S[end] has maximum value
(a, b) = partition2(S, start, end, S[i]) //свапаем эл-ты S так, чтобы сначала были все эл-ты над прямой S[start]S[i], потом S[i]S[end], потом все остальное
c = quick_hull(S, start, a)
d = quick_hull(S, a + 1, b)
swap(S[c..a], S[a + 1..d])
return start + (a - c) + (d - b)

== Сложность ==

Пусть время, необходимое для нахождения оболочки над некой прямой и множеством точек <tex>S</tex> есть <tex>T(S)</tex>
Тогда <tex>T(S) = O(\|S\|) + T(A \in S) + T(B \in S)</tex>, где <tex>A, B</tex> - множества над полученными прямыми. Отсюда видно, что в худшем случае, алгоритм тратит <tex>O(n^2)</tex>. На рандомных же данных это число равно <tex>O(n \log n)</tex>

== Ссылки ==

* [http://en.wikipedia.org/wiki/QuickHull Английская статья — Wikipedia]

Статические выпуклые оболочки: Джарвис, Грэхем, Эндрю, Чен, QuickHull

2014-02-22T11:10:41Z

194.85.161.34:

{{boring}}
{{ready}}
{{Определение
|definition=Выпуклой оболочкой множества точек называется пересечение всех выпуклых множеств, содержащих все заданные точки.}}

Еще одно определение:
{{Определение
|definition=Выпуклой оболочкой множества точек называется линейная комбинация минимального набора точек, дающая все остальные точки.}}

Ниже приводятся основные алгоритмы построения выпуклых оболочек статического множества. Используются обозначения: <tex>n</tex> - размер входных данных, <tex>k</tex> - размер оболочки.

= Алгоритм Джарвиса =

По-другому "Gift wrapping algorithm" (Заворачивание подарка).
Он заключается в том, что мы ищем выпуклую оболочку последовательно, против часовой стрелки, начиная с определенной точки.

== Описание Алгоритма ==
[[File:Graham1.png|thumb|250px|Промежуточный шаг алгоритма. Для точки <tex>p_i</tex> ищем следующую перебором.]] 
1) Возьмем самую правую нижнюю точку <tex>p_0</tex> нашего множества. Добавляем ее в ответ.

2) На каждом следующем шаге для последнего добавленного <tex>p_i</tex> ищем <tex>p_{i + 1}</tex> среди всех недобавленных точек и <tex>p_0</tex> с максимальным полярным углом относительно <tex>p_i</tex> (Если углы равны, надо сравнивать по расстоянию). Добавляем <tex>p_{i + 1}</tex> в ответ. Если <tex>p_{i + 1} == p_0</tex> , заканчиваем алгоритм.

 

== Корректность ==

Точка <tex>p_0</tex>, очевидно, принадлежит оболочке. На каждом последующем шаге алгоритма мы получаем прямую <tex>p_{i-1}p_i</tex>, по построению которой все точки множества лежат слева от нее. Значит, выпуклая оболочка состоит из <tex>p_{i}</tex>-ых и только из них.

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

Inplace-реализация алгоритма. <tex>S[1..n]</tex> - исходное множество, <tex>n > 2</tex>

Jarvis(S)
find i such that S[i] has the lowest y-coordinate and highest x-coordinate
p0 = S[i]
pi = p0
k = 0
do
k++
for i = k..n
if S[i] has lower angle and higher distance than S[k] in relation to pi
swap(S[i], S[k])
pi = S[k]
while pi != p0
return k

== Сложность ==

Добавление каждой точки в ответ занимает <tex>O(n)</tex> времени, всего точек будет <tex>k</tex>, поэтому итоговая сложность <tex>O(nk)</tex>. В худшем случае, когда оболочка состоит из всех точек сложность <tex>O(n^2)</tex>.

== Ссылки ==

* [http://en.wikipedia.org/wiki/Gift_wrapping_algorithm Английская статья — Wikipedia]
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%94%D0%B6%D0%B0%D1%80%D0%B2%D0%B8%D1%81%D0%B0 Русская статья — Wikipedia]

= Алгоритм Грэхема =

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

== Описание Алгоритма ==

[[File:Graham2.png|thumb|400px|Промежуточный шаг алгоритма. Зелеными линиями обозначена текущая выпуклая оболочка, синими - промежуточные соединения точек, красными - те отрезки, которые раньше входили в оболочку, а сейчас нет. На текущем шаге при добавлении точки <tex>p</tex> последовательно убираем из оболочки точки с <tex>i+3</tex>-ей до <tex>i+1</tex>-ой]]

1)Находим самую правую нижнюю точку множества <tex>p_0</tex>, добавляем в ответ.

2)Сортируем все остальные точки по полярному углу относительно <tex>p_0</tex>.

3)Добавляем в ответ <tex>p_1</tex> - самую первую из отсортированных точек.

4)Берем следующую по счету точку <tex>t</tex>. Пока <tex>t</tex> и две последних точки в текущей оболочке <tex>p_i</tex> и <tex>p_{i-1}</tex> образуют неправый поворот (вектора <tex>p_i t</tex> и <tex>p_{i-1} p_i</tex>), удаляем из оболочки <tex>p_i</tex>.

5)Добавляем в оболочку <tex>t</tex>.

6)Делаем п.5, пока не закончатся точки.

== Корректность ==

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

1)База. Для трех первых точек утверждение, очевидно, выполняется.

2)Переход. Пусть для <tex>i-1</tex> точек оболочки совпадают. Докажем, что и для <tex>i</tex> точек они совпадут.

Рассмотрим истинную оболочку <tex>ch(S \cup {i}) = ch(S) \cup i \setminus P</tex>, где <tex>P</tex> - множество всех точек из <tex>ch(S)</tex>, видимых из <tex>i</tex>. Так как мы добавляли точки в нашу оболочку против часовой стрелки и так как <tex>i</tex>-тая точка лежит в <tex>ch(S \cup i)</tex>, то <tex>P</tex> состоит из нескольких подряд идущих последних добавленных в оболочку точек, и именно их мы удаляем на текущем шаге. Поэтому наша оболочка и истинная для <tex>i</tex> точек совпадают.

Тогда по индукции оболочки совпадают и для <tex>i = n</tex>.

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

Inplace-реализация алгоритма. <tex>S[1..n]</tex> - исходное множество, <tex>n > 2</tex>

Graham(S)
find i such that S[i] has the lowest y-coordinate and highest x-coordinate
swap(S[i], S[1])
sort S[2..n] by angle in relation to S[1]
k = 2
for p = 3..n
while S[k - 1], S[k], S[p] has non-right orientation
k--
swap(S[p], S[k + 1])
return k + 1

== Сложность ==

Сортировка точек занимает <tex>O(n \log n)</tex> времени. При обходе каждая точка добавляется в ответ не более одного раза, поэтому сложность этой части - <tex>O(n)</tex>. Суммарное время - <tex>O(n \log n)</tex>.

== Ссылки ==

* [http://en.wikipedia.org/wiki/Graham_scan Английская статья — Wikipedia]
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%93%D1%80%D1%8D%D1%85%D0%B5%D0%BC%D0%B0 Русская статья — Wikipedia]

= Алгоритм Эндрю =

Алгоритм, очень похожий на алгоритм Грехема. Он заключается в том, что мы находим самую левую и самую правую точки, ищем для точек над и под этой прямой выпуклую оболочку Грехемом - для них начальные точки будут лежать на <tex>\pm inf</tex>, а сортировка по углу относительно далекой точки аналогична сортировке по координате; после этого объединяем две оболочки в одну.

== Описание Алгоритма ==
[[File:andrew1.png|thumb|400px|Промежуточный шаг алгоритма. Зелеными линиями обозначена текущая выпуклая оболочка, синими - промежуточные соединения точек, красными - те отрезки, которые раньше входили в оболочку, а сейчас нет. На текущем шаге при добавлении точки <tex>p</tex> последовательно убираем из оболочки точки с <tex>i+3</tex>-ей до <tex>i+1</tex>-ой]]
1)Находим самую левую и самую правую точки множества - <tex>p_0</tex> и <tex>p_1</tex>.

2)Делим множество на две части: точки над и под прямой.

3)Для каждой половины ищем выпуклую оболочку Грехемом с условием, что сортируем не по полярному углу, а по координате.

4)Сливаем получившиеся оболочки.

 

== Корректность ==

 
См. доказательство алгоритма Грехема.
 

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

Inplace-реализация алгоритма. <tex>S[1..n]</tex> - исходное множество, <tex>n > 2</tex>

Andrew(S)
sort S[1..n] by x-coordinate backward(than by y backward)
k = 2
for p = 3..n
while S[k - 1], S[k], S[p] has non-right orientation
k--
swap(S[p], S[k + 1])
k++
sort S[k + 1..n] by x-coordinate (than by y)
for p = k + 1..n
while S[k - 1], S[k], S[p] has non-right orientation
k--
swap(S[p], S[k + 1])
return k + 1

== Сложность ==

Сортировка точек занимает <tex>O(n \log n)</tex> времени. При обходе каждая точка добавляется в ответ не более одного раза, поэтому сложность двух обходов - <tex> 2 \cdot O(n)</tex>. Суммарное время - <tex>O(n \log n)</tex>.

== Ссылки ==

* [http://en.wikipedia.org/wiki/Graham_scan#Notes Одно предложение о нем]

= Алгоритм Чена =

Является комбинацией двух алгоритмов - Джарвиса и Грехема. Недостатком Грэхема является необходимость сортировки всех точек по полярному углу, что занимает достаточно много времени <tex>O(n \log n)</tex>. Джарвис требует перебора всех точек для каждой из <tex>k</tex> точек оболочки, что в худшем случае занимает <tex>O(n^2)</tex>.

== Описание Алгоритма ==

1)Разобьем все множество на произвольные группы по <tex>m</tex> штук в каждой. Будем считать, что <tex>m</tex> нам известно. Тогда всего групп окажется <tex>r = n / m</tex>.

2)Для каждой группы запускаем Грехема.

3)Начиная с самой нижней точки ищем саму выпуклую оболочку Джарвисом, но перебираем не все точки, а по одной из каждой группы.

== Сложность ==

На втором шаге алгоритма в каждой группе оболочка ищется за <tex>O(m \log m)</tex>, общее время - <tex>O(r m \log m) = O(n \log m)</tex>. На третьем шаге поиск каждой следующей точки в каждой группе занимает <tex>O(\log m)</tex>, так как точки уже отсортированы, и мы можем найти нужную бинпоиском. Тогда поиск по всем группам займет <tex dpi="130">O(r \log m) = O(\frac{n}{m} \log m)</tex>. Всего таких шагов будет <tex>k</tex>, значит общее время - <tex dpi="130">O(\frac{kn}{m} \log m)</tex>.
Итоговое время - <tex>O(n (1 + \frac{k}{m}) \log m)</tex>. Несложно видеть, что минимум достигается при <tex>m = k</tex>. В таком случае сложность равна <tex>O(n \log k)</tex>.

== Поиск <tex>m</tex> ==

Как заранее узнать <tex>k</tex>? Воспользуемся следующим методом. Положим <tex>m = 2^{2^t}</tex>. Начиная с маленьких <tex>m</tex> будем запускать наш алгоритм, причем если на третьем шаге Джарвис уже сделал <tex>m</tex> шагов, то мы выбрали наше <tex>m</tex> слишком маленьким, будем увеличивать, пока не станет <tex>m \ge k</tex>.
Тогда общее время алгоритма - <tex> \sum_{t=0}^{O(\log\log k)} O\left(n \log(2^{2^t})\right) = O(n) \sum_{t=0}^{O(\log\log k)} O(2^t) = O\left(n \cdot 2^{1+O(\log\log k)}\right) = O(n \log k).</tex>

== Ссылки ==

* [http://en.wikipedia.org/wiki/Chan%27s_algorithm Английская статья — Wikipedia]
* [http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A7%D0%B0%D0%BD%D0%B0 Русская статья — Wikipedia]

= Алгоритм QuickHull =

== Описание Алгоритма ==
[[File:hull.png|thumb|250px|Промежуточный шаг алгоритма. Для прямой <tex>p_i p_1</tex> нашли точку <tex>p</tex>. Над прямыми <tex>p_i p</tex> и <tex>p p_1</tex> точек нет, поэтому переходим к следующей прямой <tex>p_0 p_i</tex>.]]

1)Найдем самую левую точку <tex>p_0</tex> и самую правую точку <tex>p_1</tex> (Если таких несколько, выберем среди таких нижнюю и верхнюю соответственно).

2)Возьмем все точки выше прямой <tex>p_0 p_1</tex>.

3)Найдем среди этого множества точку <tex>p_i</tex>, наиболее отдаленную от прямой (если таких несколько, взять самую правую).

4)Рекурсивно повторить шаги 2-3 для прямых <tex>p_0 p_i</tex> и <tex>p_i p_1</tex>, пока есть точки.

5)Добавить в ответ точки <tex>p_0 .. p_i .. p_1</tex>, полученные в п. 3.

6)Повторить пункты 2-5 для <tex>p_1 p_0</tex> (то есть для "нижней" половины).

7)Ответ - объединение списков из п. 5 для верхней и нижней половины.

 

== Корректность ==

[[File:hull1.png|thumb|200px|]]

Очевидно, что выпуклая оболочка всего множества является объединением выпуклых оболочек для верхнего и нижнего множества. Докажем, что алгоритм верно строит оболочку для верхнего множества, для нижнего рассуждения аналогичны.
Точки <tex>p_0</tex> и <tex>p_1</tex> принадлежат оболочке.

* Пусть какая-то точка входит в нашу оболочку, но не должна.

Назовем эту точку <tex>t</tex>. По алгоритму эта точка появилась как самая удаленная от некой прямой <tex>t_1 t_2</tex>. Так как <tex>t</tex> не входит в оболочку, то существует прямая <tex>t_3 t_4</tex> из настоящей выпуклой оболочки, что <tex>t</tex> лежит снизу от прямой. Тогда какая-то из <tex>t_3</tex> и <tex>t_4</tex> удалена от прямой дальше <tex>t</tex>, что противоречит алгоритму.

* Наоборот, пусть какой-то точки <tex>t</tex> в нашей оболочке нет, а должна быть.

Пойдем вниз рекурсии в те ветки, где есть <tex>t</tex>. В какой-то момент <tex>t</tex> окажется внутри некоторого треугольника. Но тогда возникает противоречие с тем, что <tex>t</tex> принадлежит выпуклой оболочке.

Таким образом, наша оболочка совпадает с истинной, а значит алгоритм корректен.

== Реализация ==

Заметим, что длина высоты, опущенная из точки <tex>t</tex> на отрезок <tex>ab</tex>, пропорциональна векторному произведению <tex>[bt \cdot ba]</tex>, поэтому для сравнения можно использовать именно это.

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

Inplace-реализация алгоритма. <tex>S[1..n]</tex> - исходное множество. <tex>quick\_hull()</tex> - рекурсивная функция, находящая оболочку подмножества <tex>S</tex>. В реализации в конце каждого подмножества находятся эл-ты, точно не принадлежащие оболочке.

QuickHull(S)
find i such that S[i] has the highest x-coordinate and lowest y-coordinate
swap(S[1], S[i])
find i such that S[i] has the lowest x-coordinate and lowest y-coordinate
swap(S[n], S[i])
k = partition1(S) // разбиваем на те эл-ты, которые лежат над прямой и на остальные
a = quick_hull(S, 1, k)
b = quick_hull(S, k + 1, n);
swap(S[a..k], S[k + 1, b])
return start + (a - 1) + (b - k - 1) 
quick_hull(S, start, end)
find i such that S[i], S[start], S[end] has maximum value
(a, b) = partition2(S, start, end, S[i]) //свапаем эл-ты S так, чтобы сначала были все эл-ты над прямой S[start]S[i], потом S[i]S[end], потом все остальное
c = quick_hull(S, start, a)
d = quick_hull(S, a + 1, b)
swap(S[c..a], S[a + 1..d])
return start + (a - c) + (d - b)

== Сложность ==

Пусть время, необходимое для нахождения оболочки над некой прямой и множеством точек <tex>S</tex> есть <tex>T(S)</tex>
Тогда <tex>T(S) = O(\|S\|) + T(A \in S) + T(B \in S)</tex>, где <tex>A, B</tex> - множества над полученными прямыми. Отсюда видно, что в худшем случае, алгоритм тратит <tex>O(n^2)</tex>. На рандомных же данных это число равно <tex>O(n \log n)</tex>

== Ссылки ==

* [http://en.wikipedia.org/wiki/QuickHull Английская статья — Wikipedia]

Алгоритм Балабана

2013-11-30T08:08:24Z

194.85.161.34: /* Ключевые моменты */ - заменил скобки в картинке

{{В разработке}}

'''Алгоритм Балабана''' {{---}} детерминированный алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются. 

==Введение==

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

# Тривиальный детерминированный алгоритм имеет временную сложность <tex>O(n^2)</tex>, и его суть заключается в проверке попарного пересечения отрезков.
# Сложнее, но эффективнее алгоритм Бентли-Оттмана <ref>[http://neerc.ifmo.ru/wiki/index.php?title=Алгоритм_Бентли-Оттмана ''Алгоритм Бентли-Оттмана'']</ref> с оценкой сложности <tex>O((n + k)\ log(n)+k)</tex>, в основе которого лежит метод заметающей прямой.
# Алгоритм, предложенный Чазелле и Едельсбруннером <ref>[http://www.cs.princeton.edu/~chazelle/pubs/IntersectLineSegments.pdf ''An optimal algorithm for intersecting line segments in the plane'']</ref>, имеет лучшую оценку <tex>O(n\ log(n) + k)</tex>, но в отличие от предыдущих методов требует квадратичной памяти.
# Оптимальный детерминированный алгоритм был предложен Балабаном <ref>[http://www.cs.sfu.ca/~binay/813.2011/Balaban.pdf ''I.J. Balaban. An optimal algorithm for finding segments intersections. In Proceedings of the Eleventh Annual Symposium on Computational Geometry, ACM Press, New York, 1995. - pp. 211–219.'']</ref> с временной оценкой сложности <tex>O(n\ log(n) + k)</tex> и <tex>O(n)</tex> памяти, где К - число пересекающихся отрезков.

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

==Основные понятия==

Введем некоторые обозначения. Пусть <tex>Int(S)</tex> - множество всех точек пересечения отрезков из множества <tex>S</tex>, а <tex>K = |Int(S)|</tex> - количество таких пересечений ; 
Через <tex>\langle a, b \rangle</tex> обозначим вертикальную полосу, которая ограничена прямыми <tex>x = a</tex> и <tex>x = b</tex>, а через <tex>s</tex> {{---}} отрезок с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex>. 
Рассмотрим взаимное расположение вертикальной полосы <tex>\langle a, b \rangle</tex> и отрезка <tex>s</tex>.

{{Определение
|definition=
Будем говорить, что отрезок <tex>s</tex>, с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex> :
{{---}} '''охватывает''' (''span'') полосу <tex>\langle a, b \rangle</tex>, если <tex>l \le a \le b \le r</tex>; 

{{---}} '''внутренний''' (''inner'') для полосы <tex>\langle a, b \rangle</tex>, если <tex>a < l < r < b</tex>; 

{{---}} '''пересекает''' (''cross'') полосу <tex>\langle a, b \rangle</tex> в других случаях.
}}

{{Определение
|definition=
Два отрезка <tex>s_1</tex> и <tex>s_2</tex> называются ''пересекающимися внутри'' полосы <tex>\langle a, b \rangle</tex>, если их точка пересечения лежит в пределах этой полосы. 

Для двух множеств отрезков <tex>S</tex> и <tex>S'</tex> определим множество <tex>Int(S, S')</tex> как <tex>\{ {s, s'} | (s \in S, s' \in S') \& (s \ intersect \ s') \}</tex>.
}}
[[Файл:Balaban_pic_1.png|280px|thumb|right|<tex>D = ((s_1, s_2, s_3), \langle a, b \rangle)</tex>, <tex>Loc(D, s_4) = 0</tex>, <tex>Loc(D, s_5) = 2</tex> или <tex>3</tex>, <tex>Int(D, \{s_4,\ s_5\}) = \{\{s_3,\ s_5\}\}</tex>]]

Обозначения <tex>Int_{a, b}(S)</tex> и <tex>Int_{a, b}(S, S')</tex> будут использоваться для описания подмножеств <tex>Int(S)</tex> и <tex>Int(S, S')</tex>, состоящих из пересекающихся пар отрезков в пределах полосы <tex>\langle a, b \rangle</tex>.

Далее фигурные скобки <tex>\{\}</tex> используются для определения неупорядоченных множеств, а круглые скобки <tex>()</tex> используются для определения упорядоченных множеств.

{{Определение
|neat=neat
|definition=
Введем отношение порядка на множестве отрезков <tex>s_1 <_a s_2</tex> если оба отрезка пересекают вертикальную линию <tex>x = a</tex> и точка пересечения этой прямой с отрезком <tex>s_1</tex> лежит ниже точки пересечения с <tex>s_2</tex>.
}}

{{Определение
|neat=neat
|definition=
''Лестница'' <tex>D</tex> — это пара <tex>(Q, \langle a, b \rangle)</tex>, в которой отрезки из множества <tex>Q</tex> удовлетворяют следующим условиям :
{{---}} любой отрезок из <tex>Q</tex> охватывает полосу <tex>\langle a, b \rangle</tex>; 
{{---}} нет пересечений отрезков внутри лестницы; 
{{---}} <tex>Q</tex> упорядочена по отношению <tex><_a</tex>.

Часть отрезков лестницы внутри полосы будем называть '''ступеньками'''.
}}

{{Определение
|definition=
Будем называть лестницу <tex>D</tex> '''полной''' относительно множества отрезков <tex>S</tex>, если каждый отрезок из <tex>S</tex> либо не охватывает полосу <tex>\langle a, b \rangle</tex>, либо пересекает хотя бы одну из ступенек из множества <tex>D</tex>.
}}

{{Лемма
|id=lemma1
|statement=
Пусть лестница <tex>D</tex> полна относительно множества отрезков <tex>S</tex>, где <tex>S</tex> состоит из отрезков, пересекающих полосу <tex>\langle a, b \rangle</tex>, тогда <tex>|S| \le Ends_{a, b}(S) + |Int(D, S)|</tex>, 
где <tex>Ends_{a, b}(S)</tex> это число вершин отрезков из <tex>S</tex>, находящихся в пределах полосы <tex>\langle a, b \rangle</tex>.
}}

{{Определение
|definition=
Если точка <tex>p</tex> отрезка <tex>s</tex> лежит между ступеньками <tex>i</tex> и <tex>i + 1</tex>, тогда число <tex>i</tex> называется ''местоположением'' <tex>s</tex> на лестнице <tex>D</tex> и обозначается как <tex>Loc(D, s)</tex>
}}

{{Утверждение
|statement=
Имея лестницу <tex>D = (Q, \langle a, b \rangle)</tex> и множество отрезков <tex>S</tex>, множество <tex>Int(D, S)</tex> можно найти за время <tex>O(|S| log|Q| + |Int(D, S)|)</tex>. 
Однако, если <tex>S’</tex> упорядочено отношением <tex><_x</tex>, где <tex>x \in [a, b]</tex>, тогда можно найти <tex>Int(D, S)</tex> за время <tex>O(|S| + |Q| + |Int(D, S)|)</tex>.
}}

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

Введем несколько дополнительных функций, чтобы упростить основной алгоритм:

===Split===

Функция <tex>Split</tex> разделяет входное множество отрезков <tex>L</tex>, охватывающих некоторую полосу <tex>\langle a, b \rangle</tex>, на подмножества <tex>Q</tex> и <tex>L'</tex> так, что лестница <tex>(Q, \langle a, b \rangle)</tex> полна относительно множества отрезков <tex>L'</tex>.

Пусть <tex>L = (s_1 ,..., s_k)</tex>, где <tex>s_i <_a s_{i+1}</tex>
<tex>Split_{a, b}(L, Q, L')</tex>
<tex>\{</tex>
<tex>L' \leftarrow \varnothing; Q \leftarrow \varnothing</tex>
'''for''' <tex>j = 1,...,k</tex> '''do'''
'''if''' отрезок <tex>S_j</tex> не пересекает
последний отрезок из <tex>Q</tex> внутри полосы <tex>\langle a, b \rangle</tex>
и при этом охватывает её '''then'''
добавить <tex>s_j</tex> в конец <tex>Q;</tex>
'''else'''
добавить <tex>s_j</tex> в конец <tex>L';</tex>
<tex>\}</tex>

Эта функция работает за <tex>O(|L|)</tex> времени.

===Search In Strip===

Зная <tex>L</tex> мы можем найти <tex>Int_{a, b}(L)</tex> и <tex>R</tex> используя следующую рекурсивную функцию:

<tex>SearchInStrip_{a, b}(L, R)</tex>
<tex>\{</tex>
<tex>Split(L, Q, L');</tex>
'''if''' <tex>L' = \varnothing</tex> '''then'''
<tex>R \leftarrow Q;</tex>
'''return'''<tex>;</tex>
Найдем <tex>Int_{a, b}(Q, L');</tex>
<tex>SearchInStrip_{a, b} (L', R');</tex>
<tex>R \leftarrow Merge_b(Q, R’);</tex>
<tex>\}</tex>

Здесь, <tex>Merge_x(S_1, S_2)</tex> это функция объединения множеств <tex>S_1</tex> и <tex>S_2</tex>, упорядоченных по отношению <tex><_x</tex>. Время выполнения <tex>SearchInStrip</tex> эквивалентно сумме времён каждого её запуска. Очевидно, что время работы <tex>i</tex>-той функции, будет равно <tex>O(|L_i| + |Int_{a, b}(Q_i, {L_i}')|)</tex>, где <tex>L_i, Q_i, {L_i}'</tex> это соответствующие наборы <tex>(L_0 = L, L_{i+1} = {L_i}')</tex>.

Учитывая [[#lemma1|лемму]], заключаем, что функция <tex>SearchInStrip_{a, b}(L, R)</tex> работает за <tex>O(|L| + |Int_{a, b}(L)|)</tex>.

Предположим, что все отрезки лежат в полосе <tex>\langle a, b\rangle</tex>. Таким образом в самом начале у нас есть пара <tex>(S, \langle a, b\rangle)</tex>.
Что же дальше происходит: множество <tex>S</tex> ''распадается'' в подмножества <tex>Q</tex> и <tex>S'</tex>, после чего лестница <tex>D = (Q, \langle a, b \rangle)</tex> становится полной относительно множества <tex>S'</tex>. Необходимо найти пересечения отрезков из <tex>D</tex> и <tex>S'</tex>, затем, все пересечения в <tex>S'</tex>. Чтобы найти пересечения отрезков в <tex>S'</tex>, мы ''режем'' полосу <tex>\langle a, b \rangle</tex> и множество <tex>S'</tex> по вертикале <tex>x = c</tex> на полосы <tex>\langle a, c \rangle</tex>, <tex>\langle c, b \rangle</tex> и множества <tex>S'_{ls}</tex>, <tex>S'_{rs}</tex> соответственно, где <tex>c</tex> является медианой вершин отрезков между <tex>a</tex> и <tex>b</tex>. Затем мы рекурсивно вызываем функцию к парам <tex>(S'_{ls}, \langle a, c \rangle)</tex> и <tex>(S'_{rs}, \langle c, b \rangle)</tex>. Ключевым является тот факт, что согласно [[#lemma1|лемме]] <tex>|S'| \le Ends_{a, b}(S') + |Int(D, S')|</tex>, таким образом, число дополнительных отрезков, появляющихся после ''разрезаний'' пропорционально числу найденных пересечений.

===Ключевые моменты===

Давайте разберемся с алгоритмом более подробно:

Не умаляя общности, предположим, что все пересечения и вершины отрезков имеют разные абсциссы (в конечном счете, их можно будет отсортировать введением дополнительных свойств). Будем рассматривать целые координаты на промежутке <tex>[1, 2N]</tex>. Обозначим через <tex>p_i</tex> слева направо конец отрезка множества <tex>S_0</tex>, а через <tex>s(i)</tex> отрезок, которому он принадлежит соответственно.

Основная задача нашего алгоритма, это рекурсивная функция <tex>TreeSearch</tex>. Соединим каждый вызов функции с узлом некоего двоичного дерева (далее ''рекурсивное дерево''). Соответствующим узлом отметим все значения, множества и параметры вызова. Обозначим множество внутренних вершин за <tex>V</tex>.

<tex>IntersectingPairs(S_0):</tex>
Отсортируем <tex>2 \cdot N</tex> вершин по координатам и
найдем <tex>p_i, s(i), i = 1,...,2 \cdot N;\ S_r \leftarrow S_0</tex>
<tex>TreeSearch(S_r, 1, 2 \cdot N)</tex>;

<tex>TreeSearch(S_v, a, b):</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>L \leftarrow</tex> отсортируем <tex>S_v</tex> по отношению <tex><_a</tex>;
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
Разделим <tex>S_v</tex> на <tex>Q_v</tex> и <tex>S_v'</tex> так, что лестница
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex> будет полной, относительно множества <tex>S_v'</tex>;
Найдем <tex>Int(D_v, S_v')</tex>;
<tex>c \leftarrow \lfloor (a + b)/2 \rfloor</tex>;
Разделим отрезки из <tex>S_v'</tex> на пересекающих
полосу <tex>\langle a, c \rangle</tex> <tex>S_{ls}(v)</tex> и
полосу <tex>\langle c, b \rangle</tex> <tex>S_{rs}(v)</tex>;
<tex>TreeSearch(S_{ls}(v), a, c)</tex>;
<tex>TreeSearch(S_{rs}(v), c, b)</tex>;
<tex>\}</tex>

Отсюда и дальше <tex>ls(v)</tex>, <tex>rs(v)</tex> и <tex>ft(v)</tex> означают, соответственно, левого сына, правого сына, и отцовскую вершину узла <tex>v</tex>.
Наша задача показать, что все операции с узлом <tex>v</tex> происходят за <tex>O(|S_v| + |Int(D_v, S_v')| + (a_v - b_v)logN)</tex>, для этого возьмем во внимание, что <tex>\sum_v |S_v| = O(N \cdot logN + K)</tex> (очевидно, что <tex>\sum_v |Int(D_v, S_v')| \le K</tex>).

[[Файл:Balaban_pic_2.png|280px|thumb|right|<tex>S_v = \{s_1, s_2, s_3, s_4, s_5\}</tex>, <tex>L_v = (s_1, s_3)</tex>, <tex>R_v = (s_4, s_3)</tex>, <tex>I_v = \{s_2, s_5\}</tex>]]

Функция <tex>TreeSearch</tex> похожа на функцию <tex>SearchInStrip</tex>. Основная разница заключается в том, что <tex>SearchInStrip</tex> вызывает себя без изменения полосы, когда <tex>TreeSearch</tex> делит полосу на две части, после чего рекурсивно вызывает себя для них. Другое отличие заключается в том, что множество <tex>S_v</tex> не упорядочено так же, как <tex>L</tex>. В результате мы не можем напрямую использовать функцию <tex>Split</tex> для эффективного деления <tex>S_v</tex>.

Чтобы решить эту проблему, представим <tex>S_v</tex> как объединение трех множеств:
множества <tex>L_v</tex> упорядоченного по отношению <tex><_a</tex>, неупорядоченного множества <tex>I_v</tex>, и множества <tex>R_v</tex> упорядоченного по отношению <tex><_b</tex>. Расположим отрезки из <tex>S_v</tex>, пересекающие границу <tex>x = a</tex> во множество <tex>L_v</tex>, отрезки пересекающие <tex>x = b</tex> во множество <tex>R_v</tex>, и внутренние отрезки во множество <tex>I_v</tex> (пример на ''рисунке справа'').

Теперь мы можем вызвать функцию <tex>Split</tex> для множества <tex>L_v</tex> и построить <tex>Q_v</tex> за <tex>O(|L_v|) = O(|S_v|)</tex> времени. Но мы натыкаемся на новую проблему: передавая множества <tex>L_v</tex>, <tex>I_v</tex> и <tex>R_v</tex>, необходимо найти соответствующие множества сыновей узла <tex>v</tex>.

Неупорядоченные множества <tex>I_{ls(v)}</tex> и <tex>I_{rs(v)}</tex> строятся легко. Множество <tex>L_{ls(v)}</tex> будет найдено вызовом функции <tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex> для нахождения <tex>Int(D_v, S_v')</tex> в функции <tex>TreeSearch</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> за линейное время вставкой (если <tex>p_c</tex> левая вершина отрезка) или удалением (если <tex>p_c</tex> правая вершина отрезка) отрезка <tex>s(c)</tex>. Но как получить <tex>R_{ls(v)}</tex> из <tex>L_v</tex>, <tex>R_v</tex> и <tex>I_v</tex> без сортировки?

Для листьев мы сделаем проверку вначале, и получим <tex>R_v</tex> из <tex>L_v</tex>. Пусть <tex>L_v</tex> и <tex>I_v</tex> известны, и все сыновья узла <tex>v</tex> - листья. Для начала запустим функцию <tex>Split(L_v, Q_v, L_{ls(v)})</tex> и найдем <tex>Q_v</tex> и <tex>L_{ls(v)}</tex>. Теперь мы должны найти <tex>Int(D_s, S_v') = Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v) \cup Int(D_v, R_{rs(v)})</tex>, но мы не знаем <tex>R_{rs(v)}</tex> и, соответственно, можем найти только <tex>Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v)</tex>. Применим <tex>SearchInStrip</tex> к множеству <tex>L_{ls(v)}</tex> и получим <tex>R_{ls(v)}</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> вставкой или удалением отрезка <tex>s(c)</tex>. Применим <tex>SearchInStrip</tex> к <tex>L_{rs(v)}</tex> и найдем <tex>R_{rs(v)}</tex>. Теперь можем продолжить вычисление <tex>Int(D_v, R_{rs(v)})</tex> и получим <tex>R_v</tex> слиянием <tex>Q_v</tex> и <tex>R_{rs(v)}</tex>.

Конечная функция будет выглядеть так:
<tex>IntersectingPairs(S_0)</tex>
<tex>\{</tex>
Отсортируем <tex>2N</tex> концов отрезков по абсциссе
и найдем <tex>p_i</tex>, <tex>s(i)</tex> где <tex>i = 1, ..., 2N</tex>;
<tex>L_r \leftarrow (s(1))</tex>; <tex>I_r \leftarrow S_0 \setminus (\{s(1)\} \cup \{s(2N)\})</tex>;
<tex>TreeSearch(L_r, I_r, 1, 2N, R_r)</tex>;
<tex>\}</tex>

<tex>TreeSearch(L_v, I_v, a, b, R_v)</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
<tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex>;
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex>;
Найдем <tex>Int(D_v, L_{ls(v)})</tex>;
<tex>c \leftarrow \lfloor (a + b) / 2 \rfloor</tex>;
Разделяем отрезки из <tex>I_v</tex>
внутренние для полосы <tex>\langle a, c \rangle</tex> во множество <tex>I_{ls(v)}</tex>
внутренние для полосы <tex>\langle c, b \rangle</tex> во множество <tex>I_{rs(v)}</tex>
<tex>TreeSearch(L_{ls(v)}, I_{ls(v)}, a, c, R_{ls(v)})</tex>;
'''if''' <tex>p_c</tex> левый конец отрезка <tex>s(c)</tex> '''then'''
<tex>L_{rs(v)} \leftarrow</tex> вставить <tex>s(c)</tex> в <tex>R_{ls(v)}</tex>
'''else'''
<tex>L_{rs(v)} \leftarrow</tex> удалить <tex>s(c)</tex> из <tex>R_{ls(v)}</tex>
<tex>TreeSearch(L_{rs(v)}, I_{rs(v)}, c, b, R_{rs(v)})</tex>;
Найдем <tex>Int(D_v, R_{rs(v)})</tex>;
'''for''' <tex>s \in I_v</tex> '''do'''
Найдем <tex>Loc(D_v, s)</tex> используя двоичный поиск;
Найдем <tex>Int(D_v, I_v)</tex> используя значения, полученные шагом выше;
<tex>R_v \leftarrow Merge_b(Q_v, R_{rs(v)})</tex>;
<tex>\}</tex>

Заметим, что нахождение <tex>Int(D_v, R_{rs(v)})</tex> надо делать аккуратно, так как множества <tex>R_{rs(v)}</tex> и <tex>L_{ls(v)}</tex> могут иметь одни и те же отрезки (которые '''пересекают''' <tex>\langle a, b \rangle</tex>). Мы нашли их пересечения с <tex>D_v</tex> при поиске <tex>Int(D_v, L_{ls(v)})</tex>, и не должны вывести эти пересечения снова.

==Время работы==

Для начала рассчитаем место, необходимое для выполнения алгоритма. Алгоритм использует рекурсивную функцию <tex>TreeSearch</tex>. Последовательность вызовов функции может занять память. Эта последовательность может быть представлена как путь корня рекурсивного дерева, до узла. Соответствующий вызов этого узла занимает <tex>O(N)</tex> памяти, каждый его "предок" занимает <tex>O(|I_v| + |Q_v|)</tex> памяти, а остальные структуры используют <tex>O(N)</tex>. Очевидно, что любой путь <tex>pt</tex> от корня рекурсивного дерева до какого-то узла <tex>\sum_{v \in pt}(|I_v + |Q_v|) = O(N)(|I_v| \le b_v - a_v \le \lceil (b_{ft(v)} - a_{ft(v)})/2 \rceil)</tex>.

В итоге для работы алгоритма требуется <tex>O(N)</tex> памяти.

{{Лемма
|id=lemma2
|about=
#2
|statement=
<tex>\forall v \in V \ |S_v'| \le a_v - b_v + |Int(D_v, S_v')|</tex>.
|proof=
Утверждение напрямую вытекает из [[#lemma1|первой леммы]] и очевидного факта, что для любого множества <tex>S \subset S_0</tex>, количество концов отрезков, лежащих в полосе <tex>\langle a_v, b_v \rangle</tex>, меньше чем <tex>b_v - a_v</tex>.
}}

{{Теорема
|about=
#1
|statement=
<tex>\sum_{v \in V} |S_v'| \le 2N \lceil logN + 1 \rceil + K</tex>
|proof=
Утверждение напрямую вытекает из [[#lemma2|леммы №2]] и следующего отношения <tex>\sum_v (b_v - a_v) \le 2N \lceil logN + 1 \rceil</tex>.
}}

Обозначим множество всех вершин рекурсивного дерева за <tex>RT</tex>.

{{Теорема
|about=
#2
|statement=
<tex>\sum_{v \in RT} |S_v| \le N \lceil 4logN + 5 \rceil + 2K</tex>
|proof=
Для всех узлов, кроме корня <tex>r</tex> имеет место выражение <tex>|S_v| \le |S_{ft(v)}'|</tex>, следовательно <tex>\sum_{v \in RT} |S_v| \le |S_r| + \sum_{v \in RT \setminus r} |S_{ft(v)}| \le N + 2 \sum_{v \in V} |S_v'| \le N \lceil 4 logN + 5 \rceil + 2K</tex>.
}}

Начальная сортировка и инициализация множеств <tex>L_r</tex> и <tex>I_r</tex> может быть произведена за <tex>O(N logN)</tex> времени. Время работы функции <tex>TreeSearch</tex> является суммой длительностей всех его вызовов. Каждый вызов от внешних узлов добавляет к этой сумме <tex>O(|L_v| + |Int_{a, b}(L_v)|)</tex>. Для внутренних же узлов, время требуемое для поиска <tex>Loc(D_v, s)</tex> равно <tex>O(|I_v| log N)</tex>, а для остальных <tex>O(|S_v| + |Int(D_v, S_v')|)</tex>. Если мы все это сложим, то придем к выводу, что наш алгоритм работает за <tex>O(N log^2 N + K)</tex>. Заметим, что его скорость можно увеличить до <tex>O(N logN + K)</tex>, если не будем учитывать время нахождения <tex>Loc(D_v, s)</tex>.

Соответственно в оптимальном алгоритме Балабана <tex>Loc(D_v, s)</tex> находится за <tex>O(1)</tex>.

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

<references/>

==Литература==

[http://www.graphicon.ru/proceedings/2010/conference/RU/Se4/021.pdf ''Т.Вознюк, В.Терещенко {{---}} К построению эффективного решения задачи пересечения отрезков''] 
[http://booksshare.net/books/math/preparata-f/1989/files/vichgeometr.pdf ''Ф.Препарата, М.Шеймос {{---}} Вычислительная геометрия''] 

[[Категория: Вычислительная геометрия]]

Алгоритм Балабана

2013-11-30T08:03:34Z

194.85.161.34: /* Основные понятия */

{{В разработке}}

'''Алгоритм Балабана''' {{---}} детерминированный алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются. 

==Введение==

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

# Тривиальный детерминированный алгоритм имеет временную сложность <tex>O(n^2)</tex>, и его суть заключается в проверке попарного пересечения отрезков.
# Сложнее, но эффективнее алгоритм Бентли-Оттмана <ref>[http://neerc.ifmo.ru/wiki/index.php?title=Алгоритм_Бентли-Оттмана ''Алгоритм Бентли-Оттмана'']</ref> с оценкой сложности <tex>O((n + k)\ log(n)+k)</tex>, в основе которого лежит метод заметающей прямой.
# Алгоритм, предложенный Чазелле и Едельсбруннером <ref>[http://www.cs.princeton.edu/~chazelle/pubs/IntersectLineSegments.pdf ''An optimal algorithm for intersecting line segments in the plane'']</ref>, имеет лучшую оценку <tex>O(n\ log(n) + k)</tex>, но в отличие от предыдущих методов требует квадратичной памяти.
# Оптимальный детерминированный алгоритм был предложен Балабаном <ref>[http://www.cs.sfu.ca/~binay/813.2011/Balaban.pdf ''I.J. Balaban. An optimal algorithm for finding segments intersections. In Proceedings of the Eleventh Annual Symposium on Computational Geometry, ACM Press, New York, 1995. - pp. 211–219.'']</ref> с временной оценкой сложности <tex>O(n\ log(n) + k)</tex> и <tex>O(n)</tex> памяти, где К - число пересекающихся отрезков.

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

==Основные понятия==

Введем некоторые обозначения. Пусть <tex>Int(S)</tex> - множество всех точек пересечения отрезков из множества <tex>S</tex>, а <tex>K = |Int(S)|</tex> - количество таких пересечений ; 
Через <tex>\langle a, b \rangle</tex> обозначим вертикальную полосу, которая ограничена прямыми <tex>x = a</tex> и <tex>x = b</tex>, а через <tex>s</tex> {{---}} отрезок с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex>. 
Рассмотрим взаимное расположение вертикальной полосы <tex>\langle a, b \rangle</tex> и отрезка <tex>s</tex>.

{{Определение
|definition=
Будем говорить, что отрезок <tex>s</tex>, с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex> :
{{---}} '''охватывает''' (''span'') полосу <tex>\langle a, b \rangle</tex>, если <tex>l \le a \le b \le r</tex>; 

{{---}} '''внутренний''' (''inner'') для полосы <tex>\langle a, b \rangle</tex>, если <tex>a < l < r < b</tex>; 

{{---}} '''пересекает''' (''cross'') полосу <tex>\langle a, b \rangle</tex> в других случаях.
}}

{{Определение
|definition=
Два отрезка <tex>s_1</tex> и <tex>s_2</tex> называются ''пересекающимися внутри'' полосы <tex>\langle a, b \rangle</tex>, если их точка пересечения лежит в пределах этой полосы. 

Для двух множеств отрезков <tex>S</tex> и <tex>S'</tex> определим множество <tex>Int(S, S')</tex> как <tex>\{ {s, s'} | (s \in S, s' \in S') \& (s \ intersect \ s') \}</tex>.
}}
[[Файл:Balaban_pic_1.png|280px|thumb|right|<tex>D = ((s_1, s_2, s_3), \langle a, b \rangle)</tex>, <tex>Loc(D, s_4) = 0</tex>, <tex>Loc(D, s_5) = 2</tex> или <tex>3</tex>, <tex>Int(D, \{s_4,\ s_5\}) = \{\{s_3,\ s_5\}\}</tex>]]

Обозначения <tex>Int_{a, b}(S)</tex> и <tex>Int_{a, b}(S, S')</tex> будут использоваться для описания подмножеств <tex>Int(S)</tex> и <tex>Int(S, S')</tex>, состоящих из пересекающихся пар отрезков в пределах полосы <tex>\langle a, b \rangle</tex>.

Далее фигурные скобки <tex>\{\}</tex> используются для определения неупорядоченных множеств, а круглые скобки <tex>()</tex> используются для определения упорядоченных множеств.

{{Определение
|neat=neat
|definition=
Введем отношение порядка на множестве отрезков <tex>s_1 <_a s_2</tex> если оба отрезка пересекают вертикальную линию <tex>x = a</tex> и точка пересечения этой прямой с отрезком <tex>s_1</tex> лежит ниже точки пересечения с <tex>s_2</tex>.
}}

{{Определение
|neat=neat
|definition=
''Лестница'' <tex>D</tex> — это пара <tex>(Q, \langle a, b \rangle)</tex>, в которой отрезки из множества <tex>Q</tex> удовлетворяют следующим условиям :
{{---}} любой отрезок из <tex>Q</tex> охватывает полосу <tex>\langle a, b \rangle</tex>; 
{{---}} нет пересечений отрезков внутри лестницы; 
{{---}} <tex>Q</tex> упорядочена по отношению <tex><_a</tex>.

Часть отрезков лестницы внутри полосы будем называть '''ступеньками'''.
}}

{{Определение
|definition=
Будем называть лестницу <tex>D</tex> '''полной''' относительно множества отрезков <tex>S</tex>, если каждый отрезок из <tex>S</tex> либо не охватывает полосу <tex>\langle a, b \rangle</tex>, либо пересекает хотя бы одну из ступенек из множества <tex>D</tex>.
}}

{{Лемма
|id=lemma1
|statement=
Пусть лестница <tex>D</tex> полна относительно множества отрезков <tex>S</tex>, где <tex>S</tex> состоит из отрезков, пересекающих полосу <tex>\langle a, b \rangle</tex>, тогда <tex>|S| \le Ends_{a, b}(S) + |Int(D, S)|</tex>, 
где <tex>Ends_{a, b}(S)</tex> это число вершин отрезков из <tex>S</tex>, находящихся в пределах полосы <tex>\langle a, b \rangle</tex>.
}}

{{Определение
|definition=
Если точка <tex>p</tex> отрезка <tex>s</tex> лежит между ступеньками <tex>i</tex> и <tex>i + 1</tex>, тогда число <tex>i</tex> называется ''местоположением'' <tex>s</tex> на лестнице <tex>D</tex> и обозначается как <tex>Loc(D, s)</tex>
}}

{{Утверждение
|statement=
Имея лестницу <tex>D = (Q, \langle a, b \rangle)</tex> и множество отрезков <tex>S</tex>, множество <tex>Int(D, S)</tex> можно найти за время <tex>O(|S| log|Q| + |Int(D, S)|)</tex>. 
Однако, если <tex>S’</tex> упорядочено отношением <tex><_x</tex>, где <tex>x \in [a, b]</tex>, тогда можно найти <tex>Int(D, S)</tex> за время <tex>O(|S| + |Q| + |Int(D, S)|)</tex>.
}}

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

Введем несколько дополнительных функций, чтобы упростить основной алгоритм:

===Split===

Функция <tex>Split</tex> разделяет входное множество отрезков <tex>L</tex>, охватывающих некоторую полосу <tex>\langle a, b \rangle</tex>, на подмножества <tex>Q</tex> и <tex>L'</tex> так, что лестница <tex>(Q, \langle a, b \rangle)</tex> полна относительно множества отрезков <tex>L'</tex>.

Пусть <tex>L = (s_1 ,..., s_k)</tex>, где <tex>s_i <_a s_{i+1}</tex>
<tex>Split_{a, b}(L, Q, L')</tex>
<tex>\{</tex>
<tex>L' \leftarrow \varnothing; Q \leftarrow \varnothing</tex>
'''for''' <tex>j = 1,...,k</tex> '''do'''
'''if''' отрезок <tex>S_j</tex> не пересекает
последний отрезок из <tex>Q</tex> внутри полосы <tex>\langle a, b \rangle</tex>
и при этом охватывает её '''then'''
добавить <tex>s_j</tex> в конец <tex>Q;</tex>
'''else'''
добавить <tex>s_j</tex> в конец <tex>L';</tex>
<tex>\}</tex>

Эта функция работает за <tex>O(|L|)</tex> времени.

===Search In Strip===

Зная <tex>L</tex> мы можем найти <tex>Int_{a, b}(L)</tex> и <tex>R</tex> используя следующую рекурсивную функцию:

<tex>SearchInStrip_{a, b}(L, R)</tex>
<tex>\{</tex>
<tex>Split(L, Q, L');</tex>
'''if''' <tex>L' = \varnothing</tex> '''then'''
<tex>R \leftarrow Q;</tex>
'''return'''<tex>;</tex>
Найдем <tex>Int_{a, b}(Q, L');</tex>
<tex>SearchInStrip_{a, b} (L', R');</tex>
<tex>R \leftarrow Merge_b(Q, R’);</tex>
<tex>\}</tex>

Здесь, <tex>Merge_x(S_1, S_2)</tex> это функция объединения множеств <tex>S_1</tex> и <tex>S_2</tex>, упорядоченных по отношению <tex><_x</tex>. Время выполнения <tex>SearchInStrip</tex> эквивалентно сумме времён каждого её запуска. Очевидно, что время работы <tex>i</tex>-той функции, будет равно <tex>O(|L_i| + |Int_{a, b}(Q_i, {L_i}')|)</tex>, где <tex>L_i, Q_i, {L_i}'</tex> это соответствующие наборы <tex>(L_0 = L, L_{i+1} = {L_i}')</tex>.

Учитывая [[#lemma1|лемму]], заключаем, что функция <tex>SearchInStrip_{a, b}(L, R)</tex> работает за <tex>O(|L| + |Int_{a, b}(L)|)</tex>.

Предположим, что все отрезки лежат в полосе <tex>\langle a, b\rangle</tex>. Таким образом в самом начале у нас есть пара <tex>(S, \langle a, b\rangle)</tex>.
Что же дальше происходит: множество <tex>S</tex> ''распадается'' в подмножества <tex>Q</tex> и <tex>S'</tex>, после чего лестница <tex>D = (Q, \langle a, b \rangle)</tex> становится полной относительно множества <tex>S'</tex>. Необходимо найти пересечения отрезков из <tex>D</tex> и <tex>S'</tex>, затем, все пересечения в <tex>S'</tex>. Чтобы найти пересечения отрезков в <tex>S'</tex>, мы ''режем'' полосу <tex>\langle a, b \rangle</tex> и множество <tex>S'</tex> по вертикале <tex>x = c</tex> на полосы <tex>\langle a, c \rangle</tex>, <tex>\langle c, b \rangle</tex> и множества <tex>S'_{ls}</tex>, <tex>S'_{rs}</tex> соответственно, где <tex>c</tex> является медианой вершин отрезков между <tex>a</tex> и <tex>b</tex>. Затем мы рекурсивно вызываем функцию к парам <tex>(S'_{ls}, \langle a, c \rangle)</tex> и <tex>(S'_{rs}, \langle c, b \rangle)</tex>. Ключевым является тот факт, что согласно [[#lemma1|лемме]] <tex>|S'| \le Ends_{a, b}(S') + |Int(D, S')|</tex>, таким образом, число дополнительных отрезков, появляющихся после ''разрезаний'' пропорционально числу найденных пересечений.

===Ключевые моменты===

Давайте разберемся с алгоритмом более подробно:

Не умаляя общности, предположим, что все пересечения и вершины отрезков имеют разные абсциссы (в конечном счете, их можно будет отсортировать введением дополнительных свойств). Будем рассматривать целые координаты на промежутке <tex>[1, 2N]</tex>. Обозначим через <tex>p_i</tex> слева направо конец отрезка множества <tex>S_0</tex>, а через <tex>s(i)</tex> отрезок, которому он принадлежит соответственно.

Основная задача нашего алгоритма, это рекурсивная функция <tex>TreeSearch</tex>. Соединим каждый вызов функции с узлом некоего двоичного дерева (далее ''рекурсивное дерево''). Соответствующим узлом отметим все значения, множества и параметры вызова. Обозначим множество внутренних вершин за <tex>V</tex>.

<tex>IntersectingPairs(S_0):</tex>
Отсортируем <tex>2 \cdot N</tex> вершин по координатам и
найдем <tex>p_i, s(i), i = 1,...,2 \cdot N;\ S_r \leftarrow S_0</tex>
<tex>TreeSearch(S_r, 1, 2 \cdot N)</tex>;

<tex>TreeSearch(S_v, a, b):</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>L \leftarrow</tex> отсортируем <tex>S_v</tex> по отношению <tex><_a</tex>;
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
Разделим <tex>S_v</tex> на <tex>Q_v</tex> и <tex>S_v'</tex> так, что лестница
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex> будет полной, относительно множества <tex>S_v'</tex>;
Найдем <tex>Int(D_v, S_v')</tex>;
<tex>c \leftarrow \lfloor (a + b)/2 \rfloor</tex>;
Разделим отрезки из <tex>S_v'</tex> на пересекающих
полосу <tex>\langle a, c \rangle</tex> <tex>S_{ls}(v)</tex> и
полосу <tex>\langle c, b \rangle</tex> <tex>S_{rs}(v)</tex>;
<tex>TreeSearch(S_{ls}(v), a, c)</tex>;
<tex>TreeSearch(S_{rs}(v), c, b)</tex>;
<tex>\}</tex>

Отсюда и дальше <tex>ls(v)</tex>, <tex>rs(v)</tex> и <tex>ft(v)</tex> означают, соответственно, левого сына, правого сына, и отцовскую вершину узла <tex>v</tex>.
Наша задача показать, что все операции с узлом <tex>v</tex> происходят за <tex>O(|S_v| + |Int(D_v, S_v')| + (a_v - b_v)logN)</tex>, для этого возьмем во внимание, что <tex>\sum_v |S_v| = O(N \cdot logN + K)</tex> (очевидно, что <tex>\sum_v |Int(D_v, S_v')| \le K</tex>).

[[Файл:Balaban_pic_2.png|280px|thumb|right|<tex>S_v = (s_1, s_2, s_3, s_4, s_5)</tex>, <tex>L_v = (s_1, s_3)</tex>, <tex>R_v = (s_3, s_4)</tex>, <tex>I_v = (s_2, s_5)</tex>]]

Функция <tex>TreeSearch</tex> похожа на функцию <tex>SearchInStrip</tex>. Основная разница заключается в том, что <tex>SearchInStrip</tex> вызывает себя без изменения полосы, когда <tex>TreeSearch</tex> делит полосу на две части, после чего рекурсивно вызывает себя для них. Другое отличие заключается в том, что множество <tex>S_v</tex> не упорядочено так же, как <tex>L</tex>. В результате мы не можем напрямую использовать функцию <tex>Split</tex> для эффективного деления <tex>S_v</tex>.

Чтобы решить эту проблему, представим <tex>S_v</tex> как объединение трех множеств:
множества <tex>L_v</tex> упорядоченного по отношению <tex><_a</tex>, неупорядоченного множества <tex>I_v</tex>, и множества <tex>R_v</tex> упорядоченного по отношению <tex><_b</tex>. Расположим отрезки из <tex>S_v</tex>, пересекающие границу <tex>x = a</tex> во множество <tex>L_v</tex>, отрезки пересекающие <tex>x = b</tex> во множество <tex>R_v</tex>, и внутренние отрезки во множество <tex>I_v</tex> (пример на ''рисунке справа'').

Теперь мы можем вызвать функцию <tex>Split</tex> для множества <tex>L_v</tex> и построить <tex>Q_v</tex> за <tex>O(|L_v|) = O(|S_v|)</tex> времени. Но мы натыкаемся на новую проблему: передавая множества <tex>L_v</tex>, <tex>I_v</tex> и <tex>R_v</tex>, необходимо найти соответствующие множества сыновей узла <tex>v</tex>.

Неупорядоченные множества <tex>I_{ls(v)}</tex> и <tex>I_{rs(v)}</tex> строятся легко. Множество <tex>L_{ls(v)}</tex> будет найдено вызовом функции <tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex> для нахождения <tex>Int(D_v, S_v')</tex> в функции <tex>TreeSearch</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> за линейное время вставкой (если <tex>p_c</tex> левая вершина отрезка) или удалением (если <tex>p_c</tex> правая вершина отрезка) отрезка <tex>s(c)</tex>. Но как получить <tex>R_{ls(v)}</tex> из <tex>L_v</tex>, <tex>R_v</tex> и <tex>I_v</tex> без сортировки?

Для листьев мы сделаем проверку вначале, и получим <tex>R_v</tex> из <tex>L_v</tex>. Пусть <tex>L_v</tex> и <tex>I_v</tex> известны, и все сыновья узла <tex>v</tex> - листья. Для начала запустим функцию <tex>Split(L_v, Q_v, L_{ls(v)})</tex> и найдем <tex>Q_v</tex> и <tex>L_{ls(v)}</tex>. Теперь мы должны найти <tex>Int(D_s, S_v') = Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v) \cup Int(D_v, R_{rs(v)})</tex>, но мы не знаем <tex>R_{rs(v)}</tex> и, соответственно, можем найти только <tex>Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v)</tex>. Применим <tex>SearchInStrip</tex> к множеству <tex>L_{ls(v)}</tex> и получим <tex>R_{ls(v)}</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> вставкой или удалением отрезка <tex>s(c)</tex>. Применим <tex>SearchInStrip</tex> к <tex>L_{rs(v)}</tex> и найдем <tex>R_{rs(v)}</tex>. Теперь можем продолжить вычисление <tex>Int(D_v, R_{rs(v)})</tex> и получим <tex>R_v</tex> слиянием <tex>Q_v</tex> и <tex>R_{rs(v)}</tex>.

Конечная функция будет выглядеть так:
<tex>IntersectingPairs(S_0)</tex>
<tex>\{</tex>
Отсортируем <tex>2N</tex> концов отрезков по абсциссе
и найдем <tex>p_i</tex>, <tex>s(i)</tex> где <tex>i = 1, ..., 2N</tex>;
<tex>L_r \leftarrow (s(1))</tex>; <tex>I_r \leftarrow S_0 \setminus (\{s(1)\} \cup \{s(2N)\})</tex>;
<tex>TreeSearch(L_r, I_r, 1, 2N, R_r)</tex>;
<tex>\}</tex>

<tex>TreeSearch(L_v, I_v, a, b, R_v)</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
<tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex>;
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex>;
Найдем <tex>Int(D_v, L_{ls(v)})</tex>;
<tex>c \leftarrow \lfloor (a + b) / 2 \rfloor</tex>;
Разделяем отрезки из <tex>I_v</tex>
внутренние для полосы <tex>\langle a, c \rangle</tex> во множество <tex>I_{ls(v)}</tex>
внутренние для полосы <tex>\langle c, b \rangle</tex> во множество <tex>I_{rs(v)}</tex>
<tex>TreeSearch(L_{ls(v)}, I_{ls(v)}, a, c, R_{ls(v)})</tex>;
'''if''' <tex>p_c</tex> левый конец отрезка <tex>s(c)</tex> '''then'''
<tex>L_{rs(v)} \leftarrow</tex> вставить <tex>s(c)</tex> в <tex>R_{ls(v)}</tex>
'''else'''
<tex>L_{rs(v)} \leftarrow</tex> удалить <tex>s(c)</tex> из <tex>R_{ls(v)}</tex>
<tex>TreeSearch(L_{rs(v)}, I_{rs(v)}, c, b, R_{rs(v)})</tex>;
Найдем <tex>Int(D_v, R_{rs(v)})</tex>;
'''for''' <tex>s \in I_v</tex> '''do'''
Найдем <tex>Loc(D_v, s)</tex> используя двоичный поиск;
Найдем <tex>Int(D_v, I_v)</tex> используя значения, полученные шагом выше;
<tex>R_v \leftarrow Merge_b(Q_v, R_{rs(v)})</tex>;
<tex>\}</tex>

Заметим, что нахождение <tex>Int(D_v, R_{rs(v)})</tex> надо делать аккуратно, так как множества <tex>R_{rs(v)}</tex> и <tex>L_{ls(v)}</tex> могут иметь одни и те же отрезки (которые '''пересекают''' <tex>\langle a, b \rangle</tex>). Мы нашли их пересечения с <tex>D_v</tex> при поиске <tex>Int(D_v, L_{ls(v)})</tex>, и не должны вывести эти пересечения снова.

==Время работы==

Для начала рассчитаем место, необходимое для выполнения алгоритма. Алгоритм использует рекурсивную функцию <tex>TreeSearch</tex>. Последовательность вызовов функции может занять память. Эта последовательность может быть представлена как путь корня рекурсивного дерева, до узла. Соответствующий вызов этого узла занимает <tex>O(N)</tex> памяти, каждый его "предок" занимает <tex>O(|I_v| + |Q_v|)</tex> памяти, а остальные структуры используют <tex>O(N)</tex>. Очевидно, что любой путь <tex>pt</tex> от корня рекурсивного дерева до какого-то узла <tex>\sum_{v \in pt}(|I_v + |Q_v|) = O(N)(|I_v| \le b_v - a_v \le \lceil (b_{ft(v)} - a_{ft(v)})/2 \rceil)</tex>.

В итоге для работы алгоритма требуется <tex>O(N)</tex> памяти.

{{Лемма
|id=lemma2
|about=
#2
|statement=
<tex>\forall v \in V \ |S_v'| \le a_v - b_v + |Int(D_v, S_v')|</tex>.
|proof=
Утверждение напрямую вытекает из [[#lemma1|первой леммы]] и очевидного факта, что для любого множества <tex>S \subset S_0</tex>, количество концов отрезков, лежащих в полосе <tex>\langle a_v, b_v \rangle</tex>, меньше чем <tex>b_v - a_v</tex>.
}}

{{Теорема
|about=
#1
|statement=
<tex>\sum_{v \in V} |S_v'| \le 2N \lceil logN + 1 \rceil + K</tex>
|proof=
Утверждение напрямую вытекает из [[#lemma2|леммы №2]] и следующего отношения <tex>\sum_v (b_v - a_v) \le 2N \lceil logN + 1 \rceil</tex>.
}}

Обозначим множество всех вершин рекурсивного дерева за <tex>RT</tex>.

{{Теорема
|about=
#2
|statement=
<tex>\sum_{v \in RT} |S_v| \le N \lceil 4logN + 5 \rceil + 2K</tex>
|proof=
Для всех узлов, кроме корня <tex>r</tex> имеет место выражение <tex>|S_v| \le |S_{ft(v)}'|</tex>, следовательно <tex>\sum_{v \in RT} |S_v| \le |S_r| + \sum_{v \in RT \setminus r} |S_{ft(v)}| \le N + 2 \sum_{v \in V} |S_v'| \le N \lceil 4 logN + 5 \rceil + 2K</tex>.
}}

Начальная сортировка и инициализация множеств <tex>L_r</tex> и <tex>I_r</tex> может быть произведена за <tex>O(N logN)</tex> времени. Время работы функции <tex>TreeSearch</tex> является суммой длительностей всех его вызовов. Каждый вызов от внешних узлов добавляет к этой сумме <tex>O(|L_v| + |Int_{a, b}(L_v)|)</tex>. Для внутренних же узлов, время требуемое для поиска <tex>Loc(D_v, s)</tex> равно <tex>O(|I_v| log N)</tex>, а для остальных <tex>O(|S_v| + |Int(D_v, S_v')|)</tex>. Если мы все это сложим, то придем к выводу, что наш алгоритм работает за <tex>O(N log^2 N + K)</tex>. Заметим, что его скорость можно увеличить до <tex>O(N logN + K)</tex>, если не будем учитывать время нахождения <tex>Loc(D_v, s)</tex>.

Соответственно в оптимальном алгоритме Балабана <tex>Loc(D_v, s)</tex> находится за <tex>O(1)</tex>.

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

<references/>

==Литература==

[http://www.graphicon.ru/proceedings/2010/conference/RU/Se4/021.pdf ''Т.Вознюк, В.Терещенко {{---}} К построению эффективного решения задачи пересечения отрезков''] 
[http://booksshare.net/books/math/preparata-f/1989/files/vichgeometr.pdf ''Ф.Препарата, М.Шеймос {{---}} Вычислительная геометрия''] 

[[Категория: Вычислительная геометрия]]

Алгоритм Балабана

2013-11-30T07:56:55Z

194.85.161.34: /* Основные понятия */

{{В разработке}}

'''Алгоритм Балабана''' {{---}} детерминированный алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются. 

==Введение==

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

# Тривиальный детерминированный алгоритм имеет временную сложность <tex>O(n^2)</tex>, и его суть заключается в проверке попарного пересечения отрезков.
# Сложнее, но эффективнее алгоритм Бентли-Оттмана <ref>[http://neerc.ifmo.ru/wiki/index.php?title=Алгоритм_Бентли-Оттмана ''Алгоритм Бентли-Оттмана'']</ref> с оценкой сложности <tex>O((n + k)\ log(n)+k)</tex>, в основе которого лежит метод заметающей прямой.
# Алгоритм, предложенный Чазелле и Едельсбруннером <ref>[http://www.cs.princeton.edu/~chazelle/pubs/IntersectLineSegments.pdf ''An optimal algorithm for intersecting line segments in the plane'']</ref>, имеет лучшую оценку <tex>O(n\ log(n) + k)</tex>, но в отличие от предыдущих методов требует квадратичной памяти.
# Оптимальный детерминированный алгоритм был предложен Балабаном <ref>[http://www.cs.sfu.ca/~binay/813.2011/Balaban.pdf ''I.J. Balaban. An optimal algorithm for finding segments intersections. In Proceedings of the Eleventh Annual Symposium on Computational Geometry, ACM Press, New York, 1995. - pp. 211–219.'']</ref> с временной оценкой сложности <tex>O(n\ log(n) + k)</tex> и <tex>O(n)</tex> памяти, где К - число пересекающихся отрезков.

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

==Основные понятия==

Введем некоторые обозначения. Пусть <tex>Int(S)</tex> - множество всех точек пересечения отрезков из множества <tex>S</tex>, а <tex>K = |Int(S)|</tex> - количество таких пересечений ; 
Через <tex>\langle a, b \rangle</tex> обозначим вертикальную полосу, которая ограничена прямыми <tex>x = a</tex> и <tex>x = b</tex>, а через <tex>s</tex> {{---}} отрезок с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex>. 
Рассмотрим взаимное расположение вертикальной полосы <tex>\langle a, b \rangle</tex> и отрезка <tex>s</tex>.

{{Определение
|definition=
Будем говорить, что отрезок <tex>s</tex>, с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex> :
{{---}} '''охватывает''' (''span'') полосу <tex>\langle a, b \rangle</tex>, если <tex>l \le a \le b \le r</tex>; 

{{---}} '''внутренний''' (''inner'') для полосы <tex>\langle a, b \rangle</tex>, если <tex>a < l < r < b</tex>; 

{{---}} '''пересекает''' (''cross'') полосу <tex>\langle a, b \rangle</tex> в других случаях.
}}

{{Определение
|definition=
Два отрезка <tex>s_1</tex> и <tex>s_2</tex> называются ''пересекающимися внутри'' полосы <tex>\langle a, b \rangle</tex>, если их точка пересечения лежит в пределах этой полосы. 

Для двух множеств отрезков <tex>S</tex> и <tex>S'</tex> определим множество <tex>Int(S, S')</tex> как <tex>\{ {s, s'} | (s \in S, s' \in S') \& (s \ intersect \ s') \}</tex>.
}}
[[Файл:Balaban_pic_1.png|280px|thumb|right|<tex>D = ((s_1, s_2, s_3), \langle a, b \rangle)</tex>, <tex>Loc(D, s_4) = 0</tex>, <tex>Loc(D, s_5) = 2</tex> или <tex>3</tex>, <tex>Int(D, \{s_4,\ s_5\}) = \{\{s_3,\ s_5\}\}</tex>]]

Обозначения <tex>Int_{a, b}(S)</tex> и <tex>Int_{a, b}(S, S')</tex> будут использоваться для описания подмножеств <tex>Int(S)</tex> и <tex>Int(S, S')</tex>, состоящих из пересекающихся пар отрезков в пределах полосы <tex>\langle a, b \rangle</tex>. Далее скобки <tex>\{\}</tex> используются для определения неупорядоченных множеств, а скобки <tex>()</tex> используются для определения упорядоченных множеств.

Введем отношение порядка на множестве отрезков <tex>s_1 <_a s_2</tex> если оба отрезка пересекают вертикальную линию <tex>x = a</tex> и
точка пересечения этой прямой с отрезком <tex>s_1</tex> лежит ниже точки пересечения с <tex>s_2</tex>.

{{Определение
|neat=neat
|definition=
''Лестница'' <tex>D</tex> — это пара <tex>(Q, \langle a, b \rangle)</tex>, в которой отрезки из множества <tex>Q</tex> удовлетворяют следующим условиям :
− любой отрезок из <tex>Q</tex> охватывает полосу <tex>\langle a, b \rangle</tex>; 
− нет пересечений отрезков внутри лестницы; 
− <tex>Q</tex> упорядочена по отношению <tex><_a</tex>.

Часть отрезков лестницы внутри полосы будем называть '''ступеньками'''.
}}

{{Определение
|definition=
Будем называть лестницу <tex>D</tex> '''полной''' относительно множества отрезков <tex>S</tex>, если каждый отрезок из <tex>S</tex> либо не охватывает полосу <tex>\langle a, b \rangle</tex>, либо пересекает хотя бы одну из ступенек из множества <tex>D</tex>.
}}

{{Лемма
|id=lemma1
|statement=
Пусть лестница <tex>D</tex> полна относительно множества отрезков <tex>S</tex>, где <tex>S</tex> состоит из отрезков, пересекающих полосу <tex>\langle a, b \rangle</tex>, тогда <tex>|S| \le Ends_{a, b}(S) + |Int(D, S)|</tex>, 
где <tex>Ends_{a, b}(S)</tex> это число вершин отрезков из <tex>S</tex>, находящихся в пределах полосы <tex>\langle a, b \rangle</tex>.
}}

{{Определение
|definition=
Если точка <tex>p</tex> отрезка <tex>s</tex> лежит между ступеньками <tex>i</tex> и <tex>i + 1</tex>, тогда число <tex>i</tex> называется ''местоположением'' <tex>s</tex> на лестнице <tex>D</tex> и обозначается как <tex>Loc(D, s)</tex>
}}

{{Утверждение
|statement=
Имея лестницу <tex>D = (Q, \langle a, b \rangle)</tex> и множество отрезков <tex>S</tex>, множество <tex>Int(D, S)</tex> можно найти за время <tex>O(|S| log|Q| + |Int(D, S)|)</tex>. 
Однако, если <tex>S’</tex> упорядочено отношением <tex><_x</tex>, где <tex>x \in [a, b]</tex>, тогда можно найти <tex>Int(D, S)</tex> за время <tex>O(|S| + |Q| + |Int(D, S)|)</tex>.
}}

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

Введем несколько дополнительных функций, чтобы упростить основной алгоритм:

===Split===

Функция <tex>Split</tex> разделяет входное множество отрезков <tex>L</tex>, охватывающих некоторую полосу <tex>\langle a, b \rangle</tex>, на подмножества <tex>Q</tex> и <tex>L'</tex> так, что лестница <tex>(Q, \langle a, b \rangle)</tex> полна относительно множества отрезков <tex>L'</tex>.

Пусть <tex>L = (s_1 ,..., s_k)</tex>, где <tex>s_i <_a s_{i+1}</tex>
<tex>Split_{a, b}(L, Q, L')</tex>
<tex>\{</tex>
<tex>L' \leftarrow \varnothing; Q \leftarrow \varnothing</tex>
'''for''' <tex>j = 1,...,k</tex> '''do'''
'''if''' отрезок <tex>S_j</tex> не пересекает
последний отрезок из <tex>Q</tex> внутри полосы <tex>\langle a, b \rangle</tex>
и при этом охватывает её '''then'''
добавить <tex>s_j</tex> в конец <tex>Q;</tex>
'''else'''
добавить <tex>s_j</tex> в конец <tex>L';</tex>
<tex>\}</tex>

Эта функция работает за <tex>O(|L|)</tex> времени.

===Search In Strip===

Зная <tex>L</tex> мы можем найти <tex>Int_{a, b}(L)</tex> и <tex>R</tex> используя следующую рекурсивную функцию:

<tex>SearchInStrip_{a, b}(L, R)</tex>
<tex>\{</tex>
<tex>Split(L, Q, L');</tex>
'''if''' <tex>L' = \varnothing</tex> '''then'''
<tex>R \leftarrow Q;</tex>
'''return'''<tex>;</tex>
Найдем <tex>Int_{a, b}(Q, L');</tex>
<tex>SearchInStrip_{a, b} (L', R');</tex>
<tex>R \leftarrow Merge_b(Q, R’);</tex>
<tex>\}</tex>

Здесь, <tex>Merge_x(S_1, S_2)</tex> это функция объединения множеств <tex>S_1</tex> и <tex>S_2</tex>, упорядоченных по отношению <tex><_x</tex>. Время выполнения <tex>SearchInStrip</tex> эквивалентно сумме времён каждого её запуска. Очевидно, что время работы <tex>i</tex>-той функции, будет равно <tex>O(|L_i| + |Int_{a, b}(Q_i, {L_i}')|)</tex>, где <tex>L_i, Q_i, {L_i}'</tex> это соответствующие наборы <tex>(L_0 = L, L_{i+1} = {L_i}')</tex>.

Учитывая [[#lemma1|лемму]], заключаем, что функция <tex>SearchInStrip_{a, b}(L, R)</tex> работает за <tex>O(|L| + |Int_{a, b}(L)|)</tex>.

Предположим, что все отрезки лежат в полосе <tex>\langle a, b\rangle</tex>. Таким образом в самом начале у нас есть пара <tex>(S, \langle a, b\rangle)</tex>.
Что же дальше происходит: множество <tex>S</tex> ''распадается'' в подмножества <tex>Q</tex> и <tex>S'</tex>, после чего лестница <tex>D = (Q, \langle a, b \rangle)</tex> становится полной относительно множества <tex>S'</tex>. Необходимо найти пересечения отрезков из <tex>D</tex> и <tex>S'</tex>, затем, все пересечения в <tex>S'</tex>. Чтобы найти пересечения отрезков в <tex>S'</tex>, мы ''режем'' полосу <tex>\langle a, b \rangle</tex> и множество <tex>S'</tex> по вертикале <tex>x = c</tex> на полосы <tex>\langle a, c \rangle</tex>, <tex>\langle c, b \rangle</tex> и множества <tex>S'_{ls}</tex>, <tex>S'_{rs}</tex> соответственно, где <tex>c</tex> является медианой вершин отрезков между <tex>a</tex> и <tex>b</tex>. Затем мы рекурсивно вызываем функцию к парам <tex>(S'_{ls}, \langle a, c \rangle)</tex> и <tex>(S'_{rs}, \langle c, b \rangle)</tex>. Ключевым является тот факт, что согласно [[#lemma1|лемме]] <tex>|S'| \le Ends_{a, b}(S') + |Int(D, S')|</tex>, таким образом, число дополнительных отрезков, появляющихся после ''разрезаний'' пропорционально числу найденных пересечений.

===Ключевые моменты===

Давайте разберемся с алгоритмом более подробно:

Не умаляя общности, предположим, что все пересечения и вершины отрезков имеют разные абсциссы (в конечном счете, их можно будет отсортировать введением дополнительных свойств). Будем рассматривать целые координаты на промежутке <tex>[1, 2N]</tex>. Обозначим через <tex>p_i</tex> слева направо конец отрезка множества <tex>S_0</tex>, а через <tex>s(i)</tex> отрезок, которому он принадлежит соответственно.

Основная задача нашего алгоритма, это рекурсивная функция <tex>TreeSearch</tex>. Соединим каждый вызов функции с узлом некоего двоичного дерева (далее ''рекурсивное дерево''). Соответствующим узлом отметим все значения, множества и параметры вызова. Обозначим множество внутренних вершин за <tex>V</tex>.

<tex>IntersectingPairs(S_0):</tex>
Отсортируем <tex>2 \cdot N</tex> вершин по координатам и
найдем <tex>p_i, s(i), i = 1,...,2 \cdot N;\ S_r \leftarrow S_0</tex>
<tex>TreeSearch(S_r, 1, 2 \cdot N)</tex>;

<tex>TreeSearch(S_v, a, b):</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>L \leftarrow</tex> отсортируем <tex>S_v</tex> по отношению <tex><_a</tex>;
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
Разделим <tex>S_v</tex> на <tex>Q_v</tex> и <tex>S_v'</tex> так, что лестница
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex> будет полной, относительно множества <tex>S_v'</tex>;
Найдем <tex>Int(D_v, S_v')</tex>;
<tex>c \leftarrow \lfloor (a + b)/2 \rfloor</tex>;
Разделим отрезки из <tex>S_v'</tex> на пересекающих
полосу <tex>\langle a, c \rangle</tex> <tex>S_{ls}(v)</tex> и
полосу <tex>\langle c, b \rangle</tex> <tex>S_{rs}(v)</tex>;
<tex>TreeSearch(S_{ls}(v), a, c)</tex>;
<tex>TreeSearch(S_{rs}(v), c, b)</tex>;
<tex>\}</tex>

Отсюда и дальше <tex>ls(v)</tex>, <tex>rs(v)</tex> и <tex>ft(v)</tex> означают, соответственно, левого сына, правого сына, и отцовскую вершину узла <tex>v</tex>.
Наша задача показать, что все операции с узлом <tex>v</tex> происходят за <tex>O(|S_v| + |Int(D_v, S_v')| + (a_v - b_v)logN)</tex>, для этого возьмем во внимание, что <tex>\sum_v |S_v| = O(N \cdot logN + K)</tex> (очевидно, что <tex>\sum_v |Int(D_v, S_v')| \le K</tex>).

[[Файл:Balaban_pic_2.png|280px|thumb|right|<tex>S_v = (s_1, s_2, s_3, s_4, s_5)</tex>, <tex>L_v = (s_1, s_3)</tex>, <tex>R_v = (s_3, s_4)</tex>, <tex>I_v = (s_2, s_5)</tex>]]

Функция <tex>TreeSearch</tex> похожа на функцию <tex>SearchInStrip</tex>. Основная разница заключается в том, что <tex>SearchInStrip</tex> вызывает себя без изменения полосы, когда <tex>TreeSearch</tex> делит полосу на две части, после чего рекурсивно вызывает себя для них. Другое отличие заключается в том, что множество <tex>S_v</tex> не упорядочено так же, как <tex>L</tex>. В результате мы не можем напрямую использовать функцию <tex>Split</tex> для эффективного деления <tex>S_v</tex>.

Чтобы решить эту проблему, представим <tex>S_v</tex> как объединение трех множеств:
множества <tex>L_v</tex> упорядоченного по отношению <tex><_a</tex>, неупорядоченного множества <tex>I_v</tex>, и множества <tex>R_v</tex> упорядоченного по отношению <tex><_b</tex>. Расположим отрезки из <tex>S_v</tex>, пересекающие границу <tex>x = a</tex> во множество <tex>L_v</tex>, отрезки пересекающие <tex>x = b</tex> во множество <tex>R_v</tex>, и внутренние отрезки во множество <tex>I_v</tex> (пример на ''рисунке справа'').

Теперь мы можем вызвать функцию <tex>Split</tex> для множества <tex>L_v</tex> и построить <tex>Q_v</tex> за <tex>O(|L_v|) = O(|S_v|)</tex> времени. Но мы натыкаемся на новую проблему: передавая множества <tex>L_v</tex>, <tex>I_v</tex> и <tex>R_v</tex>, необходимо найти соответствующие множества сыновей узла <tex>v</tex>.

Неупорядоченные множества <tex>I_{ls(v)}</tex> и <tex>I_{rs(v)}</tex> строятся легко. Множество <tex>L_{ls(v)}</tex> будет найдено вызовом функции <tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex> для нахождения <tex>Int(D_v, S_v')</tex> в функции <tex>TreeSearch</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> за линейное время вставкой (если <tex>p_c</tex> левая вершина отрезка) или удалением (если <tex>p_c</tex> правая вершина отрезка) отрезка <tex>s(c)</tex>. Но как получить <tex>R_{ls(v)}</tex> из <tex>L_v</tex>, <tex>R_v</tex> и <tex>I_v</tex> без сортировки?

Для листьев мы сделаем проверку вначале, и получим <tex>R_v</tex> из <tex>L_v</tex>. Пусть <tex>L_v</tex> и <tex>I_v</tex> известны, и все сыновья узла <tex>v</tex> - листья. Для начала запустим функцию <tex>Split(L_v, Q_v, L_{ls(v)})</tex> и найдем <tex>Q_v</tex> и <tex>L_{ls(v)}</tex>. Теперь мы должны найти <tex>Int(D_s, S_v') = Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v) \cup Int(D_v, R_{rs(v)})</tex>, но мы не знаем <tex>R_{rs(v)}</tex> и, соответственно, можем найти только <tex>Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v)</tex>. Применим <tex>SearchInStrip</tex> к множеству <tex>L_{ls(v)}</tex> и получим <tex>R_{ls(v)}</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> вставкой или удалением отрезка <tex>s(c)</tex>. Применим <tex>SearchInStrip</tex> к <tex>L_{rs(v)}</tex> и найдем <tex>R_{rs(v)}</tex>. Теперь можем продолжить вычисление <tex>Int(D_v, R_{rs(v)})</tex> и получим <tex>R_v</tex> слиянием <tex>Q_v</tex> и <tex>R_{rs(v)}</tex>.

Конечная функция будет выглядеть так:
<tex>IntersectingPairs(S_0)</tex>
<tex>\{</tex>
Отсортируем <tex>2N</tex> концов отрезков по абсциссе
и найдем <tex>p_i</tex>, <tex>s(i)</tex> где <tex>i = 1, ..., 2N</tex>;
<tex>L_r \leftarrow (s(1))</tex>; <tex>I_r \leftarrow S_0 \setminus (\{s(1)\} \cup \{s(2N)\})</tex>;
<tex>TreeSearch(L_r, I_r, 1, 2N, R_r)</tex>;
<tex>\}</tex>

<tex>TreeSearch(L_v, I_v, a, b, R_v)</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
<tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex>;
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex>;
Найдем <tex>Int(D_v, L_{ls(v)})</tex>;
<tex>c \leftarrow \lfloor (a + b) / 2 \rfloor</tex>;
Разделяем отрезки из <tex>I_v</tex>
внутренние для полосы <tex>\langle a, c \rangle</tex> во множество <tex>I_{ls(v)}</tex>
внутренние для полосы <tex>\langle c, b \rangle</tex> во множество <tex>I_{rs(v)}</tex>
<tex>TreeSearch(L_{ls(v)}, I_{ls(v)}, a, c, R_{ls(v)})</tex>;
'''if''' <tex>p_c</tex> левый конец отрезка <tex>s(c)</tex> '''then'''
<tex>L_{rs(v)} \leftarrow</tex> вставить <tex>s(c)</tex> в <tex>R_{ls(v)}</tex>
'''else'''
<tex>L_{rs(v)} \leftarrow</tex> удалить <tex>s(c)</tex> из <tex>R_{ls(v)}</tex>
<tex>TreeSearch(L_{rs(v)}, I_{rs(v)}, c, b, R_{rs(v)})</tex>;
Найдем <tex>Int(D_v, R_{rs(v)})</tex>;
'''for''' <tex>s \in I_v</tex> '''do'''
Найдем <tex>Loc(D_v, s)</tex> используя двоичный поиск;
Найдем <tex>Int(D_v, I_v)</tex> используя значения, полученные шагом выше;
<tex>R_v \leftarrow Merge_b(Q_v, R_{rs(v)})</tex>;
<tex>\}</tex>

Заметим, что нахождение <tex>Int(D_v, R_{rs(v)})</tex> надо делать аккуратно, так как множества <tex>R_{rs(v)}</tex> и <tex>L_{ls(v)}</tex> могут иметь одни и те же отрезки (которые '''пересекают''' <tex>\langle a, b \rangle</tex>). Мы нашли их пересечения с <tex>D_v</tex> при поиске <tex>Int(D_v, L_{ls(v)})</tex>, и не должны вывести эти пересечения снова.

==Время работы==

Для начала рассчитаем место, необходимое для выполнения алгоритма. Алгоритм использует рекурсивную функцию <tex>TreeSearch</tex>. Последовательность вызовов функции может занять память. Эта последовательность может быть представлена как путь корня рекурсивного дерева, до узла. Соответствующий вызов этого узла занимает <tex>O(N)</tex> памяти, каждый его "предок" занимает <tex>O(|I_v| + |Q_v|)</tex> памяти, а остальные структуры используют <tex>O(N)</tex>. Очевидно, что любой путь <tex>pt</tex> от корня рекурсивного дерева до какого-то узла <tex>\sum_{v \in pt}(|I_v + |Q_v|) = O(N)(|I_v| \le b_v - a_v \le \lceil (b_{ft(v)} - a_{ft(v)})/2 \rceil)</tex>.

В итоге для работы алгоритма требуется <tex>O(N)</tex> памяти.

{{Лемма
|id=lemma2
|about=
#2
|statement=
<tex>\forall v \in V \ |S_v'| \le a_v - b_v + |Int(D_v, S_v')|</tex>.
|proof=
Утверждение напрямую вытекает из [[#lemma1|первой леммы]] и очевидного факта, что для любого множества <tex>S \subset S_0</tex>, количество концов отрезков, лежащих в полосе <tex>\langle a_v, b_v \rangle</tex>, меньше чем <tex>b_v - a_v</tex>.
}}

{{Теорема
|about=
#1
|statement=
<tex>\sum_{v \in V} |S_v'| \le 2N \lceil logN + 1 \rceil + K</tex>
|proof=
Утверждение напрямую вытекает из [[#lemma2|леммы №2]] и следующего отношения <tex>\sum_v (b_v - a_v) \le 2N \lceil logN + 1 \rceil</tex>.
}}

Обозначим множество всех вершин рекурсивного дерева за <tex>RT</tex>.

{{Теорема
|about=
#2
|statement=
<tex>\sum_{v \in RT} |S_v| \le N \lceil 4logN + 5 \rceil + 2K</tex>
|proof=
Для всех узлов, кроме корня <tex>r</tex> имеет место выражение <tex>|S_v| \le |S_{ft(v)}'|</tex>, следовательно <tex>\sum_{v \in RT} |S_v| \le |S_r| + \sum_{v \in RT \setminus r} |S_{ft(v)}| \le N + 2 \sum_{v \in V} |S_v'| \le N \lceil 4 logN + 5 \rceil + 2K</tex>.
}}

Начальная сортировка и инициализация множеств <tex>L_r</tex> и <tex>I_r</tex> может быть произведена за <tex>O(N logN)</tex> времени. Время работы функции <tex>TreeSearch</tex> является суммой длительностей всех его вызовов. Каждый вызов от внешних узлов добавляет к этой сумме <tex>O(|L_v| + |Int_{a, b}(L_v)|)</tex>. Для внутренних же узлов, время требуемое для поиска <tex>Loc(D_v, s)</tex> равно <tex>O(|I_v| log N)</tex>, а для остальных <tex>O(|S_v| + |Int(D_v, S_v')|)</tex>. Если мы все это сложим, то придем к выводу, что наш алгоритм работает за <tex>O(N log^2 N + K)</tex>. Заметим, что его скорость можно увеличить до <tex>O(N logN + K)</tex>, если не будем учитывать время нахождения <tex>Loc(D_v, s)</tex>.

Соответственно в оптимальном алгоритме Балабана <tex>Loc(D_v, s)</tex> находится за <tex>O(1)</tex>.

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

<references/>

==Литература==

[http://www.graphicon.ru/proceedings/2010/conference/RU/Se4/021.pdf ''Т.Вознюк, В.Терещенко {{---}} К построению эффективного решения задачи пересечения отрезков''] 
[http://booksshare.net/books/math/preparata-f/1989/files/vichgeometr.pdf ''Ф.Препарата, М.Шеймос {{---}} Вычислительная геометрия''] 

[[Категория: Вычислительная геометрия]]

Алгоритм Балабана

2013-11-30T07:54:15Z

194.85.161.34: /* Введение */

{{В разработке}}

'''Алгоритм Балабана''' {{---}} детерминированный алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются. 

==Введение==

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

# Тривиальный детерминированный алгоритм имеет временную сложность <tex>O(n^2)</tex>, и его суть заключается в проверке попарного пересечения отрезков.
# Сложнее, но эффективнее алгоритм Бентли-Оттмана <ref>[http://neerc.ifmo.ru/wiki/index.php?title=Алгоритм_Бентли-Оттмана ''Алгоритм Бентли-Оттмана'']</ref> с оценкой сложности <tex>O((n + k)\ log(n)+k)</tex>, в основе которого лежит метод заметающей прямой.
# Алгоритм, предложенный Чазелле и Едельсбруннером <ref>[http://www.cs.princeton.edu/~chazelle/pubs/IntersectLineSegments.pdf ''An optimal algorithm for intersecting line segments in the plane'']</ref>, имеет лучшую оценку <tex>O(n\ log(n) + k)</tex>, но в отличие от предыдущих методов требует квадратичной памяти.
# Оптимальный детерминированный алгоритм был предложен Балабаном <ref>[http://www.cs.sfu.ca/~binay/813.2011/Balaban.pdf ''I.J. Balaban. An optimal algorithm for finding segments intersections. In Proceedings of the Eleventh Annual Symposium on Computational Geometry, ACM Press, New York, 1995. - pp. 211–219.'']</ref> с временной оценкой сложности <tex>O(n\ log(n) + k)</tex> и <tex>O(n)</tex> памяти, где К - число пересекающихся отрезков.

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

==Основные понятия==

Введем некоторые обозначения. Пусть <tex>Int(S)</tex> - множество всех точек пересечения отрезков из множества <tex>S</tex>, а <tex>K = |Int(S)|</tex> - количество таких пересечений ; 
Через <tex>\langle a, b \rangle</tex> обозначим вертикальную полосу, которая ограничена прямыми <tex>x = a</tex> и <tex>x = b</tex>, а через <tex>s</tex> {{---}} отрезок с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex>. 
Рассмотрим взаимное расположение вертикальной полосы <tex>\langle a, b \rangle</tex> и отрезка <tex>s</tex>.

{{Определение
|definition=
Будем говорить, что отрезок <tex>s</tex>, с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex> :
- '''охватывает'''(span) полосу <tex>\langle a, b \rangle</tex>, если <tex>l \le a \le b \le r</tex>; 
- '''внутренний'''(inner) для полосы <tex>\langle a, b \rangle</tex>, если <tex>a < l < r < b</tex>; 
- '''пересекает'''(cross) полосу <tex>\langle a, b \rangle</tex> в других случаях.
}}

{{Определение
|definition=
Два отрезка <tex>s_1</tex> и <tex>s_2</tex> называются ''пересекающимися внутри'' полосы <tex>\langle a, b \rangle</tex>, если их точка пересечения лежит в пределах этой полосы. 

Для двух множеств отрезков <tex>S</tex> и <tex>S'</tex> определим множество <tex>Int(S, S')</tex> как <tex>\{ {s, s'} | (s \in S, s' \in S') \& (s \ intersect \ s') \}</tex>.
}}
[[Файл:Balaban_pic_1.png|280px|thumb|right|<tex>D = ((s_1, s_2, s_3), \langle a, b \rangle)</tex>, <tex>Loc(D, s_4) = 0</tex>, <tex>Loc(D, s_5) = 2</tex> или <tex>3</tex>, <tex>Int(D, \{s_4,\ s_5\}) = \{\{s_3,\ s_5\}\}</tex>]]

Обозначения <tex>Int_{a, b}(S)</tex> и <tex>Int_{a, b}(S, S')</tex> будут использоваться для описания подмножеств <tex>Int(S)</tex> и <tex>Int(S, S')</tex>, состоящих из пересекающихся пар отрезков в пределах полосы <tex>\langle a, b \rangle</tex>. Далее скобки <tex>\{\}</tex> используются для определения неупорядоченных множеств, а скобки <tex>()</tex> используются для определения упорядоченных множеств.

Введем отношение порядка на множестве отрезков <tex>s_1 <_a s_2</tex> если оба отрезка пересекают вертикальную линию <tex>x = a</tex> и
точка пересечения этой прямой с отрезком <tex>s_1</tex> лежит ниже точки пересечения с <tex>s_2</tex>.

{{Определение
|neat=neat
|definition=
''Лестница'' <tex>D</tex> — это пара <tex>(Q, \langle a, b \rangle)</tex>, в которой отрезки из множества <tex>Q</tex> удовлетворяют следующим условиям :
− любой отрезок из <tex>Q</tex> охватывает полосу <tex>\langle a, b \rangle</tex>; 
− нет пересечений отрезков внутри лестницы; 
− <tex>Q</tex> упорядочена по отношению <tex><_a</tex>.

Часть отрезков лестницы внутри полосы будем называть '''ступеньками'''.
}}

{{Определение
|definition=
Будем называть лестницу <tex>D</tex> '''полной''' относительно множества отрезков <tex>S</tex>, если каждый отрезок из <tex>S</tex> либо не охватывает полосу <tex>\langle a, b \rangle</tex>, либо пересекает хотя бы одну из ступенек из множества <tex>D</tex>.
}}

{{Лемма
|id=lemma1
|statement=
Пусть лестница <tex>D</tex> полна относительно множества отрезков <tex>S</tex>, где <tex>S</tex> состоит из отрезков, пересекающих полосу <tex>\langle a, b \rangle</tex>, тогда <tex>|S| \le Ends_{a, b}(S) + |Int(D, S)|</tex>, 
где <tex>Ends_{a, b}(S)</tex> это число вершин отрезков из <tex>S</tex>, находящихся в пределах полосы <tex>\langle a, b \rangle</tex>.
}}

{{Определение
|definition=
Если точка <tex>p</tex> отрезка <tex>s</tex> лежит между ступеньками <tex>i</tex> и <tex>i + 1</tex>, тогда число <tex>i</tex> называется ''местоположением'' <tex>s</tex> на лестнице <tex>D</tex> и обозначается как <tex>Loc(D, s)</tex>
}}

{{Утверждение
|statement=
Имея лестницу <tex>D = (Q, \langle a, b \rangle)</tex> и множество отрезков <tex>S</tex>, множество <tex>Int(D, S)</tex> можно найти за время <tex>O(|S| log|Q| + |Int(D, S)|)</tex>. 
Однако, если <tex>S’</tex> упорядочено отношением <tex><_x</tex>, где <tex>x \in [a, b]</tex>, тогда можно найти <tex>Int(D, S)</tex> за время <tex>O(|S| + |Q| + |Int(D, S)|)</tex>.
}}

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

Введем несколько дополнительных функций, чтобы упростить основной алгоритм:

===Split===

Функция <tex>Split</tex> разделяет входное множество отрезков <tex>L</tex>, охватывающих некоторую полосу <tex>\langle a, b \rangle</tex>, на подмножества <tex>Q</tex> и <tex>L'</tex> так, что лестница <tex>(Q, \langle a, b \rangle)</tex> полна относительно множества отрезков <tex>L'</tex>.

Пусть <tex>L = (s_1 ,..., s_k)</tex>, где <tex>s_i <_a s_{i+1}</tex>
<tex>Split_{a, b}(L, Q, L')</tex>
<tex>\{</tex>
<tex>L' \leftarrow \varnothing; Q \leftarrow \varnothing</tex>
'''for''' <tex>j = 1,...,k</tex> '''do'''
'''if''' отрезок <tex>S_j</tex> не пересекает
последний отрезок из <tex>Q</tex> внутри полосы <tex>\langle a, b \rangle</tex>
и при этом охватывает её '''then'''
добавить <tex>s_j</tex> в конец <tex>Q;</tex>
'''else'''
добавить <tex>s_j</tex> в конец <tex>L';</tex>
<tex>\}</tex>

Эта функция работает за <tex>O(|L|)</tex> времени.

===Search In Strip===

Зная <tex>L</tex> мы можем найти <tex>Int_{a, b}(L)</tex> и <tex>R</tex> используя следующую рекурсивную функцию:

<tex>SearchInStrip_{a, b}(L, R)</tex>
<tex>\{</tex>
<tex>Split(L, Q, L');</tex>
'''if''' <tex>L' = \varnothing</tex> '''then'''
<tex>R \leftarrow Q;</tex>
'''return'''<tex>;</tex>
Найдем <tex>Int_{a, b}(Q, L');</tex>
<tex>SearchInStrip_{a, b} (L', R');</tex>
<tex>R \leftarrow Merge_b(Q, R’);</tex>
<tex>\}</tex>

Здесь, <tex>Merge_x(S_1, S_2)</tex> это функция объединения множеств <tex>S_1</tex> и <tex>S_2</tex>, упорядоченных по отношению <tex><_x</tex>. Время выполнения <tex>SearchInStrip</tex> эквивалентно сумме времён каждого её запуска. Очевидно, что время работы <tex>i</tex>-той функции, будет равно <tex>O(|L_i| + |Int_{a, b}(Q_i, {L_i}')|)</tex>, где <tex>L_i, Q_i, {L_i}'</tex> это соответствующие наборы <tex>(L_0 = L, L_{i+1} = {L_i}')</tex>.

Учитывая [[#lemma1|лемму]], заключаем, что функция <tex>SearchInStrip_{a, b}(L, R)</tex> работает за <tex>O(|L| + |Int_{a, b}(L)|)</tex>.

Предположим, что все отрезки лежат в полосе <tex>\langle a, b\rangle</tex>. Таким образом в самом начале у нас есть пара <tex>(S, \langle a, b\rangle)</tex>.
Что же дальше происходит: множество <tex>S</tex> ''распадается'' в подмножества <tex>Q</tex> и <tex>S'</tex>, после чего лестница <tex>D = (Q, \langle a, b \rangle)</tex> становится полной относительно множества <tex>S'</tex>. Необходимо найти пересечения отрезков из <tex>D</tex> и <tex>S'</tex>, затем, все пересечения в <tex>S'</tex>. Чтобы найти пересечения отрезков в <tex>S'</tex>, мы ''режем'' полосу <tex>\langle a, b \rangle</tex> и множество <tex>S'</tex> по вертикале <tex>x = c</tex> на полосы <tex>\langle a, c \rangle</tex>, <tex>\langle c, b \rangle</tex> и множества <tex>S'_{ls}</tex>, <tex>S'_{rs}</tex> соответственно, где <tex>c</tex> является медианой вершин отрезков между <tex>a</tex> и <tex>b</tex>. Затем мы рекурсивно вызываем функцию к парам <tex>(S'_{ls}, \langle a, c \rangle)</tex> и <tex>(S'_{rs}, \langle c, b \rangle)</tex>. Ключевым является тот факт, что согласно [[#lemma1|лемме]] <tex>|S'| \le Ends_{a, b}(S') + |Int(D, S')|</tex>, таким образом, число дополнительных отрезков, появляющихся после ''разрезаний'' пропорционально числу найденных пересечений.

===Ключевые моменты===

Давайте разберемся с алгоритмом более подробно:

Не умаляя общности, предположим, что все пересечения и вершины отрезков имеют разные абсциссы (в конечном счете, их можно будет отсортировать введением дополнительных свойств). Будем рассматривать целые координаты на промежутке <tex>[1, 2N]</tex>. Обозначим через <tex>p_i</tex> слева направо конец отрезка множества <tex>S_0</tex>, а через <tex>s(i)</tex> отрезок, которому он принадлежит соответственно.

Основная задача нашего алгоритма, это рекурсивная функция <tex>TreeSearch</tex>. Соединим каждый вызов функции с узлом некоего двоичного дерева (далее ''рекурсивное дерево''). Соответствующим узлом отметим все значения, множества и параметры вызова. Обозначим множество внутренних вершин за <tex>V</tex>.

<tex>IntersectingPairs(S_0):</tex>
Отсортируем <tex>2 \cdot N</tex> вершин по координатам и
найдем <tex>p_i, s(i), i = 1,...,2 \cdot N;\ S_r \leftarrow S_0</tex>
<tex>TreeSearch(S_r, 1, 2 \cdot N)</tex>;

<tex>TreeSearch(S_v, a, b):</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>L \leftarrow</tex> отсортируем <tex>S_v</tex> по отношению <tex><_a</tex>;
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
Разделим <tex>S_v</tex> на <tex>Q_v</tex> и <tex>S_v'</tex> так, что лестница
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex> будет полной, относительно множества <tex>S_v'</tex>;
Найдем <tex>Int(D_v, S_v')</tex>;
<tex>c \leftarrow \lfloor (a + b)/2 \rfloor</tex>;
Разделим отрезки из <tex>S_v'</tex> на пересекающих
полосу <tex>\langle a, c \rangle</tex> <tex>S_{ls}(v)</tex> и
полосу <tex>\langle c, b \rangle</tex> <tex>S_{rs}(v)</tex>;
<tex>TreeSearch(S_{ls}(v), a, c)</tex>;
<tex>TreeSearch(S_{rs}(v), c, b)</tex>;
<tex>\}</tex>

Отсюда и дальше <tex>ls(v)</tex>, <tex>rs(v)</tex> и <tex>ft(v)</tex> означают, соответственно, левого сына, правого сына, и отцовскую вершину узла <tex>v</tex>.
Наша задача показать, что все операции с узлом <tex>v</tex> происходят за <tex>O(|S_v| + |Int(D_v, S_v')| + (a_v - b_v)logN)</tex>, для этого возьмем во внимание, что <tex>\sum_v |S_v| = O(N \cdot logN + K)</tex> (очевидно, что <tex>\sum_v |Int(D_v, S_v')| \le K</tex>).

[[Файл:Balaban_pic_2.png|280px|thumb|right|<tex>S_v = (s_1, s_2, s_3, s_4, s_5)</tex>, <tex>L_v = (s_1, s_3)</tex>, <tex>R_v = (s_3, s_4)</tex>, <tex>I_v = (s_2, s_5)</tex>]]

Функция <tex>TreeSearch</tex> похожа на функцию <tex>SearchInStrip</tex>. Основная разница заключается в том, что <tex>SearchInStrip</tex> вызывает себя без изменения полосы, когда <tex>TreeSearch</tex> делит полосу на две части, после чего рекурсивно вызывает себя для них. Другое отличие заключается в том, что множество <tex>S_v</tex> не упорядочено так же, как <tex>L</tex>. В результате мы не можем напрямую использовать функцию <tex>Split</tex> для эффективного деления <tex>S_v</tex>.

Чтобы решить эту проблему, представим <tex>S_v</tex> как объединение трех множеств:
множества <tex>L_v</tex> упорядоченного по отношению <tex><_a</tex>, неупорядоченного множества <tex>I_v</tex>, и множества <tex>R_v</tex> упорядоченного по отношению <tex><_b</tex>. Расположим отрезки из <tex>S_v</tex>, пересекающие границу <tex>x = a</tex> во множество <tex>L_v</tex>, отрезки пересекающие <tex>x = b</tex> во множество <tex>R_v</tex>, и внутренние отрезки во множество <tex>I_v</tex> (пример на ''рисунке справа'').

Теперь мы можем вызвать функцию <tex>Split</tex> для множества <tex>L_v</tex> и построить <tex>Q_v</tex> за <tex>O(|L_v|) = O(|S_v|)</tex> времени. Но мы натыкаемся на новую проблему: передавая множества <tex>L_v</tex>, <tex>I_v</tex> и <tex>R_v</tex>, необходимо найти соответствующие множества сыновей узла <tex>v</tex>.

Неупорядоченные множества <tex>I_{ls(v)}</tex> и <tex>I_{rs(v)}</tex> строятся легко. Множество <tex>L_{ls(v)}</tex> будет найдено вызовом функции <tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex> для нахождения <tex>Int(D_v, S_v')</tex> в функции <tex>TreeSearch</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> за линейное время вставкой (если <tex>p_c</tex> левая вершина отрезка) или удалением (если <tex>p_c</tex> правая вершина отрезка) отрезка <tex>s(c)</tex>. Но как получить <tex>R_{ls(v)}</tex> из <tex>L_v</tex>, <tex>R_v</tex> и <tex>I_v</tex> без сортировки?

Для листьев мы сделаем проверку вначале, и получим <tex>R_v</tex> из <tex>L_v</tex>. Пусть <tex>L_v</tex> и <tex>I_v</tex> известны, и все сыновья узла <tex>v</tex> - листья. Для начала запустим функцию <tex>Split(L_v, Q_v, L_{ls(v)})</tex> и найдем <tex>Q_v</tex> и <tex>L_{ls(v)}</tex>. Теперь мы должны найти <tex>Int(D_s, S_v') = Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v) \cup Int(D_v, R_{rs(v)})</tex>, но мы не знаем <tex>R_{rs(v)}</tex> и, соответственно, можем найти только <tex>Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v)</tex>. Применим <tex>SearchInStrip</tex> к множеству <tex>L_{ls(v)}</tex> и получим <tex>R_{ls(v)}</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> вставкой или удалением отрезка <tex>s(c)</tex>. Применим <tex>SearchInStrip</tex> к <tex>L_{rs(v)}</tex> и найдем <tex>R_{rs(v)}</tex>. Теперь можем продолжить вычисление <tex>Int(D_v, R_{rs(v)})</tex> и получим <tex>R_v</tex> слиянием <tex>Q_v</tex> и <tex>R_{rs(v)}</tex>.

Конечная функция будет выглядеть так:
<tex>IntersectingPairs(S_0)</tex>
<tex>\{</tex>
Отсортируем <tex>2N</tex> концов отрезков по абсциссе
и найдем <tex>p_i</tex>, <tex>s(i)</tex> где <tex>i = 1, ..., 2N</tex>;
<tex>L_r \leftarrow (s(1))</tex>; <tex>I_r \leftarrow S_0 \setminus (\{s(1)\} \cup \{s(2N)\})</tex>;
<tex>TreeSearch(L_r, I_r, 1, 2N, R_r)</tex>;
<tex>\}</tex>

<tex>TreeSearch(L_v, I_v, a, b, R_v)</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
<tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex>;
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex>;
Найдем <tex>Int(D_v, L_{ls(v)})</tex>;
<tex>c \leftarrow \lfloor (a + b) / 2 \rfloor</tex>;
Разделяем отрезки из <tex>I_v</tex>
внутренние для полосы <tex>\langle a, c \rangle</tex> во множество <tex>I_{ls(v)}</tex>
внутренние для полосы <tex>\langle c, b \rangle</tex> во множество <tex>I_{rs(v)}</tex>
<tex>TreeSearch(L_{ls(v)}, I_{ls(v)}, a, c, R_{ls(v)})</tex>;
'''if''' <tex>p_c</tex> левый конец отрезка <tex>s(c)</tex> '''then'''
<tex>L_{rs(v)} \leftarrow</tex> вставить <tex>s(c)</tex> в <tex>R_{ls(v)}</tex>
'''else'''
<tex>L_{rs(v)} \leftarrow</tex> удалить <tex>s(c)</tex> из <tex>R_{ls(v)}</tex>
<tex>TreeSearch(L_{rs(v)}, I_{rs(v)}, c, b, R_{rs(v)})</tex>;
Найдем <tex>Int(D_v, R_{rs(v)})</tex>;
'''for''' <tex>s \in I_v</tex> '''do'''
Найдем <tex>Loc(D_v, s)</tex> используя двоичный поиск;
Найдем <tex>Int(D_v, I_v)</tex> используя значения, полученные шагом выше;
<tex>R_v \leftarrow Merge_b(Q_v, R_{rs(v)})</tex>;
<tex>\}</tex>

Заметим, что нахождение <tex>Int(D_v, R_{rs(v)})</tex> надо делать аккуратно, так как множества <tex>R_{rs(v)}</tex> и <tex>L_{ls(v)}</tex> могут иметь одни и те же отрезки (которые '''пересекают''' <tex>\langle a, b \rangle</tex>). Мы нашли их пересечения с <tex>D_v</tex> при поиске <tex>Int(D_v, L_{ls(v)})</tex>, и не должны вывести эти пересечения снова.

==Время работы==

Для начала рассчитаем место, необходимое для выполнения алгоритма. Алгоритм использует рекурсивную функцию <tex>TreeSearch</tex>. Последовательность вызовов функции может занять память. Эта последовательность может быть представлена как путь корня рекурсивного дерева, до узла. Соответствующий вызов этого узла занимает <tex>O(N)</tex> памяти, каждый его "предок" занимает <tex>O(|I_v| + |Q_v|)</tex> памяти, а остальные структуры используют <tex>O(N)</tex>. Очевидно, что любой путь <tex>pt</tex> от корня рекурсивного дерева до какого-то узла <tex>\sum_{v \in pt}(|I_v + |Q_v|) = O(N)(|I_v| \le b_v - a_v \le \lceil (b_{ft(v)} - a_{ft(v)})/2 \rceil)</tex>.

В итоге для работы алгоритма требуется <tex>O(N)</tex> памяти.

{{Лемма
|id=lemma2
|about=
#2
|statement=
<tex>\forall v \in V \ |S_v'| \le a_v - b_v + |Int(D_v, S_v')|</tex>.
|proof=
Утверждение напрямую вытекает из [[#lemma1|первой леммы]] и очевидного факта, что для любого множества <tex>S \subset S_0</tex>, количество концов отрезков, лежащих в полосе <tex>\langle a_v, b_v \rangle</tex>, меньше чем <tex>b_v - a_v</tex>.
}}

{{Теорема
|about=
#1
|statement=
<tex>\sum_{v \in V} |S_v'| \le 2N \lceil logN + 1 \rceil + K</tex>
|proof=
Утверждение напрямую вытекает из [[#lemma2|леммы №2]] и следующего отношения <tex>\sum_v (b_v - a_v) \le 2N \lceil logN + 1 \rceil</tex>.
}}

Обозначим множество всех вершин рекурсивного дерева за <tex>RT</tex>.

{{Теорема
|about=
#2
|statement=
<tex>\sum_{v \in RT} |S_v| \le N \lceil 4logN + 5 \rceil + 2K</tex>
|proof=
Для всех узлов, кроме корня <tex>r</tex> имеет место выражение <tex>|S_v| \le |S_{ft(v)}'|</tex>, следовательно <tex>\sum_{v \in RT} |S_v| \le |S_r| + \sum_{v \in RT \setminus r} |S_{ft(v)}| \le N + 2 \sum_{v \in V} |S_v'| \le N \lceil 4 logN + 5 \rceil + 2K</tex>.
}}

Начальная сортировка и инициализация множеств <tex>L_r</tex> и <tex>I_r</tex> может быть произведена за <tex>O(N logN)</tex> времени. Время работы функции <tex>TreeSearch</tex> является суммой длительностей всех его вызовов. Каждый вызов от внешних узлов добавляет к этой сумме <tex>O(|L_v| + |Int_{a, b}(L_v)|)</tex>. Для внутренних же узлов, время требуемое для поиска <tex>Loc(D_v, s)</tex> равно <tex>O(|I_v| log N)</tex>, а для остальных <tex>O(|S_v| + |Int(D_v, S_v')|)</tex>. Если мы все это сложим, то придем к выводу, что наш алгоритм работает за <tex>O(N log^2 N + K)</tex>. Заметим, что его скорость можно увеличить до <tex>O(N logN + K)</tex>, если не будем учитывать время нахождения <tex>Loc(D_v, s)</tex>.

Соответственно в оптимальном алгоритме Балабана <tex>Loc(D_v, s)</tex> находится за <tex>O(1)</tex>.

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

<references/>

==Литература==

[http://www.graphicon.ru/proceedings/2010/conference/RU/Se4/021.pdf ''Т.Вознюк, В.Терещенко {{---}} К построению эффективного решения задачи пересечения отрезков''] 
[http://booksshare.net/books/math/preparata-f/1989/files/vichgeometr.pdf ''Ф.Препарата, М.Шеймос {{---}} Вычислительная геометрия''] 

[[Категория: Вычислительная геометрия]]

Алгоритм Балабана

2013-11-30T07:36:25Z

194.85.161.34: /* Split */

{{В разработке}}

'''Алгоритм Балабана''' {{---}} детерминированный алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются. 

==Введение==

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

1.) Тривиальный детерминированный алгоритм имеет временную сложность <tex>O(n^2)</tex>, и его суть заключается в проверке попарного пересечения отрезков.

2.) Сложнее, но эффективнее алгоритм Бентли-Оттмана <ref>[http://neerc.ifmo.ru/wiki/index.php?title=Алгоритм_Бентли-Оттмана ''Алгоритм Бентли-Оттмана'']</ref> с оценкой сложности <tex>O((n + k)\ log(n)+k)</tex>, в основе которого лежит метод заметающей прямой.

3.) Алгоритм, предложенный Чазелле и Едельсбруннером <ref>[http://www.cs.princeton.edu/~chazelle/pubs/IntersectLineSegments.pdf ''An optimal algorithm for intersecting line segments in the plane'']</ref>, имеет лучшую оценку <tex>O(n\ log(n) + k)</tex>, но в отличие от предыдущих методов требует квадратичной памяти.

4.) Оптимальный детерминированный алгоритм был предложен Балабаном <ref>[http://www.cs.sfu.ca/~binay/813.2011/Balaban.pdf ''I.J. Balaban. An optimal algorithm for finding segments intersections. In Proceedings of the Eleventh Annual Symposium on Computational Geometry, ACM Press, New York, 1995. - pp. 211–219.'']</ref> с временной оценкой сложности <tex>O(n\ log(n) + k)</tex> и <tex>O(n)</tex> памяти, где К - число пересекающихся отрезков.

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

==Основные понятия==

Введем некоторые обозначения. Пусть <tex>Int(S)</tex> - множество всех точек пересечения отрезков из множества <tex>S</tex>, а <tex>K = |Int(S)|</tex> - количество таких пересечений ; 
Через <tex>\langle a, b \rangle</tex> обозначим вертикальную полосу, которая ограничена прямыми <tex>x = a</tex> и <tex>x = b</tex>, а через <tex>s</tex> {{---}} отрезок с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex>. 
Рассмотрим взаимное расположение вертикальной полосы <tex>\langle a, b \rangle</tex> и отрезка <tex>s</tex>.

{{Определение
|definition=
Будем говорить, что отрезок <tex>s</tex>, с вершинами в точках с абсциссами <tex>l</tex> и <tex>r</tex> :
- '''охватывает'''(span) полосу <tex>\langle a, b \rangle</tex>, если <tex>l \le a \le b \le r</tex>; 
- '''внутренний'''(inner) для полосы <tex>\langle a, b \rangle</tex>, если <tex>a < l < r < b</tex>; 
- '''пересекает'''(cross) полосу <tex>\langle a, b \rangle</tex> в других случаях.
}}

{{Определение
|definition=
Два отрезка <tex>s_1</tex> и <tex>s_2</tex> называются ''пересекающимися внутри'' полосы <tex>\langle a, b \rangle</tex>, если их точка пересечения лежит в пределах этой полосы. 

Для двух множеств отрезков <tex>S</tex> и <tex>S'</tex> определим множество <tex>Int(S, S')</tex> как <tex>\{ {s, s'} | (s \in S, s' \in S') \& (s \ intersect \ s') \}</tex>.
}}
[[Файл:Balaban_pic_1.png|280px|thumb|right|<tex>D = ((s_1, s_2, s_3), \langle a, b \rangle)</tex>, <tex>Loc(D, s_4) = 0</tex>, <tex>Loc(D, s_5) = 2</tex> или <tex>3</tex>, <tex>Int(D, \{s_4,\ s_5\}) = \{\{s_3,\ s_5\}\}</tex>]]

Обозначения <tex>Int_{a, b}(S)</tex> и <tex>Int_{a, b}(S, S')</tex> будут использоваться для описания подмножеств <tex>Int(S)</tex> и <tex>Int(S, S')</tex>, состоящих из пересекающихся пар отрезков в пределах полосы <tex>\langle a, b \rangle</tex>. Далее скобки <tex>\{\}</tex> используются для определения неупорядоченных множеств, а скобки <tex>()</tex> используются для определения упорядоченных множеств.

Введем отношение порядка на множестве отрезков <tex>s_1 <_a s_2</tex> если оба отрезка пересекают вертикальную линию <tex>x = a</tex> и
точка пересечения этой прямой с отрезком <tex>s_1</tex> лежит ниже точки пересечения с <tex>s_2</tex>.

{{Определение
|neat=neat
|definition=
''Лестница'' <tex>D</tex> — это пара <tex>(Q, \langle a, b \rangle)</tex>, в которой отрезки из множества <tex>Q</tex> удовлетворяют следующим условиям :
− любой отрезок из <tex>Q</tex> охватывает полосу <tex>\langle a, b \rangle</tex>; 
− нет пересечений отрезков внутри лестницы; 
− <tex>Q</tex> упорядочена по отношению <tex><_a</tex>.

Часть отрезков лестницы внутри полосы будем называть '''ступеньками'''.
}}

{{Определение
|definition=
Будем называть лестницу <tex>D</tex> '''полной''' относительно множества отрезков <tex>S</tex>, если каждый отрезок из <tex>S</tex> либо не охватывает полосу <tex>\langle a, b \rangle</tex>, либо пересекает хотя бы одну из ступенек из множества <tex>D</tex>.
}}

{{Лемма
|id=lemma1
|statement=
Пусть лестница <tex>D</tex> полна относительно множества отрезков <tex>S</tex>, где <tex>S</tex> состоит из отрезков, пересекающих полосу <tex>\langle a, b \rangle</tex>, тогда <tex>|S| \le Ends_{a, b}(S) + |Int(D, S)|</tex>, 
где <tex>Ends_{a, b}(S)</tex> это число вершин отрезков из <tex>S</tex>, находящихся в пределах полосы <tex>\langle a, b \rangle</tex>.
}}

{{Определение
|definition=
Если точка <tex>p</tex> отрезка <tex>s</tex> лежит между ступеньками <tex>i</tex> и <tex>i + 1</tex>, тогда число <tex>i</tex> называется ''местоположением'' <tex>s</tex> на лестнице <tex>D</tex> и обозначается как <tex>Loc(D, s)</tex>
}}

{{Утверждение
|statement=
Имея лестницу <tex>D = (Q, \langle a, b \rangle)</tex> и множество отрезков <tex>S</tex>, множество <tex>Int(D, S)</tex> можно найти за время <tex>O(|S| log|Q| + |Int(D, S)|)</tex>. 
Однако, если <tex>S’</tex> упорядочено отношением <tex><_x</tex>, где <tex>x \in [a, b]</tex>, тогда можно найти <tex>Int(D, S)</tex> за время <tex>O(|S| + |Q| + |Int(D, S)|)</tex>.
}}

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

Введем несколько дополнительных функций, чтобы упростить основной алгоритм:

===Split===

Функция <tex>Split</tex> разделяет входное множество отрезков <tex>L</tex>, охватывающих некоторую полосу <tex>\langle a, b \rangle</tex>, на подмножества <tex>Q</tex> и <tex>L'</tex> так, что лестница <tex>(Q, \langle a, b \rangle)</tex> полна относительно множества отрезков <tex>L'</tex>.

Пусть <tex>L = (s_1 ,..., s_k)</tex>, где <tex>s_i <_a s_{i+1}</tex>
<tex>Split_{a, b}(L, Q, L')</tex>
<tex>\{</tex>
<tex>L' \leftarrow \varnothing; Q \leftarrow \varnothing</tex>
'''for''' <tex>j = 1,...,k</tex> '''do'''
'''if''' отрезок <tex>S_j</tex> не пересекает
последний отрезок из <tex>Q</tex> внутри полосы <tex>\langle a, b \rangle</tex>
и при этом охватывает её '''then'''
добавить <tex>s_j</tex> в конец <tex>Q;</tex>
'''else'''
добавить <tex>s_j</tex> в конец <tex>L';</tex>
<tex>\}</tex>

Эта функция работает за <tex>O(|L|)</tex> времени.

===Search In Strip===

Зная <tex>L</tex> мы можем найти <tex>Int_{a, b}(L)</tex> и <tex>R</tex> используя следующую рекурсивную функцию:

<tex>SearchInStrip_{a, b}(L, R)</tex>
<tex>\{</tex>
<tex>Split(L, Q, L');</tex>
'''if''' <tex>L' = \varnothing</tex> '''then'''
<tex>R \leftarrow Q;</tex>
'''return'''<tex>;</tex>
Найдем <tex>Int_{a, b}(Q, L');</tex>
<tex>SearchInStrip_{a, b} (L', R');</tex>
<tex>R \leftarrow Merge_b(Q, R’);</tex>
<tex>\}</tex>

Здесь, <tex>Merge_x(S_1, S_2)</tex> это функция объединения множеств <tex>S_1</tex> и <tex>S_2</tex>, упорядоченных по отношению <tex><_x</tex>. Время выполнения <tex>SearchInStrip</tex> эквивалентно сумме времён каждого её запуска. Очевидно, что время работы <tex>i</tex>-той функции, будет равно <tex>O(|L_i| + |Int_{a, b}(Q_i, {L_i}')|)</tex>, где <tex>L_i, Q_i, {L_i}'</tex> это соответствующие наборы <tex>(L_0 = L, L_{i+1} = {L_i}')</tex>.

Учитывая [[#lemma1|лемму]], заключаем, что функция <tex>SearchInStrip_{a, b}(L, R)</tex> работает за <tex>O(|L| + |Int_{a, b}(L)|)</tex>.

Предположим, что все отрезки лежат в полосе <tex>\langle a, b\rangle</tex>. Таким образом в самом начале у нас есть пара <tex>(S, \langle a, b\rangle)</tex>.
Что же дальше происходит: множество <tex>S</tex> ''распадается'' в подмножества <tex>Q</tex> и <tex>S'</tex>, после чего лестница <tex>D = (Q, \langle a, b \rangle)</tex> становится полной относительно множества <tex>S'</tex>. Необходимо найти пересечения отрезков из <tex>D</tex> и <tex>S'</tex>, затем, все пересечения в <tex>S'</tex>. Чтобы найти пересечения отрезков в <tex>S'</tex>, мы ''режем'' полосу <tex>\langle a, b \rangle</tex> и множество <tex>S'</tex> по вертикале <tex>x = c</tex> на полосы <tex>\langle a, c \rangle</tex>, <tex>\langle c, b \rangle</tex> и множества <tex>S'_{ls}</tex>, <tex>S'_{rs}</tex> соответственно, где <tex>c</tex> является медианой вершин отрезков между <tex>a</tex> и <tex>b</tex>. Затем мы рекурсивно вызываем функцию к парам <tex>(S'_{ls}, \langle a, c \rangle)</tex> и <tex>(S'_{rs}, \langle c, b \rangle)</tex>. Ключевым является тот факт, что согласно [[#lemma1|лемме]] <tex>|S'| \le Ends_{a, b}(S') + |Int(D, S')|</tex>, таким образом, число дополнительных отрезков, появляющихся после ''разрезаний'' пропорционально числу найденных пересечений.

===Ключевые моменты===

Давайте разберемся с алгоритмом более подробно:

Не умаляя общности, предположим, что все пересечения и вершины отрезков имеют разные абсциссы (в конечном счете, их можно будет отсортировать введением дополнительных свойств). Будем рассматривать целые координаты на промежутке <tex>[1, 2N]</tex>. Обозначим через <tex>p_i</tex> слева направо конец отрезка множества <tex>S_0</tex>, а через <tex>s(i)</tex> отрезок, которому он принадлежит соответственно.

Основная задача нашего алгоритма, это рекурсивная функция <tex>TreeSearch</tex>. Соединим каждый вызов функции с узлом некоего двоичного дерева (далее ''рекурсивное дерево''). Соответствующим узлом отметим все значения, множества и параметры вызова. Обозначим множество внутренних вершин за <tex>V</tex>.

<tex>IntersectingPairs(S_0):</tex>
Отсортируем <tex>2 \cdot N</tex> вершин по координатам и
найдем <tex>p_i, s(i), i = 1,...,2 \cdot N;\ S_r \leftarrow S_0</tex>
<tex>TreeSearch(S_r, 1, 2 \cdot N)</tex>;

<tex>TreeSearch(S_v, a, b):</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>L \leftarrow</tex> отсортируем <tex>S_v</tex> по отношению <tex><_a</tex>;
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
Разделим <tex>S_v</tex> на <tex>Q_v</tex> и <tex>S_v'</tex> так, что лестница
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex> будет полной, относительно множества <tex>S_v'</tex>;
Найдем <tex>Int(D_v, S_v')</tex>;
<tex>c \leftarrow \lfloor (a + b)/2 \rfloor</tex>;
Разделим отрезки из <tex>S_v'</tex> на пересекающих
полосу <tex>\langle a, c \rangle</tex> <tex>S_{ls}(v)</tex> и
полосу <tex>\langle c, b \rangle</tex> <tex>S_{rs}(v)</tex>;
<tex>TreeSearch(S_{ls}(v), a, c)</tex>;
<tex>TreeSearch(S_{rs}(v), c, b)</tex>;
<tex>\}</tex>

Отсюда и дальше <tex>ls(v)</tex>, <tex>rs(v)</tex> и <tex>ft(v)</tex> означают, соответственно, левого сына, правого сына, и отцовскую вершину узла <tex>v</tex>.
Наша задача показать, что все операции с узлом <tex>v</tex> происходят за <tex>O(|S_v| + |Int(D_v, S_v')| + (a_v - b_v)logN)</tex>, для этого возьмем во внимание, что <tex>\sum_v |S_v| = O(N \cdot logN + K)</tex> (очевидно, что <tex>\sum_v |Int(D_v, S_v')| \le K</tex>).

[[Файл:Balaban_pic_2.png|280px|thumb|right|<tex>S_v = (s_1, s_2, s_3, s_4, s_5)</tex>, <tex>L_v = (s_1, s_3)</tex>, <tex>R_v = (s_3, s_4)</tex>, <tex>I_v = (s_2, s_5)</tex>]]

Функция <tex>TreeSearch</tex> похожа на функцию <tex>SearchInStrip</tex>. Основная разница заключается в том, что <tex>SearchInStrip</tex> вызывает себя без изменения полосы, когда <tex>TreeSearch</tex> делит полосу на две части, после чего рекурсивно вызывает себя для них. Другое отличие заключается в том, что множество <tex>S_v</tex> не упорядочено так же, как <tex>L</tex>. В результате мы не можем напрямую использовать функцию <tex>Split</tex> для эффективного деления <tex>S_v</tex>.

Чтобы решить эту проблему, представим <tex>S_v</tex> как объединение трех множеств:
множества <tex>L_v</tex> упорядоченного по отношению <tex><_a</tex>, неупорядоченного множества <tex>I_v</tex>, и множества <tex>R_v</tex> упорядоченного по отношению <tex><_b</tex>. Расположим отрезки из <tex>S_v</tex>, пересекающие границу <tex>x = a</tex> во множество <tex>L_v</tex>, отрезки пересекающие <tex>x = b</tex> во множество <tex>R_v</tex>, и внутренние отрезки во множество <tex>I_v</tex> (пример на ''рисунке справа'').

Теперь мы можем вызвать функцию <tex>Split</tex> для множества <tex>L_v</tex> и построить <tex>Q_v</tex> за <tex>O(|L_v|) = O(|S_v|)</tex> времени. Но мы натыкаемся на новую проблему: передавая множества <tex>L_v</tex>, <tex>I_v</tex> и <tex>R_v</tex>, необходимо найти соответствующие множества сыновей узла <tex>v</tex>.

Неупорядоченные множества <tex>I_{ls(v)}</tex> и <tex>I_{rs(v)}</tex> строятся легко. Множество <tex>L_{ls(v)}</tex> будет найдено вызовом функции <tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex> для нахождения <tex>Int(D_v, S_v')</tex> в функции <tex>TreeSearch</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> за линейное время вставкой (если <tex>p_c</tex> левая вершина отрезка) или удалением (если <tex>p_c</tex> правая вершина отрезка) отрезка <tex>s(c)</tex>. Но как получить <tex>R_{ls(v)}</tex> из <tex>L_v</tex>, <tex>R_v</tex> и <tex>I_v</tex> без сортировки?

Для листьев мы сделаем проверку вначале, и получим <tex>R_v</tex> из <tex>L_v</tex>. Пусть <tex>L_v</tex> и <tex>I_v</tex> известны, и все сыновья узла <tex>v</tex> - листья. Для начала запустим функцию <tex>Split(L_v, Q_v, L_{ls(v)})</tex> и найдем <tex>Q_v</tex> и <tex>L_{ls(v)}</tex>. Теперь мы должны найти <tex>Int(D_s, S_v') = Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v) \cup Int(D_v, R_{rs(v)})</tex>, но мы не знаем <tex>R_{rs(v)}</tex> и, соответственно, можем найти только <tex>Int(D_v, L_{ls(v)}) \cup Int(D_v, I_v)</tex>. Применим <tex>SearchInStrip</tex> к множеству <tex>L_{ls(v)}</tex> и получим <tex>R_{ls(v)}</tex>. Множество <tex>L_{rs(v)}</tex> получается из <tex>R_{ls(v)}</tex> вставкой или удалением отрезка <tex>s(c)</tex>. Применим <tex>SearchInStrip</tex> к <tex>L_{rs(v)}</tex> и найдем <tex>R_{rs(v)}</tex>. Теперь можем продолжить вычисление <tex>Int(D_v, R_{rs(v)})</tex> и получим <tex>R_v</tex> слиянием <tex>Q_v</tex> и <tex>R_{rs(v)}</tex>.

Конечная функция будет выглядеть так:
<tex>IntersectingPairs(S_0)</tex>
<tex>\{</tex>
Отсортируем <tex>2N</tex> концов отрезков по абсциссе
и найдем <tex>p_i</tex>, <tex>s(i)</tex> где <tex>i = 1, ..., 2N</tex>;
<tex>L_r \leftarrow (s(1))</tex>; <tex>I_r \leftarrow S_0 \setminus (\{s(1)\} \cup \{s(2N)\})</tex>;
<tex>TreeSearch(L_r, I_r, 1, 2N, R_r)</tex>;
<tex>\}</tex>

<tex>TreeSearch(L_v, I_v, a, b, R_v)</tex>
<tex>\{</tex>
'''if''' <tex>b - a = 1</tex> '''then'''
<tex>\{</tex>
<tex>SearchInStrip_{a, b}(L_v, R_v)</tex>;
'''return''';
<tex>\}</tex>
<tex>Split_{a, b}(L_v, Q_v, L_{ls(v)})</tex>;
<tex>D_v \leftarrow (Q_v, \langle a, b \rangle)</tex>;
Найдем <tex>Int(D_v, L_{ls(v)})</tex>;
<tex>c \leftarrow \lfloor (a + b) / 2 \rfloor</tex>;
Разделяем отрезки из <tex>I_v</tex>
внутренние для полосы <tex>\langle a, c \rangle</tex> во множество <tex>I_{ls(v)}</tex>
внутренние для полосы <tex>\langle c, b \rangle</tex> во множество <tex>I_{rs(v)}</tex>
<tex>TreeSearch(L_{ls(v)}, I_{ls(v)}, a, c, R_{ls(v)})</tex>;
'''if''' <tex>p_c</tex> левый конец отрезка <tex>s(c)</tex> '''then'''
<tex>L_{rs(v)} \leftarrow</tex> вставить <tex>s(c)</tex> в <tex>R_{ls(v)}</tex>
'''else'''
<tex>L_{rs(v)} \leftarrow</tex> удалить <tex>s(c)</tex> из <tex>R_{ls(v)}</tex>
<tex>TreeSearch(L_{rs(v)}, I_{rs(v)}, c, b, R_{rs(v)})</tex>;
Найдем <tex>Int(D_v, R_{rs(v)})</tex>;
'''for''' <tex>s \in I_v</tex> '''do'''
Найдем <tex>Loc(D_v, s)</tex> используя двоичный поиск;
Найдем <tex>Int(D_v, I_v)</tex> используя значения, полученные шагом выше;
<tex>R_v \leftarrow Merge_b(Q_v, R_{rs(v)})</tex>;
<tex>\}</tex>

Заметим, что нахождение <tex>Int(D_v, R_{rs(v)})</tex> надо делать аккуратно, так как множества <tex>R_{rs(v)}</tex> и <tex>L_{ls(v)}</tex> могут иметь одни и те же отрезки (которые '''пересекают''' <tex>\langle a, b \rangle</tex>). Мы нашли их пересечения с <tex>D_v</tex> при поиске <tex>Int(D_v, L_{ls(v)})</tex>, и не должны вывести эти пересечения снова.

==Время работы==

Для начала рассчитаем место, необходимое для выполнения алгоритма. Алгоритм использует рекурсивную функцию <tex>TreeSearch</tex>. Последовательность вызовов функции может занять память. Эта последовательность может быть представлена как путь корня рекурсивного дерева, до узла. Соответствующий вызов этого узла занимает <tex>O(N)</tex> памяти, каждый его "предок" занимает <tex>O(|I_v| + |Q_v|)</tex> памяти, а остальные структуры используют <tex>O(N)</tex>. Очевидно, что любой путь <tex>pt</tex> от корня рекурсивного дерева до какого-то узла <tex>\sum_{v \in pt}(|I_v + |Q_v|) = O(N)(|I_v| \le b_v - a_v \le \lceil (b_{ft(v)} - a_{ft(v)})/2 \rceil)</tex>.

В итоге для работы алгоритма требуется <tex>O(N)</tex> памяти.

{{Лемма
|id=lemma2
|about=
#2
|statement=
<tex>\forall v \in V \ |S_v'| \le a_v - b_v + |Int(D_v, S_v')|</tex>.
|proof=
Утверждение напрямую вытекает из [[#lemma1|первой леммы]] и очевидного факта, что для любого множества <tex>S \subset S_0</tex>, количество концов отрезков, лежащих в полосе <tex>\langle a_v, b_v \rangle</tex>, меньше чем <tex>b_v - a_v</tex>.
}}

{{Теорема
|about=
#1
|statement=
<tex>\sum_{v \in V} |S_v'| \le 2N \lceil logN + 1 \rceil + K</tex>
|proof=
Утверждение напрямую вытекает из [[#lemma2|леммы №2]] и следующего отношения <tex>\sum_v (b_v - a_v) \le 2N \lceil logN + 1 \rceil</tex>.
}}

Обозначим множество всех вершин рекурсивного дерева за <tex>RT</tex>.

{{Теорема
|about=
#2
|statement=
<tex>\sum_{v \in RT} |S_v| \le N \lceil 4logN + 5 \rceil + 2K</tex>
|proof=
Для всех узлов, кроме корня <tex>r</tex> имеет место выражение <tex>|S_v| \le |S_{ft(v)}'|</tex>, следовательно <tex>\sum_{v \in RT} |S_v| \le |S_r| + \sum_{v \in RT \setminus r} |S_{ft(v)}| \le N + 2 \sum_{v \in V} |S_v'| \le N \lceil 4 logN + 5 \rceil + 2K</tex>.
}}

Начальная сортировка и инициализация множеств <tex>L_r</tex> и <tex>I_r</tex> может быть произведена за <tex>O(N logN)</tex> времени. Время работы функции <tex>TreeSearch</tex> является суммой длительностей всех его вызовов. Каждый вызов от внешних узлов добавляет к этой сумме <tex>O(|L_v| + |Int_{a, b}(L_v)|)</tex>. Для внутренних же узлов, время требуемое для поиска <tex>Loc(D_v, s)</tex> равно <tex>O(|I_v| log N)</tex>, а для остальных <tex>O(|S_v| + |Int(D_v, S_v')|)</tex>. Если мы все это сложим, то придем к выводу, что наш алгоритм работает за <tex>O(N log^2 N + K)</tex>. Заметим, что его скорость можно увеличить до <tex>O(N logN + K)</tex>, если не будем учитывать время нахождения <tex>Loc(D_v, s)</tex>.

Соответственно в оптимальном алгоритме Балабана <tex>Loc(D_v, s)</tex> находится за <tex>O(1)</tex>.

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

<references/>

==Литература==

[http://www.graphicon.ru/proceedings/2010/conference/RU/Se4/021.pdf ''Т.Вознюк, В.Терещенко {{---}} К построению эффективного решения задачи пересечения отрезков''] 
[http://booksshare.net/books/math/preparata-f/1989/files/vichgeometr.pdf ''Ф.Препарата, М.Шеймос {{---}} Вычислительная геометрия''] 

[[Категория: Вычислительная геометрия]]

Алгоритм Балабана

2013-09-26T11:20:00Z

194.85.161.34:

{{В разработке}}

'''Алгоритм Балабана''' {{---}} детерминированный алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются 

==Введение==

Методы поиска пересечений отрезков разделяются на детерминированные и недетерминированные. Тривиальный детерминированный алгоритм имеет временную сложность <tex>O(n^2)</tex> и суть его заключается в проверке попарного пересечения отрезков.

Сложнее, но эффективнее алгоритм Бентли-Отмена <ref>[http://neerc.ifmo.ru/wiki/index.php?title=Алгоритм_Бентли-Оттмана ''Алгоритм Бентли-Оттмана'']</ref> с оценкой сложности <tex>O((n + k)\ log(n)+k)</tex>, в основе которого лежит метод заметающей прямой.

Алгоритм, предложенный Чазеле и Едельсбруннером <ref>[http://booksshare.net/books/math/preparata-f/1989/files/vichgeometr.pdf ''Ф.Препарата, М.Шеймос {{---}} Вычислительная геометрия (стр. 348 - 350)'']</ref>, имеет лучшую оценку <tex>O(n\ log(n) + k)</tex>, но в отличие от предыдущих методов требует квадратичной памяти.

Оптимальный детерминированный алгоритм был предложен Балабаном <ref>[http://www.cs.sfu.ca/~binay/813.2011/Balaban.pdf ''I.J. Balaban. An optimal algorithm for finding segments intersections. In Proceedings of the Eleventh Annual Symposium on Computational Geometry, ACM Press, New York, 1995. - pp. 211–219.'']</ref> с временной оценкой сложности <tex>O(n\ log(n) + k)</tex> и <tex>O(n)</tex> памяти.

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

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

<references/>

==Литература==

[http://www.graphicon.ru/proceedings/2010/conference/RU/Se4/021.pdf ''Т.Вознюк, В.Терещенко {{---}} К построению эффективного решения задачи пересечения отрезков''] 
[http://booksshare.net/books/math/preparata-f/1989/files/vichgeometr.pdf ''Ф.Препарата, М.Шеймос {{---}} Вычислительная геометрия''] 

[[Категория: Вычислительная геометрия]]

Алгоритм Балабана

2013-09-26T11:09:29Z

194.85.161.34: /* Литература */

{{В разработке}}

'''Алгоритм Балабана''' {{---}} детерминированный алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются 

==Введение==

Методы поиска пересечений отрезков разделяются на детерминированные и недетерминированные. Тривиальный детерминированный алгоритм имеет временную сложность <tex>O(n^2)</tex> и суть его заключается в проверке попарного пересечения отрезков. Сложнее, но эффективнее алгоритм Бентли-Отмена <ref>[http://neerc.ifmo.ru/wiki/index.php?title=Алгоритм_Бентли-Оттмана ''Алгоритм Бентли-Оттмана'']</ref> с оценкой сложности <tex>O((n + k)\ log(n)+k)</tex>, в основе которого лежит метод заметающей прямой. Оптимальный детерминированный алгоритм был предложен Балабаном <ref>[http://www.cs.sfu.ca/~binay/813.2011/Balaban.pdf ''I.J. Balaban. An optimal algorithm for finding segments intersections. In Proceedings of the Eleventh Annual Symposium on Computational Geometry, ACM Press, New York, 1995. - pp. 211–219.'']</ref> с временной оценкой сложности <tex>O(n\ log(n) + k)</tex> и <tex>O(n)</tex> памяти.

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

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

<references/>

==Литература==

[http://www.graphicon.ru/proceedings/2010/conference/RU/Se4/021.pdf ''Т.Вознюк, В.Терещенко {{---}} К построению эффективного решения задачи пересечения отрезков''] 
[http://booksshare.net/books/math/preparata-f/1989/files/vichgeometr.pdf ''Ф.Препарата, М.Шеймос {{---}} Вычислительная геометрия''] 

[[Категория: Вычислительная геометрия]]

Алгоритм Балабана

2013-09-26T11:05:45Z

194.85.161.34: add ''in creating'' lable

{{В разработке}}

'''Алгоритм Балабана''' {{---}} детерминированный алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются 

==Введение==

Методы поиска пересечений отрезков разделяются на детерминированные и недетерминированные. Тривиальный детерминированный алгоритм имеет временную сложность <tex>O(n^2)</tex> и суть его заключается в проверке попарного пересечения отрезков. Сложнее, но эффективнее алгоритм Бентли-Отмена <ref>[http://neerc.ifmo.ru/wiki/index.php?title=Алгоритм_Бентли-Оттмана ''Алгоритм Бентли-Оттмана'']</ref> с оценкой сложности <tex>O((n + k)\ log(n)+k)</tex>, в основе которого лежит метод заметающей прямой. Оптимальный детерминированный алгоритм был предложен Балабаном <ref>[http://www.cs.sfu.ca/~binay/813.2011/Balaban.pdf ''I.J. Balaban. An optimal algorithm for finding segments intersections. In Proceedings of the Eleventh Annual Symposium on Computational Geometry, ACM Press, New York, 1995. - pp. 211–219.'']</ref> с временной оценкой сложности <tex>O(n\ log(n) + k)</tex> и <tex>O(n)</tex> памяти.

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

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

<references/>

==Литература==

[http://www.graphicon.ru/proceedings/2010/conference/RU/Se4/021.pdf ''К построению эффективного решения задачи пересечения отрезков''] 

[[Категория: Вычислительная геометрия]]

Сопряжённый оператор

2013-06-06T11:33:03Z

194.85.161.34: /* Сопряженный оператор */

{{В разработке}}

Все рассматриваемые далее пространства считаем Банаховыми.

== Естественное вложение ==

<tex> E^* </tex> {{---}} множество линейных непрерывных функционалов над <tex> E </tex>. <tex> E^* </tex> называют пространством, сопряженным к <tex> E </tex>.

Аналогично, <tex> E^{**} </tex> {{---}} пространство, сопряженное к <tex> E^* </tex>.

Между <tex> E </tex> и <tex> E^{**} </tex> существует так называемый '''естественный изоморфизм''', сохраняющий норму точки. {{TODO|t=?}}

Введем <tex> F_x </tex> следующим образом: <tex> F_x (f) = f(x), f \in E^{*} </tex>.

<tex> F_x : E^{*} \to \mathbb{R} </tex>, тогда <tex> F_x \in E^{**} </tex>.

Тогда само <tex> F </tex> отображает <tex> E </tex> в <tex> E^{**} </tex>.

<tex> F </tex> линейно: <tex> F_{\alpha x_1 + \beta x_2} = \alpha F_{x_1} + \beta F_{x_2} </tex>.

<tex> | F_x(f) | = |f(x)| \le \| f \| \| x \| </tex>, откуда <tex> \| F_x \| \le \| x \| </tex>.

С другой стороны, по теореме Хана-Банаха, <tex> \forall x_0 \in E, \exists f_0 \in E^* </tex>, что выполняются два условия:
# <tex> f_0(x_0) = \| x_0 \| </tex>
# <tex> \| f_0 \| = 1 </tex>.

<tex> | F_{x_0} (f_0) | = f_0 (x_0) = \| x_0 \|, \| f_0 \| = 1 </tex>, потому получаем, что <tex> \| F_{x_0} \| \ge \| x_0 \| \implies \| F_{x_0} \| = \| x_0 \| </tex>.

Значит, получившееся преобразование <tex> x \mapsto F_x </tex> {{---}} изометрия, <tex> \| x \| = \| F_x \| </tex>, получили '''естественное вложение''' <tex> E </tex> в <tex> E^{**} </tex>.

<tex> E </tex> называется '''рефлексивным''', если <tex> E </tex> будет совпадать с <tex> E^{**} </tex> при таком отображении.

Например, гильбертово пространство <tex> H </tex> рефлексивно (следует из теоремы Рисса об общем виде линейного функционала).

<tex> C[0, 1] </tex> {{---}} не является рефлексивным.

== Сопряженный оператор ==

Пусть оператор <tex> A </tex> действует из <tex> E </tex> в <tex> F </tex>, и функционал <tex> \varphi </tex> принадлежит <tex> F^* </tex>.

Рассмотрим <tex> f(x) = \varphi (Ax), | f(x) | \le \| \varphi \| \| A \| \| x \| </tex>.

Получили новый функционал <tex> f </tex>, принадлежащий <tex> E^* </tex>. <tex> \varphi \mapsto \varphi A </tex>.

<tex> \varphi A = A^* (\varphi), A^* : F^* \to E^* </tex>. <tex> A^* </tex> {{---}} '''сопряженный оператор''' к <tex> A </tex>.

{{Теорема
|statement=
Если <tex> A </tex> {{---}} линейный ограниченный оператор, то <tex> \| A^* \| = \| A \| </tex>.
|proof=
Возьмем <tex> x \in E, \varphi \in F^* </tex>.

<tex> | A^* (\varphi, x) | = | \varphi (Ax) | \le \| A \| \| \varphi \| \| x \| </tex>.

Получили, что <tex> \| A^* (\varphi) \| \le \| A \| \| \varphi \| </tex>, откуда <tex> \| A^* \| \le \| A \| </tex>.

Для доказательства в обратную сторону используем теорему Хана-Банаха:

По определению нормы: <tex> \forall \varepsilon > 0 \, \exists x: \| x \| = 1 \implies \| A \| - \varepsilon < \| Ax \| </tex>.

<tex> Ax \in F </tex>, по теореме Хана-Банаха подберем <tex> \varphi_0 \in F^*, \| \varphi_0 \| = 1: \varphi_0 (Ax) = \| Ax \| </tex>.

<tex> \| A^*(\varphi_0, x) \| = | \varphi_0(Ax) | = \| Ax \| > \| A \| - \varepsilon </tex>.

<tex> \| A^*(\varphi_0, x) \| \le \| A^*(\varphi_0) \| \| x \| = \| A^*(\varphi_0) \| \le \| A^* \| \| \varphi_0 \| = \| A^* \| </tex>.

Соединяя эти два неравенства, получаем, что <tex> \forall \varepsilon > 0: \| A^* \| > \| A \| - \varepsilon </tex>.

Устремляя <tex> \varepsilon </tex> к нулю, получаем, что <tex> \| A^* \| \ge \| A \| </tex>, и, окончательно, <tex> \| A^* \| = \| A \| </tex>.

}}

== Примеры сопряженных операторов ==

Возьмем любое гильбертово пространство <tex> H </tex>, <tex> A : H \to H </tex>.

<tex> \forall \varphi \in H^* </tex> по теореме Рисса об общем виде линейного функционала в <tex> H </tex> существует
<tex> z : \varphi (y) = \langle y, z \rangle, \| \varphi \| = \| z \| </tex>.

Поскольку <tex> x \mapsto \varphi (Ax) </tex> также является линейным функционалом <tex> H \to H </tex>, то <tex> \varphi (Ax) = \langle Ax, z \rangle = \langle x, y \rangle </tex>, где <tex> y </tex> не зависит от <tex> x </tex>.

Имеем отображение <tex> z \mapsto y </tex>, тогда <tex> y = A^*(z) </tex>, и окончательно:

<tex> \langle Ax, z \rangle = \langle x, A^*z \rangle </tex>.

В гильбертовом пространстве <tex> H </tex> сопряженный оператор {{---}} тот оператор, который позволяет писать равенство выше.

{{Определение
|definition=
Оператор <tex> A </tex> называется '''самосопряженным''', если <tex> A = A^* </tex>
}}

В случае <tex> \mathbb{R}^n </tex> (частный случай <tex> H </tex>) оператор <tex> A : \mathbb{R}^n \to \mathbb{R}^n </tex> представляет собой матрицу размером <tex> n \times n </tex>. Сопряженный к <tex> A </tex> оператор получается транспонированием соответствующей матрицы: <tex> A^* = A^T </tex>. Для симметричной матрицы <tex> A </tex> получается <tex> A^* = A^T = A </tex>, то есть, если <tex> A </tex> {{---}} симметричная матрица, то <tex> A </tex> {{---}} самосопряженный оператор.

Рассмотрим теперь пространство <tex> E = L_p [0, 1] </tex>.

Пусть <tex> K(u, v) : [0, 1] \times [0, 1] \to \mathbb{R} </tex> {{---}} непрерывная функция на <tex> [0, 1] \times [0, 1] </tex>, <tex> x \in E </tex>.

'''Интегральный оператор''' <tex> A </tex>, действующий из <tex> L_p [0, 1] </tex> в <tex> L_p [0, 1] </tex> определяется так: <tex> A(x, s) = (Ax)(s) = \int\limits_0^1 K(s, t) x(t) dt </tex>. <tex> Ax \in E </tex>.

Построим сопряженный оператор:

По теореме об общем виде линейного функционала в <tex> L_p </tex> {{TODO|t=ее у нас в курсе не было. КАК НЕ БЫЛО-ТО???777 НИЧЕГО ШТО ЭТО ГИЛЬБЕРТОВО ПРОСТРАНСТВО!!?? -- Вот только <tex>L_p</tex> не совсем гильбертово, ага? (<tex>p \neq 2</tex>)}},

<tex> \forall \varphi \in E^*, x \in E: \varphi(x) = \int\limits_0^1 y(t) x(t) dt, y \in L_q </tex>, где <tex> \frac 1p + \frac 1q = 1 </tex> (<tex> p </tex> и <tex> q </tex> называются '''сопряженными показателями''').

<tex> L_p^* = L_q </tex>.

<tex> A^*(\varphi, x) = \varphi (Ax) = \int\limits_0^1 y(s) (Ax)(s) ds = \int\limits_0^1 y(s) (\int\limits_0^1 K(s, t) x(t) dt) ds = </tex> (по теореме Фубини поменяем порядок интегрирования) <tex> = \int\limits_0^1 ( \int\limits_0^1 K(s, t) y(s) ds) x(t) dt </tex>

Получили, что <tex> A^*(\varphi, x) = \int\limits_0^1 ( \int\limits_0^1 K(s, t) y(s) ds) x(t) dt </tex>. Обозначим <tex> z(t) = \int\limits_0^1 K(s, t) y(s) ds </tex>, тогда <tex> A^* (\varphi) \equiv z </tex>, аналогично <tex> \varphi \equiv y </tex>.

<tex> A^* </tex> {{---}} интегральный оператор из <tex> L_q </tex>, имеющий ядро <tex> K^*(s, t) = K(t, s) </tex>. В частности, если ядро симметрично (<tex> K(s, t) = K(t, s) </tex>), и <tex> k = 2 </tex>, то <tex> A = A^* </tex>

== Ортогональное дополнение ==

Важное значение имеет '''ортогональное дополнение''' (в любом нормированном пространстве):

<tex> E </tex> {{---}} НП, <tex> S \subset E^* </tex>.

<tex> S^{\bot} = \{ x \in E \mid \forall f \in S: f(x) = 0 \} </tex> {{---}} ортогональное дополнение <tex> S \subset E^* </tex>.

Аналогично определяется для <tex> T \subset E : T^{\bot} = \{ f \in E^* \mid \forall x \in T: f(x) = 0 \} </tex>.

{{Утверждение
|statement= <tex> \{ 0 \} = (E^*)^{\bot}, \{ 0 \} = E^{\bot} </tex>.
|proof=

Оба включения <tex> \subset </tex> очевидны по определению. В обратную сторону:

Пусть <tex> x \in (E^*)^{\bot} </tex>, тогда <tex> \forall f \in E^*: f(x) = 0 </tex>

Предположим, что <tex> x \neq 0 </tex>, тогда по теореме Хана-Банаха, <tex> \exists f: f(x) = \| x \| \neq 0 </tex>, получили противоречие, что <tex> x \in (E^*)^{\bot} </tex>.

Второе включение в обратную сторону доказывается аналогично.
}}

== Теоремы о множестве значений оператора ==

{{TODO|t=придумать нормальный заголовок}}

=== Теорема 1 ===

{{Теорема
|statement= <tex> A \in \mathcal{L}(E,F) \implies \operatorname{Cl} R(A) = (\operatorname{Ker} A^*)^\perp </tex>.
|proof = {{TODO | t = написать доказательство}}
}}

=== Теорема 2 ===

{{Теорема
|statement= <tex> A \in \mathcal{L}(E,F),~R(A) = \operatorname{Cl} R(A) \implies R(A^*) = (\operatorname{Ker} )^\perp </tex>.
|proof = {{TODO | t = написать доказательство}}
}}

PCP-теорема

2013-03-18T11:03:00Z

194.85.161.34: /* Экспандер графы */

{{Теорема
|id=pcp_th
|about=<tex>\mathrm{PCP}</tex> теорема
|statement=<tex>\mathrm{PCP}[\log n, O(1)] = \mathrm{NP}</tex>
}}

Классическое доказательство [[Класс PCP|<tex>\mathrm{PCP}</tex>]] теоремы громоздкое и довольно сложное для восприятия,
рассмотрим вариант докаательства, предложенный Динуром. Оно основано на том, что <tex>\mathrm{PCP}</tex>-теорема [[Эквивалентность_PCP-теоремы_и_теоремы_о_трудности_аппроксимации | эквивалентна <tex>\mathrm{NP}</tex>-трудности задачи <tex>\rho-GAPqCSP</tex>]].

==Определения и леммы, используемые в доказательстве==
{{Определение
|definition= <tex>\mathcal{C}=\lbrace c_1,..., c_n\rbrace</tex> назовем множеством условий над
множеством переменных <tex>V</tex>.
}}
{{Определение
|definition=Число неудовлетворенности <tex>UNSAT(\mathcal{C})</tex> — минимальное подмножество неудовлетворенных условий для любых возможных назначений <tex>V</tex>. <tex>\mathcal{C}</tex> удовлетворимо тогда и только тогда, когда <tex>UNSAT(\mathcal{C})=0</tex>. Если же <tex>\mathcal{C}</tex> неудовлетворимо, тогда <tex>UNSAT(\mathcal{C}) \ge \frac 1 n</tex>.
}}

===Графы условий===
Нам понадобятся графы ограничений для двух переменных, которые определяются следующим образом:
{{Определение
|definition=
<tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex> называется графом условий, если:
* <tex>(V,E)</tex> — неориентированный граф, называемый графом, леащим в основе <tex>G</tex>.
* Множество <tex>V</tex> также представляется в виде множества переменных принимающих значениями из алфавита <tex>\Sigma</tex>
* Каждое ребро <tex>e \in E</tex> содержит условие <tex>c(e) \subseteq \Sigma^2</tex> и <tex>\mathcal{C}=\lbrace c(e)\rbrace_{e \in E}</tex>. Условие <tex>c(e)</tex> называется удовлетворенным парой <tex>(a, b)</tex>, если <tex>(a, b) \in c(e)</tex>
}}

Присваивание это отображение <tex>\sigma:V \rightarrow \Sigma</tex>, которое назначает каждой вершине из <tex>V</tex>
значение из <tex>\Sigma</tex>. Для любого присвоения <tex>\sigma</tex> определим <tex>UNSAT_\sigma(G) = \operatorname*{Pr}\limits_{(u,v)\in E} [(\sigma(u),\sigma(v)) \notin c(e)]</tex> и <tex>UNSAT(G) = \operatorname*{min}\limits_\sigma UNSAT_\sigma(G)</tex>.

Назовем <tex>UNSAT(G)</tex> числом неудовлетворенности графа <tex>G</tex>. Размером графа будем считать размер его описания <tex>size(G)=O(|V|+|E| \cdot |\Sigma|^2)</tex>

{{Лемма
|statement=Для заданного графа условий <tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex>, где <tex>|\Sigma|=3</tex> проверка утверждения <tex>UNSAT(G)=0</tex> — <tex>\mathrm{NP}</tex>-трудная задача.
|proof=
Сведем <tex>3Color</tex> к нашей задаче. Дан граф <tex>G</tex>, алфавит <tex>\Sigma=\lbrace 1,2,3 \rbrace</tex> для трех цветов. Оснастим ребра условиями неравенства. Очевидно, что <tex>G \in 3Color</tex> тогда и только тогда, когда <tex>UNSAT(G)=0<tex> (Иногда удобно использовать одно и то же обозначение <tex>G</tex> для графа условий и графа, лежащего в его основе).
}}

===Экспандер графы===
Экспандер графы играют важную роль во многих теоретических результатах.

{{Определение
|definition= <tex>G=(V,E)</tex> <tex>d</tex>-регулярный граф. Положим <tex>E(S,\overline{S})=|(S \times \overline{S}) \cap E|</tex> равным количеству ребер их подмножества <tex>S\in V</tex> в его дополнение. Определим реберное расширение как
<tex>h(G)=\operatorname*{min}\limits_{S:|S|<\frac {|V|} 2} \frac {E(S, \overline S)} {|S|}</tex>
}}

{{Лемма
|about=О экспандерах
|statement=Существует <tex>d_0 \in \mathbb{N}</tex> и <tex>h_0 >0</tex> такие, что есть построимое за полиномиальное время семейство <tex>\lbrace X_n\rbrace_{n \in \mathbb{N}}</tex> <tex>d_0</tex>-регулярных графов <tex>X_n</tex> с <tex>n</tex> вершинами таких, что <tex>h(X_n) \ge h_0</tex>.
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

{{Лемма
|statement= Пусть <tex>G</tex> <tex>d</tex>-регулярный граф, а <tex>h(G)</tex> его реберное расширение. Тогда <tex>\lambda(G) \le d - \frac {h(G)^2} d</tex>
}}

{{Определение
|definition=Собственным числом графа <tex>\lambda</tex> называют собственное число его матрицы смежности.
}}

{{Лемма
|statement=Пусть <tex>G</tex> <tex>d</tex>-регулярный граф со вторым по величине собственным числом <tex>\lambda</tex>. Пусть <tex>F \subseteq E</tex> множество ребер. Вероятность <tex>p</tex> того, что случайный путь, начинающийся со случайного ребра из <tex>F</tex> на <tex>i+1</tex> шаге попадет <tex>F</tex> ограничена <tex>\frac {|F|} {|E|} + \left({\frac {|\lambda|} d}\right)^i</tex>.
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}


==Операции на графах условий==
Для доказательства <tex>\mathrm{PCP}</tex> теоремы потребуются три операции над графами уловий:
* Препроцессинг. Простая операция, сохраняющая чило неудовлетворенности(примерно) и размер алфавита, но делающая граф лучше.
* Усиление. Эта операция увеоичивает чило неудовлетворенности за счет увеличения размера алфавита.
* Композицияю Эта операция уменьшает размер алфавита, сохраняя число неудовлетворенности(приблизительно).

===Препроцессинг===
Под хорошим графом будем понимать регулярный, фиксированной степени экспандер граф.
{{Лемма
|about=Препроцессинг
|statement= существуют константы <tex>0 < \lambda < d</tex> и <tex>\beta_1 >0</tex> такие, что любой граф условий <tex>G</tex> может быть преобразован в граф условий <tex>G'=prep(G)</tex> такой, что:
* <tex>G'</tex> <tex>d</tex>-регулярный
* <tex>G'</tex> имеет тот же алфавит, что и <tex>G</tex> и <tex>size(G') = O(size(G))</tex>.
* <tex>\beta_1 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
}}

Заметим, что третий пункт теммы гарантирует поддержание полноты, т.е. если <tex>UNSAT(G)=0</tex>, то и <tex>UNSAT(G')=0</tex>. Доказательство этой леммы состоит из двух следующих лемм (<tex>\beta_1=c \cdot \frac d {d + d_0 + 1}</tex>).

{{Лемма
|about=Константная степень
|statement=Любой граф условий <tex>G = \langle (V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>(d_0 + 1)</tex>-регулярный граф условий <tex>G'=\langle (V',E'),\Sigma,\mathcal{C}'\rangle</tex> такой, что <tex>|V'|</tex>=2|E|</tex> и <tex>c \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>. Для некоторых заданных констант <tex>d_0,c>0</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

Эта лемма известна как экспандер-замена(expander-replacement transformation).

{{Лемма
|about=О расширении
|statement=
Пусть <tex>d_0, h_0 >0</tex> некоторые константы. Любой <tex>d</tex>-регулярный граф условий <tex>G</tex> может быть преобразован в <tex>G'</tex> такой, что:
* <tex>G'</tex> <tex>(d + d_0 + 1)</tex>-регулярный, имеет собственные циклы и <tex>\lambda(G') \le d + d_0 + 1 - \frac {h_0^2} {d + d_0 + 1} < deg(G')</tex>
* <tex>size(G')=O(size(G))</tex>
* <tex> \frac d {d + d_0 + 1} \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

===Усиление===
Это новая операция на системах условий, которая увеличивает число неудовлетворенности.
Пусть <tex>G=\langle (V,E),\Sigma,\mathcal{C}\rangle<tex> граф условий, <tex>t \in \mathbb{N}</tex>. Определим <tex>G^t=\langle (V,\mathbf{E}),\Sigma^{d^{\lceil t/2\rceil}}, \mathcal{C}^t \rangle</tex> как следующий граф условий:
* Веришины <tex>G^t</tex> совпадают с вершинами <tex>G</tex>
* Ребра: <tex>u</tex> и <tex>v</tex> соединены <tex>k</tex> ребрами в <tex>\mathbf{E}</tex>, если количество путей длины <tex>t</tex> из <tex>u</tex> в <tex>v</tex> в графе <tex>G</tex> равно <tex>k</tex>
* Алфавит: алфавит графа <tex>G^t</tex> <tex>\Sigma^{d^{\lceil t/2\rceil}}</tex>, где каждой вершине сопоставлены значения ее соседей, достижимых за <tex>\frac t 2</tex> шагов.
* Условия: Условия сопоставленные ребру <tex>e=(u,v) \in \mathbf{E}</tex> удовлетворены, если назначения для <tex>u</tex> и <tex>v</tex> согласованы с назначениями, удовлетворяющими условия, порожденные <tex>\frac t 2</tex> соседями <tex>u</tex> и <tex>v</tex>.

Если <tex>UNSAT(G)=0</tex> тогда очевидно <tex>UNSAT(G^t)=0</tex>. Интереснее доказательство того, что <tex>UNSAT(G^t) \ge O(\sqrt{t} \cdot UNSAT(G)</tex>.

{{Лемма
|about=Усиление
|statement= Пусть <tex>\lambda < d</tex> и <tex>|\Sigma|</tex> произвольные константы. Тогда существует константа <tex>\beta_2=\beta_2(\lambda,d,|\Sigma|)>0</rex> такая, что для любого <tex>t \in \mathbb N</tex> и для любого <tex>d</tex>-регулярного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> с собственными циклами и <tex>\lambda(G)\le \lambda</tex>, <tex>UNSAT(G^t) \ge \beta_2 \sqrt{t} \cdot min \left({UNSAT(G), \frac 1 t}\right)</tex>.
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

Поскольку <tex>UNSAT(G) \le \frac 1 t</tex>, из жтой леммы следует что <tex>UNSAT(G^t) \ge O(\sqrt{t}) \cdot UNSAT(G)</tex>. Это основная техническая лемма.

===Композиция===
{{Определение
|about=Тестер присвоений
|definition=Тестер присвоений с алфавитом <tex>\Sigma_0</tex> и вероятностью отклонения <tex>\epsilon > 0</tex> это полиномиальное преобразование <tex>\mathcal{P}</tex>, принимающее на вход схему <tex>\Phi</tex> над будевыми переменными <tex>X</tex> и дающую на выходе граф условий <tex>G=\langle(V,E),\Sigma_0,\mathcal{C}\rangle</tex> такой, что <tex>V \subset X</tex>(в условном графе <tex>V</tex> играет одновременно две роли: переменных и вершин. <tex>Y \subset X</tex> подразумевает, что некоторые вершины из <tex>V</tex> определены с помощью переменных <tex>X</tex>). Пусть <tex>V'=V \setminus X</tex> и <tex>a : X \rightarrow \lbrace 0,1 \rbrace</tex> — присваивание.
* (Полнота) Если <tex>a \in SAT(\Phi)</tex> то существует <tex>b : V' \rightarrow \Sigma_0</tex> такое, что <tex>UNSAT_{a\cup{b}}(G)=0</tex>
* (Обоснованность) Если <tex>a \notin SAT(\Phi)</tex> то для всех <tex>b : V' \rightarrow \Sigma_0</tex>, <tex>UNSAT_{a\cup{b}}(G) \ge \epsilon \cdot dist(a, SAT(\Phi))</tex>.
}}

Следует заметить, что не накладывается никаких ограничений ни на время работы <tex>\mathcal{P}</tex> ни на <tex>size(G)</tex>. Мы игнорируем размер схемы <Tex>\Phi</tex>, которая может быть экспоненциальна относительно <tex>|X|</tex>.

{{Лемма
|about=Композиция
|statement=Пусть существует тестер присвоений <tex>\mathcal{P}</tex> с константной вероятностью отклонения <tex>\epsilon > 0</tex> и алфавитом <tex>\Sigma_0</tex>, <tex>|\Sigma_0|=O(1)</tex>. Тогда существует <tex>\beta_3 > 0</tex>, зависящая только от <tex>\mathcal{P}</tex>, такая что любой граф условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex>, обозначаемый <tex>G \circ \mathcal{C}</tex>, такой что <tex>size(G')=M(|\Sigma|) \cdot size(G)</tex> и <tex>\beta_3 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

==Основная теорема==
Основываясь на операциях с графами условий мы можем доказать основную теорему.
{{Теорема
|about=Основная теорема
|statement=Для любого <tex>\Sigma</tex>, <tex>|\Sigma|=O(1)</tex> существуют константы <tex>C > 0</tex> и <tex>0 < \alpha < 1</tex> такие, что для данного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> за полиномиальное время можно построить граф условий <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex> такой, что:
* <tex>size(G') \le C \cdot size(G)</tex> и <tex>|\Sigma_0| = O(1)</tex>
* (Полнота) Если <tex>UNSAT(G)=0</tex>, то <tex>UNSAT(G')=0</tex>
* (Обоснованность) <tex>UNSAT(G') \ge min(2 \cdot UNSAT(G), \alpha)</tex>
|proof=
Построим <tex>G'</tex> по <tex>G</tex> следующим образом: <tex>G'=(prep(G))^t \circ \mathcal{P}</tex>.
# (Препроцессинг) Пусть <tex>H_1=prep(G)</tex>. Существуют некоторые глобальные константы <tex>\lambda < d </tex> и <tex>\beta_1 >0</tex> такие, что <tex>H_1</tex> <tex>d</tex>-регулярный, имеет тот же алфавит, что и <tex>G</tex>, <tex>\lambda(H_1) \le \lambda < d</tex> и <tex>\beta_1 \cdot UNSAT*G( \le UNSAT(H_1) \le UNSAT(G)</tex>.
# (Усиление) Пусть <tex>H_2=(H_1)^t</tex> для достаточно большой константы <tex> t > 1</tex>, которую определим ниже. Существует некоторая константа <tex>\beta_2=\beta(\lambda, d, |\Sigma|) > 0</tex>, для которой <tex>UNSAT(H_2) \ge \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex>. Однако, алфавит вырос до <tex>\Sigma^{d^{\lceil t / 2 \rceil}}</tex>.
# (Композиция) Пусть <tex>G'=H_2 \circ \mathcal{P}</tex>. Это уменьшит алфавит до <tex>\Sigma_0</tex>, при <tex>\beta_3 \cdot UNSAT(H_2) \le UNSAT(G') \le UNSAT(H_2)</tex> для некоторой <tex>\beta_3 > 0 </tex>.

Проверим выполнение условий теоремы. Размер <tex>G'</tex> линеен относительно размера<tex>G</tex>, поскольку на каждом шагу увеличивался линейно. Полнота явно поддерживается на каждом шаге. Теперь выберем <tex>t=\left\lceil\left({\frac 2 {\beta_1\beta_2\beta_3}}\right)^2\right\rceil</tex>. Пусть <tex>\alpha=\frac {\beta_3\beta_2} {sqrt{t}}</tex>.
Таким образом,

<tex>UNSAT(G') \ge \beta_3 \cdot UNSAT(H_2)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(\beta_1 UNSAT(G_, \frac 1 t) </tex> <tex>\ge min(2 \cdot UNSAT(G), \alpha)</tex>
}}
===Доказательство PCP теоремы===
{{Лемма
|statement=Следствием из основной теоремы является <tex>\mathrm{NP}</tex>-трудность <tex>GAP-3SAT_s</tex>.
|proof=Сведем удовлетворимость графа условий к нашей задаче. Пусть <tex>G</tex> задача удовлетворимости некоторого графа с <tex>|\Sigma|=3</tex>. Идей состоит в повторении применения основной теоремы до тех пор, пока число неудовлетворенности не станет постоянным.

Пусть <tex>G_0 = G</tex> и <tex>G_i(i \ge 1)</tex> — результат применения основной теоремы к <tex>G_{i-1}</tex>. Тогда для <tex>i \ge 1</tex> <tex>G</tex> — граф условий с алфавитом <tex>\Sigma_0</tex>. Пусть <tex>E_0</tex> — множество ребер <tex>G_0<tex> и <tex>k=\log|E_0|=O(\log n)</tex>.

Полнота показывается тривиально: если <tex>UNSAT(G_0)=0</tex>, то для всех <tex>i</tex> <tex>UNSAT(G_i)=0</tex>. Для обоснованности рассмотрим <tex>UNSAT(G_0) > 0</tex>. Если для некоторого <tex>i*<k</tex>, <tex>UNSAT(G_{i*}) \ge \frac \alpha 2</tex>, то из основной теоремы следует, что для всех <tex>i>i*</tex> <tex>UNSAT(G_i)\ge \alpha</tex>. На остальные <tex>i</tex> это распространяется по индукции <tex>UNSAT(G_i) \ge min(2^i UNSAT(G_0), \alpha)</tex>.

Если <tex>UNSAT(G_0)>0</tex>, то <tex>UNSAT(G_0)\ge \frac 1 {|E_0|}</tex>. Конечно, <tex>2^k UNSAT(G_0) > \alpha</tex>. Таким образом <tex>UNSAT(G_k) \ge \alpha</tex>.

Такми образом <tex>\rho -GAP2CSP</tex> <tex>\mathrm{NP}</tex>-трудная. Достичь обоснованности <tex>\frac 1 2</tex> можно последовательным повторением <tex>u=\frac 1 {\log(\frac 1 {1 - \alpha})} </tex> раз. Тоесть создать новые условия, представляющие собой <tex>AND</tex> всех возможных <tex>u</tex>-наборов прежних условий. Конечно, при этом количество запросов на условие увеличится до <tex>2u</tex>.

}}

==Дополнительные материалы==
* [http://www.math.ias.edu/boaz/ExpanderCourse/|N. Linial and A. Wigderson. Expander graphs and their applications. Lecture notes of a course, 2003].
* Michael Sipser and Daniel A. Spielman. Expander codes. IEEE Trans. Inform. Theory, 42(6, part 1):1710–1722, 1996. Codes and complexity.
* C. Papadimitriou and M. Yannakakis. Optimization, approximation and complexity classes. Journal of Computer and System Sciences, 3:425–440, 1991.
* Irit Dinur and Omer Reingold. Assignment testers: Towards combinatorial proofs of the PCP theorem. In Proceedings of the 45th Symposium on Foundations of Computer Science (FOCS), 2004.
==Источники==
* [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005].
* [http://www.cs.utah.edu/~alfeld/LecturePDFs/pcp.pdf The PCP Theorem, Notes by Scott Alfeld, 2008].

PCP-теорема

2013-03-18T11:02:30Z

194.85.161.34: /* Экспандер графы */

{{Теорема
|id=pcp_th
|about=<tex>\mathrm{PCP}</tex> теорема
|statement=<tex>\mathrm{PCP}[\log n, O(1)] = \mathrm{NP}</tex>
}}

Классическое доказательство [[Класс PCP|<tex>\mathrm{PCP}</tex>]] теоремы громоздкое и довольно сложное для восприятия,
рассмотрим вариант докаательства, предложенный Динуром. Оно основано на том, что <tex>\mathrm{PCP}</tex>-теорема [[Эквивалентность_PCP-теоремы_и_теоремы_о_трудности_аппроксимации | эквивалентна <tex>\mathrm{NP}</tex>-трудности задачи <tex>\rho-GAPqCSP</tex>]].

==Определения и леммы, используемые в доказательстве==
{{Определение
|definition= <tex>\mathcal{C}=\lbrace c_1,..., c_n\rbrace</tex> назовем множеством условий над
множеством переменных <tex>V</tex>.
}}
{{Определение
|definition=Число неудовлетворенности <tex>UNSAT(\mathcal{C})</tex> — минимальное подмножество неудовлетворенных условий для любых возможных назначений <tex>V</tex>. <tex>\mathcal{C}</tex> удовлетворимо тогда и только тогда, когда <tex>UNSAT(\mathcal{C})=0</tex>. Если же <tex>\mathcal{C}</tex> неудовлетворимо, тогда <tex>UNSAT(\mathcal{C}) \ge \frac 1 n</tex>.
}}

===Графы условий===
Нам понадобятся графы ограничений для двух переменных, которые определяются следующим образом:
{{Определение
|definition=
<tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex> называется графом условий, если:
* <tex>(V,E)</tex> — неориентированный граф, называемый графом, леащим в основе <tex>G</tex>.
* Множество <tex>V</tex> также представляется в виде множества переменных принимающих значениями из алфавита <tex>\Sigma</tex>
* Каждое ребро <tex>e \in E</tex> содержит условие <tex>c(e) \subseteq \Sigma^2</tex> и <tex>\mathcal{C}=\lbrace c(e)\rbrace_{e \in E}</tex>. Условие <tex>c(e)</tex> называется удовлетворенным парой <tex>(a, b)</tex>, если <tex>(a, b) \in c(e)</tex>
}}

Присваивание это отображение <tex>\sigma:V \rightarrow \Sigma</tex>, которое назначает каждой вершине из <tex>V</tex>
значение из <tex>\Sigma</tex>. Для любого присвоения <tex>\sigma</tex> определим <tex>UNSAT_\sigma(G) = \operatorname*{Pr}\limits_{(u,v)\in E} [(\sigma(u),\sigma(v)) \notin c(e)]</tex> и <tex>UNSAT(G) = \operatorname*{min}\limits_\sigma UNSAT_\sigma(G)</tex>.

Назовем <tex>UNSAT(G)</tex> числом неудовлетворенности графа <tex>G</tex>. Размером графа будем считать размер его описания <tex>size(G)=O(|V|+|E| \cdot |\Sigma|^2)</tex>

{{Лемма
|statement=Для заданного графа условий <tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex>, где <tex>|\Sigma|=3</tex> проверка утверждения <tex>UNSAT(G)=0</tex> — <tex>\mathrm{NP}</tex>-трудная задача.
|proof=
Сведем <tex>3Color</tex> к нашей задаче. Дан граф <tex>G</tex>, алфавит <tex>\Sigma=\lbrace 1,2,3 \rbrace</tex> для трех цветов. Оснастим ребра условиями неравенства. Очевидно, что <tex>G \in 3Color</tex> тогда и только тогда, когда <tex>UNSAT(G)=0<tex> (Иногда удобно использовать одно и то же обозначение <tex>G</tex> для графа условий и графа, лежащего в его основе).
}}

===Экспандер графы===
Экспандер графы играют важную роль во многих теоретических результатах.

{{Определение
|definition= <tex>G=(V,E)</tex> <tex>d</tex>-регулярный граф. Положим <tex>E(S,\overline{S})=|(S \times \overline{S}) \cap E|</tex> равным количеству ребер их подмножества <tex>S\in V</tex> в его дополнение. Определим реберное расширение как
<tex>h(G)=\operatorname*{min}\limits_{S:|S|<\frac {|V|} 2} \frac {E(S, \overline S)} {|S|}</tex>
}}

{{Лемма
|about=О экспандерах
|statement=Существует <tex>d_0 \in \mathbb{N}</tex> и <tex>h_0 >0</tex> такие, что есть построимое за полиномиальное время семейство <tex>\lbrace X_n\rbrace_{n \in \mathbb{N}}</tex> <tex>d_0</tex>-регулярных графов <tex>X_n</tex> с <tex>n</tex> вершинами таких, что <tex>h(X_n) \ge h_0</tex>.
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

{{Лемма
|statement= Пусть <tex>G</tex> <tex>d</tex>-регулярный граф, а <tex>h(G)</tex> его реберное расширение. Тогда <tex>\lambda(G) \le d - \frac {h(G)^2} d</tex>
}}

{{Определение
|definition=Собственным числом графа <tex>\lambda</tex> называют собственное число его матрицы смежности.
}}

{{Лемма
|statement=Пусть <tex>G</tex> <tex>d</tex>-регулярный граф со вторым по величине собственным числом <tex>\lambda</tex>. Пусть <tex>F \subseteq E</tex> множество ребер. Вероятность <tex>p</tex> того, что случайный путь, начинающийся со случайного ребра из <tex>F</tex> на <tex>i+1</tex> шаге попадет <tex>F</tex> ограничена <tex>\frac {|F|} {|E|} + \left({\frac {|\lambda|} d}\right)^i</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}


==Операции на графах условий==
Для доказательства <tex>\mathrm{PCP}</tex> теоремы потребуются три операции над графами уловий:
* Препроцессинг. Простая операция, сохраняющая чило неудовлетворенности(примерно) и размер алфавита, но делающая граф лучше.
* Усиление. Эта операция увеоичивает чило неудовлетворенности за счет увеличения размера алфавита.
* Композицияю Эта операция уменьшает размер алфавита, сохраняя число неудовлетворенности(приблизительно).

===Препроцессинг===
Под хорошим графом будем понимать регулярный, фиксированной степени экспандер граф.
{{Лемма
|about=Препроцессинг
|statement= существуют константы <tex>0 < \lambda < d</tex> и <tex>\beta_1 >0</tex> такие, что любой граф условий <tex>G</tex> может быть преобразован в граф условий <tex>G'=prep(G)</tex> такой, что:
* <tex>G'</tex> <tex>d</tex>-регулярный
* <tex>G'</tex> имеет тот же алфавит, что и <tex>G</tex> и <tex>size(G') = O(size(G))</tex>.
* <tex>\beta_1 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
}}

Заметим, что третий пункт теммы гарантирует поддержание полноты, т.е. если <tex>UNSAT(G)=0</tex>, то и <tex>UNSAT(G')=0</tex>. Доказательство этой леммы состоит из двух следующих лемм (<tex>\beta_1=c \cdot \frac d {d + d_0 + 1}</tex>).

{{Лемма
|about=Константная степень
|statement=Любой граф условий <tex>G = \langle (V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>(d_0 + 1)</tex>-регулярный граф условий <tex>G'=\langle (V',E'),\Sigma,\mathcal{C}'\rangle</tex> такой, что <tex>|V'|</tex>=2|E|</tex> и <tex>c \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>. Для некоторых заданных констант <tex>d_0,c>0</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

Эта лемма известна как экспандер-замена(expander-replacement transformation).

{{Лемма
|about=О расширении
|statement=
Пусть <tex>d_0, h_0 >0</tex> некоторые константы. Любой <tex>d</tex>-регулярный граф условий <tex>G</tex> может быть преобразован в <tex>G'</tex> такой, что:
* <tex>G'</tex> <tex>(d + d_0 + 1)</tex>-регулярный, имеет собственные циклы и <tex>\lambda(G') \le d + d_0 + 1 - \frac {h_0^2} {d + d_0 + 1} < deg(G')</tex>
* <tex>size(G')=O(size(G))</tex>
* <tex> \frac d {d + d_0 + 1} \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

===Усиление===
Это новая операция на системах условий, которая увеличивает число неудовлетворенности.
Пусть <tex>G=\langle (V,E),\Sigma,\mathcal{C}\rangle<tex> граф условий, <tex>t \in \mathbb{N}</tex>. Определим <tex>G^t=\langle (V,\mathbf{E}),\Sigma^{d^{\lceil t/2\rceil}}, \mathcal{C}^t \rangle</tex> как следующий граф условий:
* Веришины <tex>G^t</tex> совпадают с вершинами <tex>G</tex>
* Ребра: <tex>u</tex> и <tex>v</tex> соединены <tex>k</tex> ребрами в <tex>\mathbf{E}</tex>, если количество путей длины <tex>t</tex> из <tex>u</tex> в <tex>v</tex> в графе <tex>G</tex> равно <tex>k</tex>
* Алфавит: алфавит графа <tex>G^t</tex> <tex>\Sigma^{d^{\lceil t/2\rceil}}</tex>, где каждой вершине сопоставлены значения ее соседей, достижимых за <tex>\frac t 2</tex> шагов.
* Условия: Условия сопоставленные ребру <tex>e=(u,v) \in \mathbf{E}</tex> удовлетворены, если назначения для <tex>u</tex> и <tex>v</tex> согласованы с назначениями, удовлетворяющими условия, порожденные <tex>\frac t 2</tex> соседями <tex>u</tex> и <tex>v</tex>.

Если <tex>UNSAT(G)=0</tex> тогда очевидно <tex>UNSAT(G^t)=0</tex>. Интереснее доказательство того, что <tex>UNSAT(G^t) \ge O(\sqrt{t} \cdot UNSAT(G)</tex>.

{{Лемма
|about=Усиление
|statement= Пусть <tex>\lambda < d</tex> и <tex>|\Sigma|</tex> произвольные константы. Тогда существует константа <tex>\beta_2=\beta_2(\lambda,d,|\Sigma|)>0</rex> такая, что для любого <tex>t \in \mathbb N</tex> и для любого <tex>d</tex>-регулярного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> с собственными циклами и <tex>\lambda(G)\le \lambda</tex>, <tex>UNSAT(G^t) \ge \beta_2 \sqrt{t} \cdot min \left({UNSAT(G), \frac 1 t}\right)</tex>.
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

Поскольку <tex>UNSAT(G) \le \frac 1 t</tex>, из жтой леммы следует что <tex>UNSAT(G^t) \ge O(\sqrt{t}) \cdot UNSAT(G)</tex>. Это основная техническая лемма.

===Композиция===
{{Определение
|about=Тестер присвоений
|definition=Тестер присвоений с алфавитом <tex>\Sigma_0</tex> и вероятностью отклонения <tex>\epsilon > 0</tex> это полиномиальное преобразование <tex>\mathcal{P}</tex>, принимающее на вход схему <tex>\Phi</tex> над будевыми переменными <tex>X</tex> и дающую на выходе граф условий <tex>G=\langle(V,E),\Sigma_0,\mathcal{C}\rangle</tex> такой, что <tex>V \subset X</tex>(в условном графе <tex>V</tex> играет одновременно две роли: переменных и вершин. <tex>Y \subset X</tex> подразумевает, что некоторые вершины из <tex>V</tex> определены с помощью переменных <tex>X</tex>). Пусть <tex>V'=V \setminus X</tex> и <tex>a : X \rightarrow \lbrace 0,1 \rbrace</tex> — присваивание.
* (Полнота) Если <tex>a \in SAT(\Phi)</tex> то существует <tex>b : V' \rightarrow \Sigma_0</tex> такое, что <tex>UNSAT_{a\cup{b}}(G)=0</tex>
* (Обоснованность) Если <tex>a \notin SAT(\Phi)</tex> то для всех <tex>b : V' \rightarrow \Sigma_0</tex>, <tex>UNSAT_{a\cup{b}}(G) \ge \epsilon \cdot dist(a, SAT(\Phi))</tex>.
}}

Следует заметить, что не накладывается никаких ограничений ни на время работы <tex>\mathcal{P}</tex> ни на <tex>size(G)</tex>. Мы игнорируем размер схемы <Tex>\Phi</tex>, которая может быть экспоненциальна относительно <tex>|X|</tex>.

{{Лемма
|about=Композиция
|statement=Пусть существует тестер присвоений <tex>\mathcal{P}</tex> с константной вероятностью отклонения <tex>\epsilon > 0</tex> и алфавитом <tex>\Sigma_0</tex>, <tex>|\Sigma_0|=O(1)</tex>. Тогда существует <tex>\beta_3 > 0</tex>, зависящая только от <tex>\mathcal{P}</tex>, такая что любой граф условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex>, обозначаемый <tex>G \circ \mathcal{C}</tex>, такой что <tex>size(G')=M(|\Sigma|) \cdot size(G)</tex> и <tex>\beta_3 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

==Основная теорема==
Основываясь на операциях с графами условий мы можем доказать основную теорему.
{{Теорема
|about=Основная теорема
|statement=Для любого <tex>\Sigma</tex>, <tex>|\Sigma|=O(1)</tex> существуют константы <tex>C > 0</tex> и <tex>0 < \alpha < 1</tex> такие, что для данного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> за полиномиальное время можно построить граф условий <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex> такой, что:
* <tex>size(G') \le C \cdot size(G)</tex> и <tex>|\Sigma_0| = O(1)</tex>
* (Полнота) Если <tex>UNSAT(G)=0</tex>, то <tex>UNSAT(G')=0</tex>
* (Обоснованность) <tex>UNSAT(G') \ge min(2 \cdot UNSAT(G), \alpha)</tex>
|proof=
Построим <tex>G'</tex> по <tex>G</tex> следующим образом: <tex>G'=(prep(G))^t \circ \mathcal{P}</tex>.
# (Препроцессинг) Пусть <tex>H_1=prep(G)</tex>. Существуют некоторые глобальные константы <tex>\lambda < d </tex> и <tex>\beta_1 >0</tex> такие, что <tex>H_1</tex> <tex>d</tex>-регулярный, имеет тот же алфавит, что и <tex>G</tex>, <tex>\lambda(H_1) \le \lambda < d</tex> и <tex>\beta_1 \cdot UNSAT*G( \le UNSAT(H_1) \le UNSAT(G)</tex>.
# (Усиление) Пусть <tex>H_2=(H_1)^t</tex> для достаточно большой константы <tex> t > 1</tex>, которую определим ниже. Существует некоторая константа <tex>\beta_2=\beta(\lambda, d, |\Sigma|) > 0</tex>, для которой <tex>UNSAT(H_2) \ge \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex>. Однако, алфавит вырос до <tex>\Sigma^{d^{\lceil t / 2 \rceil}}</tex>.
# (Композиция) Пусть <tex>G'=H_2 \circ \mathcal{P}</tex>. Это уменьшит алфавит до <tex>\Sigma_0</tex>, при <tex>\beta_3 \cdot UNSAT(H_2) \le UNSAT(G') \le UNSAT(H_2)</tex> для некоторой <tex>\beta_3 > 0 </tex>.

Проверим выполнение условий теоремы. Размер <tex>G'</tex> линеен относительно размера<tex>G</tex>, поскольку на каждом шагу увеличивался линейно. Полнота явно поддерживается на каждом шаге. Теперь выберем <tex>t=\left\lceil\left({\frac 2 {\beta_1\beta_2\beta_3}}\right)^2\right\rceil</tex>. Пусть <tex>\alpha=\frac {\beta_3\beta_2} {sqrt{t}}</tex>.
Таким образом,

<tex>UNSAT(G') \ge \beta_3 \cdot UNSAT(H_2)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(\beta_1 UNSAT(G_, \frac 1 t) </tex> <tex>\ge min(2 \cdot UNSAT(G), \alpha)</tex>
}}
===Доказательство PCP теоремы===
{{Лемма
|statement=Следствием из основной теоремы является <tex>\mathrm{NP}</tex>-трудность <tex>GAP-3SAT_s</tex>.
|proof=Сведем удовлетворимость графа условий к нашей задаче. Пусть <tex>G</tex> задача удовлетворимости некоторого графа с <tex>|\Sigma|=3</tex>. Идей состоит в повторении применения основной теоремы до тех пор, пока число неудовлетворенности не станет постоянным.

Пусть <tex>G_0 = G</tex> и <tex>G_i(i \ge 1)</tex> — результат применения основной теоремы к <tex>G_{i-1}</tex>. Тогда для <tex>i \ge 1</tex> <tex>G</tex> — граф условий с алфавитом <tex>\Sigma_0</tex>. Пусть <tex>E_0</tex> — множество ребер <tex>G_0<tex> и <tex>k=\log|E_0|=O(\log n)</tex>.

Полнота показывается тривиально: если <tex>UNSAT(G_0)=0</tex>, то для всех <tex>i</tex> <tex>UNSAT(G_i)=0</tex>. Для обоснованности рассмотрим <tex>UNSAT(G_0) > 0</tex>. Если для некоторого <tex>i*<k</tex>, <tex>UNSAT(G_{i*}) \ge \frac \alpha 2</tex>, то из основной теоремы следует, что для всех <tex>i>i*</tex> <tex>UNSAT(G_i)\ge \alpha</tex>. На остальные <tex>i</tex> это распространяется по индукции <tex>UNSAT(G_i) \ge min(2^i UNSAT(G_0), \alpha)</tex>.

Если <tex>UNSAT(G_0)>0</tex>, то <tex>UNSAT(G_0)\ge \frac 1 {|E_0|}</tex>. Конечно, <tex>2^k UNSAT(G_0) > \alpha</tex>. Таким образом <tex>UNSAT(G_k) \ge \alpha</tex>.

Такми образом <tex>\rho -GAP2CSP</tex> <tex>\mathrm{NP}</tex>-трудная. Достичь обоснованности <tex>\frac 1 2</tex> можно последовательным повторением <tex>u=\frac 1 {\log(\frac 1 {1 - \alpha})} </tex> раз. Тоесть создать новые условия, представляющие собой <tex>AND</tex> всех возможных <tex>u</tex>-наборов прежних условий. Конечно, при этом количество запросов на условие увеличится до <tex>2u</tex>.

}}

==Дополнительные материалы==
* [http://www.math.ias.edu/boaz/ExpanderCourse/|N. Linial and A. Wigderson. Expander graphs and their applications. Lecture notes of a course, 2003].
* Michael Sipser and Daniel A. Spielman. Expander codes. IEEE Trans. Inform. Theory, 42(6, part 1):1710–1722, 1996. Codes and complexity.
* C. Papadimitriou and M. Yannakakis. Optimization, approximation and complexity classes. Journal of Computer and System Sciences, 3:425–440, 1991.
* Irit Dinur and Omer Reingold. Assignment testers: Towards combinatorial proofs of the PCP theorem. In Proceedings of the 45th Symposium on Foundations of Computer Science (FOCS), 2004.
==Источники==
* [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005].
* [http://www.cs.utah.edu/~alfeld/LecturePDFs/pcp.pdf The PCP Theorem, Notes by Scott Alfeld, 2008].

PCP-теорема

2013-03-18T11:01:55Z

194.85.161.34: /* Препроцессинг */

{{Теорема
|id=pcp_th
|about=<tex>\mathrm{PCP}</tex> теорема
|statement=<tex>\mathrm{PCP}[\log n, O(1)] = \mathrm{NP}</tex>
}}

Классическое доказательство [[Класс PCP|<tex>\mathrm{PCP}</tex>]] теоремы громоздкое и довольно сложное для восприятия,
рассмотрим вариант докаательства, предложенный Динуром. Оно основано на том, что <tex>\mathrm{PCP}</tex>-теорема [[Эквивалентность_PCP-теоремы_и_теоремы_о_трудности_аппроксимации | эквивалентна <tex>\mathrm{NP}</tex>-трудности задачи <tex>\rho-GAPqCSP</tex>]].

==Определения и леммы, используемые в доказательстве==
{{Определение
|definition= <tex>\mathcal{C}=\lbrace c_1,..., c_n\rbrace</tex> назовем множеством условий над
множеством переменных <tex>V</tex>.
}}
{{Определение
|definition=Число неудовлетворенности <tex>UNSAT(\mathcal{C})</tex> — минимальное подмножество неудовлетворенных условий для любых возможных назначений <tex>V</tex>. <tex>\mathcal{C}</tex> удовлетворимо тогда и только тогда, когда <tex>UNSAT(\mathcal{C})=0</tex>. Если же <tex>\mathcal{C}</tex> неудовлетворимо, тогда <tex>UNSAT(\mathcal{C}) \ge \frac 1 n</tex>.
}}

===Графы условий===
Нам понадобятся графы ограничений для двух переменных, которые определяются следующим образом:
{{Определение
|definition=
<tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex> называется графом условий, если:
* <tex>(V,E)</tex> — неориентированный граф, называемый графом, леащим в основе <tex>G</tex>.
* Множество <tex>V</tex> также представляется в виде множества переменных принимающих значениями из алфавита <tex>\Sigma</tex>
* Каждое ребро <tex>e \in E</tex> содержит условие <tex>c(e) \subseteq \Sigma^2</tex> и <tex>\mathcal{C}=\lbrace c(e)\rbrace_{e \in E}</tex>. Условие <tex>c(e)</tex> называется удовлетворенным парой <tex>(a, b)</tex>, если <tex>(a, b) \in c(e)</tex>
}}

Присваивание это отображение <tex>\sigma:V \rightarrow \Sigma</tex>, которое назначает каждой вершине из <tex>V</tex>
значение из <tex>\Sigma</tex>. Для любого присвоения <tex>\sigma</tex> определим <tex>UNSAT_\sigma(G) = \operatorname*{Pr}\limits_{(u,v)\in E} [(\sigma(u),\sigma(v)) \notin c(e)]</tex> и <tex>UNSAT(G) = \operatorname*{min}\limits_\sigma UNSAT_\sigma(G)</tex>.

Назовем <tex>UNSAT(G)</tex> числом неудовлетворенности графа <tex>G</tex>. Размером графа будем считать размер его описания <tex>size(G)=O(|V|+|E| \cdot |\Sigma|^2)</tex>

{{Лемма
|statement=Для заданного графа условий <tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex>, где <tex>|\Sigma|=3</tex> проверка утверждения <tex>UNSAT(G)=0</tex> — <tex>\mathrm{NP}</tex>-трудная задача.
|proof=
Сведем <tex>3Color</tex> к нашей задаче. Дан граф <tex>G</tex>, алфавит <tex>\Sigma=\lbrace 1,2,3 \rbrace</tex> для трех цветов. Оснастим ребра условиями неравенства. Очевидно, что <tex>G \in 3Color</tex> тогда и только тогда, когда <tex>UNSAT(G)=0<tex> (Иногда удобно использовать одно и то же обозначение <tex>G</tex> для графа условий и графа, лежащего в его основе).
}}

===Экспандер графы===
Экспандер графы играют важную роль во многих теоретических результатах.

{{Определение
|definition= <tex>G=(V,E)</tex> <tex>d</tex>-регулярный граф. Положим <tex>E(S,\overline{S})=|(S \times \overline{S}) \cap E|</tex> равным количеству ребер их подмножества <tex>S\in V</tex> в его дополнение. Определим реберное расширение как
<tex>h(G)=\operatorname*{min}\limits_{S:|S|<\frac {|V|} 2} \frac {E(S, \overline S)} {|S|}</tex>
}}

{{Лемма
|about=О экспандерах
|statement=Существует <tex>d_0 \in \mathbb{N}</tex> и <tex>h_0 >0</tex> такие, что есть построимое за полиномиальное время семейство <tex>\lbrace X_n\rbrace_{n \in \mathbb{N}}</tex> <tex>d_0</tex>-регулярных графов <tex>X_n</tex> с <tex>n</tex> вершинами таких, что <tex>h(X_n) \ge h_0</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

{{Лемма
|statement= Пусть <tex>G</tex> <tex>d</tex>-регулярный граф, а <tex>h(G)</tex> его реберное расширение. Тогда <tex>\lambda(G) \le d - \frac {h(G)^2} d</tex>
}}

{{Определение
|definition=Собственным числом графа <tex>\lambda</tex> называют собственное число его матрицы смежности.
}}

{{Лемма
|statement=Пусть <tex>G</tex> <tex>d</tex>-регулярный граф со вторым по величине собственным числом <tex>\lambda</tex>. Пусть <tex>F \subseteq E</tex> множество ребер. Вероятность <tex>p</tex> того, что случайный путь, начинающийся со случайного ребра из <tex>F</tex> на <tex>i+1</tex> шаге попадет <tex>F</tex> ограничена <tex>\frac {|F|} {|E|} + \left({\frac {|\lambda|} d}\right)^i</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

==Операции на графах условий==
Для доказательства <tex>\mathrm{PCP}</tex> теоремы потребуются три операции над графами уловий:
* Препроцессинг. Простая операция, сохраняющая чило неудовлетворенности(примерно) и размер алфавита, но делающая граф лучше.
* Усиление. Эта операция увеоичивает чило неудовлетворенности за счет увеличения размера алфавита.
* Композицияю Эта операция уменьшает размер алфавита, сохраняя число неудовлетворенности(приблизительно).

===Препроцессинг===
Под хорошим графом будем понимать регулярный, фиксированной степени экспандер граф.
{{Лемма
|about=Препроцессинг
|statement= существуют константы <tex>0 < \lambda < d</tex> и <tex>\beta_1 >0</tex> такие, что любой граф условий <tex>G</tex> может быть преобразован в граф условий <tex>G'=prep(G)</tex> такой, что:
* <tex>G'</tex> <tex>d</tex>-регулярный
* <tex>G'</tex> имеет тот же алфавит, что и <tex>G</tex> и <tex>size(G') = O(size(G))</tex>.
* <tex>\beta_1 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
}}

Заметим, что третий пункт теммы гарантирует поддержание полноты, т.е. если <tex>UNSAT(G)=0</tex>, то и <tex>UNSAT(G')=0</tex>. Доказательство этой леммы состоит из двух следующих лемм (<tex>\beta_1=c \cdot \frac d {d + d_0 + 1}</tex>).

{{Лемма
|about=Константная степень
|statement=Любой граф условий <tex>G = \langle (V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>(d_0 + 1)</tex>-регулярный граф условий <tex>G'=\langle (V',E'),\Sigma,\mathcal{C}'\rangle</tex> такой, что <tex>|V'|</tex>=2|E|</tex> и <tex>c \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>. Для некоторых заданных констант <tex>d_0,c>0</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

Эта лемма известна как экспандер-замена(expander-replacement transformation).

{{Лемма
|about=О расширении
|statement=
Пусть <tex>d_0, h_0 >0</tex> некоторые константы. Любой <tex>d</tex>-регулярный граф условий <tex>G</tex> может быть преобразован в <tex>G'</tex> такой, что:
* <tex>G'</tex> <tex>(d + d_0 + 1)</tex>-регулярный, имеет собственные циклы и <tex>\lambda(G') \le d + d_0 + 1 - \frac {h_0^2} {d + d_0 + 1} < deg(G')</tex>
* <tex>size(G')=O(size(G))</tex>
* <tex> \frac d {d + d_0 + 1} \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

===Усиление===
Это новая операция на системах условий, которая увеличивает число неудовлетворенности.
Пусть <tex>G=\langle (V,E),\Sigma,\mathcal{C}\rangle<tex> граф условий, <tex>t \in \mathbb{N}</tex>. Определим <tex>G^t=\langle (V,\mathbf{E}),\Sigma^{d^{\lceil t/2\rceil}}, \mathcal{C}^t \rangle</tex> как следующий граф условий:
* Веришины <tex>G^t</tex> совпадают с вершинами <tex>G</tex>
* Ребра: <tex>u</tex> и <tex>v</tex> соединены <tex>k</tex> ребрами в <tex>\mathbf{E}</tex>, если количество путей длины <tex>t</tex> из <tex>u</tex> в <tex>v</tex> в графе <tex>G</tex> равно <tex>k</tex>
* Алфавит: алфавит графа <tex>G^t</tex> <tex>\Sigma^{d^{\lceil t/2\rceil}}</tex>, где каждой вершине сопоставлены значения ее соседей, достижимых за <tex>\frac t 2</tex> шагов.
* Условия: Условия сопоставленные ребру <tex>e=(u,v) \in \mathbf{E}</tex> удовлетворены, если назначения для <tex>u</tex> и <tex>v</tex> согласованы с назначениями, удовлетворяющими условия, порожденные <tex>\frac t 2</tex> соседями <tex>u</tex> и <tex>v</tex>.

Если <tex>UNSAT(G)=0</tex> тогда очевидно <tex>UNSAT(G^t)=0</tex>. Интереснее доказательство того, что <tex>UNSAT(G^t) \ge O(\sqrt{t} \cdot UNSAT(G)</tex>.

{{Лемма
|about=Усиление
|statement= Пусть <tex>\lambda < d</tex> и <tex>|\Sigma|</tex> произвольные константы. Тогда существует константа <tex>\beta_2=\beta_2(\lambda,d,|\Sigma|)>0</rex> такая, что для любого <tex>t \in \mathbb N</tex> и для любого <tex>d</tex>-регулярного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> с собственными циклами и <tex>\lambda(G)\le \lambda</tex>, <tex>UNSAT(G^t) \ge \beta_2 \sqrt{t} \cdot min \left({UNSAT(G), \frac 1 t}\right)</tex>.
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

Поскольку <tex>UNSAT(G) \le \frac 1 t</tex>, из жтой леммы следует что <tex>UNSAT(G^t) \ge O(\sqrt{t}) \cdot UNSAT(G)</tex>. Это основная техническая лемма.

===Композиция===
{{Определение
|about=Тестер присвоений
|definition=Тестер присвоений с алфавитом <tex>\Sigma_0</tex> и вероятностью отклонения <tex>\epsilon > 0</tex> это полиномиальное преобразование <tex>\mathcal{P}</tex>, принимающее на вход схему <tex>\Phi</tex> над будевыми переменными <tex>X</tex> и дающую на выходе граф условий <tex>G=\langle(V,E),\Sigma_0,\mathcal{C}\rangle</tex> такой, что <tex>V \subset X</tex>(в условном графе <tex>V</tex> играет одновременно две роли: переменных и вершин. <tex>Y \subset X</tex> подразумевает, что некоторые вершины из <tex>V</tex> определены с помощью переменных <tex>X</tex>). Пусть <tex>V'=V \setminus X</tex> и <tex>a : X \rightarrow \lbrace 0,1 \rbrace</tex> — присваивание.
* (Полнота) Если <tex>a \in SAT(\Phi)</tex> то существует <tex>b : V' \rightarrow \Sigma_0</tex> такое, что <tex>UNSAT_{a\cup{b}}(G)=0</tex>
* (Обоснованность) Если <tex>a \notin SAT(\Phi)</tex> то для всех <tex>b : V' \rightarrow \Sigma_0</tex>, <tex>UNSAT_{a\cup{b}}(G) \ge \epsilon \cdot dist(a, SAT(\Phi))</tex>.
}}

Следует заметить, что не накладывается никаких ограничений ни на время работы <tex>\mathcal{P}</tex> ни на <tex>size(G)</tex>. Мы игнорируем размер схемы <Tex>\Phi</tex>, которая может быть экспоненциальна относительно <tex>|X|</tex>.

{{Лемма
|about=Композиция
|statement=Пусть существует тестер присвоений <tex>\mathcal{P}</tex> с константной вероятностью отклонения <tex>\epsilon > 0</tex> и алфавитом <tex>\Sigma_0</tex>, <tex>|\Sigma_0|=O(1)</tex>. Тогда существует <tex>\beta_3 > 0</tex>, зависящая только от <tex>\mathcal{P}</tex>, такая что любой граф условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex>, обозначаемый <tex>G \circ \mathcal{C}</tex>, такой что <tex>size(G')=M(|\Sigma|) \cdot size(G)</tex> и <tex>\beta_3 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

==Основная теорема==
Основываясь на операциях с графами условий мы можем доказать основную теорему.
{{Теорема
|about=Основная теорема
|statement=Для любого <tex>\Sigma</tex>, <tex>|\Sigma|=O(1)</tex> существуют константы <tex>C > 0</tex> и <tex>0 < \alpha < 1</tex> такие, что для данного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> за полиномиальное время можно построить граф условий <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex> такой, что:
* <tex>size(G') \le C \cdot size(G)</tex> и <tex>|\Sigma_0| = O(1)</tex>
* (Полнота) Если <tex>UNSAT(G)=0</tex>, то <tex>UNSAT(G')=0</tex>
* (Обоснованность) <tex>UNSAT(G') \ge min(2 \cdot UNSAT(G), \alpha)</tex>
|proof=
Построим <tex>G'</tex> по <tex>G</tex> следующим образом: <tex>G'=(prep(G))^t \circ \mathcal{P}</tex>.
# (Препроцессинг) Пусть <tex>H_1=prep(G)</tex>. Существуют некоторые глобальные константы <tex>\lambda < d </tex> и <tex>\beta_1 >0</tex> такие, что <tex>H_1</tex> <tex>d</tex>-регулярный, имеет тот же алфавит, что и <tex>G</tex>, <tex>\lambda(H_1) \le \lambda < d</tex> и <tex>\beta_1 \cdot UNSAT*G( \le UNSAT(H_1) \le UNSAT(G)</tex>.
# (Усиление) Пусть <tex>H_2=(H_1)^t</tex> для достаточно большой константы <tex> t > 1</tex>, которую определим ниже. Существует некоторая константа <tex>\beta_2=\beta(\lambda, d, |\Sigma|) > 0</tex>, для которой <tex>UNSAT(H_2) \ge \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex>. Однако, алфавит вырос до <tex>\Sigma^{d^{\lceil t / 2 \rceil}}</tex>.
# (Композиция) Пусть <tex>G'=H_2 \circ \mathcal{P}</tex>. Это уменьшит алфавит до <tex>\Sigma_0</tex>, при <tex>\beta_3 \cdot UNSAT(H_2) \le UNSAT(G') \le UNSAT(H_2)</tex> для некоторой <tex>\beta_3 > 0 </tex>.

Проверим выполнение условий теоремы. Размер <tex>G'</tex> линеен относительно размера<tex>G</tex>, поскольку на каждом шагу увеличивался линейно. Полнота явно поддерживается на каждом шаге. Теперь выберем <tex>t=\left\lceil\left({\frac 2 {\beta_1\beta_2\beta_3}}\right)^2\right\rceil</tex>. Пусть <tex>\alpha=\frac {\beta_3\beta_2} {sqrt{t}}</tex>.
Таким образом,

<tex>UNSAT(G') \ge \beta_3 \cdot UNSAT(H_2)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(\beta_1 UNSAT(G_, \frac 1 t) </tex> <tex>\ge min(2 \cdot UNSAT(G), \alpha)</tex>
}}
===Доказательство PCP теоремы===
{{Лемма
|statement=Следствием из основной теоремы является <tex>\mathrm{NP}</tex>-трудность <tex>GAP-3SAT_s</tex>.
|proof=Сведем удовлетворимость графа условий к нашей задаче. Пусть <tex>G</tex> задача удовлетворимости некоторого графа с <tex>|\Sigma|=3</tex>. Идей состоит в повторении применения основной теоремы до тех пор, пока число неудовлетворенности не станет постоянным.

Пусть <tex>G_0 = G</tex> и <tex>G_i(i \ge 1)</tex> — результат применения основной теоремы к <tex>G_{i-1}</tex>. Тогда для <tex>i \ge 1</tex> <tex>G</tex> — граф условий с алфавитом <tex>\Sigma_0</tex>. Пусть <tex>E_0</tex> — множество ребер <tex>G_0<tex> и <tex>k=\log|E_0|=O(\log n)</tex>.

Полнота показывается тривиально: если <tex>UNSAT(G_0)=0</tex>, то для всех <tex>i</tex> <tex>UNSAT(G_i)=0</tex>. Для обоснованности рассмотрим <tex>UNSAT(G_0) > 0</tex>. Если для некоторого <tex>i*<k</tex>, <tex>UNSAT(G_{i*}) \ge \frac \alpha 2</tex>, то из основной теоремы следует, что для всех <tex>i>i*</tex> <tex>UNSAT(G_i)\ge \alpha</tex>. На остальные <tex>i</tex> это распространяется по индукции <tex>UNSAT(G_i) \ge min(2^i UNSAT(G_0), \alpha)</tex>.

Если <tex>UNSAT(G_0)>0</tex>, то <tex>UNSAT(G_0)\ge \frac 1 {|E_0|}</tex>. Конечно, <tex>2^k UNSAT(G_0) > \alpha</tex>. Таким образом <tex>UNSAT(G_k) \ge \alpha</tex>.

Такми образом <tex>\rho -GAP2CSP</tex> <tex>\mathrm{NP}</tex>-трудная. Достичь обоснованности <tex>\frac 1 2</tex> можно последовательным повторением <tex>u=\frac 1 {\log(\frac 1 {1 - \alpha})} </tex> раз. Тоесть создать новые условия, представляющие собой <tex>AND</tex> всех возможных <tex>u</tex>-наборов прежних условий. Конечно, при этом количество запросов на условие увеличится до <tex>2u</tex>.

}}

==Дополнительные материалы==
* [http://www.math.ias.edu/boaz/ExpanderCourse/|N. Linial and A. Wigderson. Expander graphs and their applications. Lecture notes of a course, 2003].
* Michael Sipser and Daniel A. Spielman. Expander codes. IEEE Trans. Inform. Theory, 42(6, part 1):1710–1722, 1996. Codes and complexity.
* C. Papadimitriou and M. Yannakakis. Optimization, approximation and complexity classes. Journal of Computer and System Sciences, 3:425–440, 1991.
* Irit Dinur and Omer Reingold. Assignment testers: Towards combinatorial proofs of the PCP theorem. In Proceedings of the 45th Symposium on Foundations of Computer Science (FOCS), 2004.
==Источники==
* [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005].
* [http://www.cs.utah.edu/~alfeld/LecturePDFs/pcp.pdf The PCP Theorem, Notes by Scott Alfeld, 2008].

PCP-теорема

2013-03-18T11:01:06Z

194.85.161.34: /* Усиление */

{{Теорема
|id=pcp_th
|about=<tex>\mathrm{PCP}</tex> теорема
|statement=<tex>\mathrm{PCP}[\log n, O(1)] = \mathrm{NP}</tex>
}}

Классическое доказательство [[Класс PCP|<tex>\mathrm{PCP}</tex>]] теоремы громоздкое и довольно сложное для восприятия,
рассмотрим вариант докаательства, предложенный Динуром. Оно основано на том, что <tex>\mathrm{PCP}</tex>-теорема [[Эквивалентность_PCP-теоремы_и_теоремы_о_трудности_аппроксимации | эквивалентна <tex>\mathrm{NP}</tex>-трудности задачи <tex>\rho-GAPqCSP</tex>]].

==Определения и леммы, используемые в доказательстве==
{{Определение
|definition= <tex>\mathcal{C}=\lbrace c_1,..., c_n\rbrace</tex> назовем множеством условий над
множеством переменных <tex>V</tex>.
}}
{{Определение
|definition=Число неудовлетворенности <tex>UNSAT(\mathcal{C})</tex> — минимальное подмножество неудовлетворенных условий для любых возможных назначений <tex>V</tex>. <tex>\mathcal{C}</tex> удовлетворимо тогда и только тогда, когда <tex>UNSAT(\mathcal{C})=0</tex>. Если же <tex>\mathcal{C}</tex> неудовлетворимо, тогда <tex>UNSAT(\mathcal{C}) \ge \frac 1 n</tex>.
}}

===Графы условий===
Нам понадобятся графы ограничений для двух переменных, которые определяются следующим образом:
{{Определение
|definition=
<tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex> называется графом условий, если:
* <tex>(V,E)</tex> — неориентированный граф, называемый графом, леащим в основе <tex>G</tex>.
* Множество <tex>V</tex> также представляется в виде множества переменных принимающих значениями из алфавита <tex>\Sigma</tex>
* Каждое ребро <tex>e \in E</tex> содержит условие <tex>c(e) \subseteq \Sigma^2</tex> и <tex>\mathcal{C}=\lbrace c(e)\rbrace_{e \in E}</tex>. Условие <tex>c(e)</tex> называется удовлетворенным парой <tex>(a, b)</tex>, если <tex>(a, b) \in c(e)</tex>
}}

Присваивание это отображение <tex>\sigma:V \rightarrow \Sigma</tex>, которое назначает каждой вершине из <tex>V</tex>
значение из <tex>\Sigma</tex>. Для любого присвоения <tex>\sigma</tex> определим <tex>UNSAT_\sigma(G) = \operatorname*{Pr}\limits_{(u,v)\in E} [(\sigma(u),\sigma(v)) \notin c(e)]</tex> и <tex>UNSAT(G) = \operatorname*{min}\limits_\sigma UNSAT_\sigma(G)</tex>.

Назовем <tex>UNSAT(G)</tex> числом неудовлетворенности графа <tex>G</tex>. Размером графа будем считать размер его описания <tex>size(G)=O(|V|+|E| \cdot |\Sigma|^2)</tex>

{{Лемма
|statement=Для заданного графа условий <tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex>, где <tex>|\Sigma|=3</tex> проверка утверждения <tex>UNSAT(G)=0</tex> — <tex>\mathrm{NP}</tex>-трудная задача.
|proof=
Сведем <tex>3Color</tex> к нашей задаче. Дан граф <tex>G</tex>, алфавит <tex>\Sigma=\lbrace 1,2,3 \rbrace</tex> для трех цветов. Оснастим ребра условиями неравенства. Очевидно, что <tex>G \in 3Color</tex> тогда и только тогда, когда <tex>UNSAT(G)=0<tex> (Иногда удобно использовать одно и то же обозначение <tex>G</tex> для графа условий и графа, лежащего в его основе).
}}

===Экспандер графы===
Экспандер графы играют важную роль во многих теоретических результатах.

{{Определение
|definition= <tex>G=(V,E)</tex> <tex>d</tex>-регулярный граф. Положим <tex>E(S,\overline{S})=|(S \times \overline{S}) \cap E|</tex> равным количеству ребер их подмножества <tex>S\in V</tex> в его дополнение. Определим реберное расширение как
<tex>h(G)=\operatorname*{min}\limits_{S:|S|<\frac {|V|} 2} \frac {E(S, \overline S)} {|S|}</tex>
}}

{{Лемма
|about=О экспандерах
|statement=Существует <tex>d_0 \in \mathbb{N}</tex> и <tex>h_0 >0</tex> такие, что есть построимое за полиномиальное время семейство <tex>\lbrace X_n\rbrace_{n \in \mathbb{N}}</tex> <tex>d_0</tex>-регулярных графов <tex>X_n</tex> с <tex>n</tex> вершинами таких, что <tex>h(X_n) \ge h_0</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

{{Лемма
|statement= Пусть <tex>G</tex> <tex>d</tex>-регулярный граф, а <tex>h(G)</tex> его реберное расширение. Тогда <tex>\lambda(G) \le d - \frac {h(G)^2} d</tex>
}}

{{Определение
|definition=Собственным числом графа <tex>\lambda</tex> называют собственное число его матрицы смежности.
}}

{{Лемма
|statement=Пусть <tex>G</tex> <tex>d</tex>-регулярный граф со вторым по величине собственным числом <tex>\lambda</tex>. Пусть <tex>F \subseteq E</tex> множество ребер. Вероятность <tex>p</tex> того, что случайный путь, начинающийся со случайного ребра из <tex>F</tex> на <tex>i+1</tex> шаге попадет <tex>F</tex> ограничена <tex>\frac {|F|} {|E|} + \left({\frac {|\lambda|} d}\right)^i</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

==Операции на графах условий==
Для доказательства <tex>\mathrm{PCP}</tex> теоремы потребуются три операции над графами уловий:
* Препроцессинг. Простая операция, сохраняющая чило неудовлетворенности(примерно) и размер алфавита, но делающая граф лучше.
* Усиление. Эта операция увеоичивает чило неудовлетворенности за счет увеличения размера алфавита.
* Композицияю Эта операция уменьшает размер алфавита, сохраняя число неудовлетворенности(приблизительно).

===Препроцессинг===
Под хорошим графом будем понимать регулярный, фиксированной степени экспандер граф.
{{Лемма
|about=Препроцессинг
|statement= существуют константы <tex>0 < \lambda < d</tex> и <tex>\beta_1 >0</tex> такие, что любой граф условий <tex>G</tex> может быть преобразован в граф условий <tex>G'=prep(G)</tex> такой, что:
* <tex>G'</tex> <tex>d</tex>-регулярный
* <tex>G'</tex> имеет тот же алфавит, что и <tex>G</tex> и <tex>size(G') = O(size(G))</tex>.
* <tex>\beta_1 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
}}

Заметим, что третий пункт теммы гарантирует поддержание полноты, т.е. если <tex>UNSAT(G)=0</tex>, то и <tex>UNSAT(G')=0</tex>. Доказательство этой леммы состоит из двух следующих лемм (<tex>\beta_1=c \cdot \frac d {d + d_0 + 1}</tex>).

{{Лемма
|about=Константная степень
|statement=Любой граф условий <tex>G = \langle (V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>(d_0 + 1)</tex>-регулярный граф условий <tex>G'=\langle (V',E'),\Sigma,\mathcal{C}'\rangle</tex> такой, что <tex>|V'|</tex>=2|E|</tex> и <tex>c \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>. Для некоторых заданных констант <tex>d_0,c>0</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

Эта лемма известна как экспандер-замена(expander-replacement transformation).

{{Лемма
|about=О расширении
|statement=
Пусть <tex>d_0, h_0 >0</tex> некоторые константы. Любой <tex>d</tex>-регулярный граф условий <tex>G</tex> может быть преобразован в <tex>G'</tex> такой, что:
* <tex>G'</tex> <tex>(d + d_0 + 1)</tex>-регулярный, имеет собственные циклы и <tex>\lambda(G') \le d + d_0 + 1 - \frac {h_0^2} {d + d_0 + 1} < deg(G')</tex>
* <tex>size(G')=O(size(G))</tex>
* <tex> \frac d {d + d_0 + 1} \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

===Усиление===
Это новая операция на системах условий, которая увеличивает число неудовлетворенности.
Пусть <tex>G=\langle (V,E),\Sigma,\mathcal{C}\rangle<tex> граф условий, <tex>t \in \mathbb{N}</tex>. Определим <tex>G^t=\langle (V,\mathbf{E}),\Sigma^{d^{\lceil t/2\rceil}}, \mathcal{C}^t \rangle</tex> как следующий граф условий:
* Веришины <tex>G^t</tex> совпадают с вершинами <tex>G</tex>
* Ребра: <tex>u</tex> и <tex>v</tex> соединены <tex>k</tex> ребрами в <tex>\mathbf{E}</tex>, если количество путей длины <tex>t</tex> из <tex>u</tex> в <tex>v</tex> в графе <tex>G</tex> равно <tex>k</tex>
* Алфавит: алфавит графа <tex>G^t</tex> <tex>\Sigma^{d^{\lceil t/2\rceil}}</tex>, где каждой вершине сопоставлены значения ее соседей, достижимых за <tex>\frac t 2</tex> шагов.
* Условия: Условия сопоставленные ребру <tex>e=(u,v) \in \mathbf{E}</tex> удовлетворены, если назначения для <tex>u</tex> и <tex>v</tex> согласованы с назначениями, удовлетворяющими условия, порожденные <tex>\frac t 2</tex> соседями <tex>u</tex> и <tex>v</tex>.

Если <tex>UNSAT(G)=0</tex> тогда очевидно <tex>UNSAT(G^t)=0</tex>. Интереснее доказательство того, что <tex>UNSAT(G^t) \ge O(\sqrt{t} \cdot UNSAT(G)</tex>.

{{Лемма
|about=Усиление
|statement= Пусть <tex>\lambda < d</tex> и <tex>|\Sigma|</tex> произвольные константы. Тогда существует константа <tex>\beta_2=\beta_2(\lambda,d,|\Sigma|)>0</rex> такая, что для любого <tex>t \in \mathbb N</tex> и для любого <tex>d</tex>-регулярного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> с собственными циклами и <tex>\lambda(G)\le \lambda</tex>, <tex>UNSAT(G^t) \ge \beta_2 \sqrt{t} \cdot min \left({UNSAT(G), \frac 1 t}\right)</tex>.
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

Поскольку <tex>UNSAT(G) \le \frac 1 t</tex>, из жтой леммы следует что <tex>UNSAT(G^t) \ge O(\sqrt{t}) \cdot UNSAT(G)</tex>. Это основная техническая лемма.

===Композиция===
{{Определение
|about=Тестер присвоений
|definition=Тестер присвоений с алфавитом <tex>\Sigma_0</tex> и вероятностью отклонения <tex>\epsilon > 0</tex> это полиномиальное преобразование <tex>\mathcal{P}</tex>, принимающее на вход схему <tex>\Phi</tex> над будевыми переменными <tex>X</tex> и дающую на выходе граф условий <tex>G=\langle(V,E),\Sigma_0,\mathcal{C}\rangle</tex> такой, что <tex>V \subset X</tex>(в условном графе <tex>V</tex> играет одновременно две роли: переменных и вершин. <tex>Y \subset X</tex> подразумевает, что некоторые вершины из <tex>V</tex> определены с помощью переменных <tex>X</tex>). Пусть <tex>V'=V \setminus X</tex> и <tex>a : X \rightarrow \lbrace 0,1 \rbrace</tex> — присваивание.
* (Полнота) Если <tex>a \in SAT(\Phi)</tex> то существует <tex>b : V' \rightarrow \Sigma_0</tex> такое, что <tex>UNSAT_{a\cup{b}}(G)=0</tex>
* (Обоснованность) Если <tex>a \notin SAT(\Phi)</tex> то для всех <tex>b : V' \rightarrow \Sigma_0</tex>, <tex>UNSAT_{a\cup{b}}(G) \ge \epsilon \cdot dist(a, SAT(\Phi))</tex>.
}}

Следует заметить, что не накладывается никаких ограничений ни на время работы <tex>\mathcal{P}</tex> ни на <tex>size(G)</tex>. Мы игнорируем размер схемы <Tex>\Phi</tex>, которая может быть экспоненциальна относительно <tex>|X|</tex>.

{{Лемма
|about=Композиция
|statement=Пусть существует тестер присвоений <tex>\mathcal{P}</tex> с константной вероятностью отклонения <tex>\epsilon > 0</tex> и алфавитом <tex>\Sigma_0</tex>, <tex>|\Sigma_0|=O(1)</tex>. Тогда существует <tex>\beta_3 > 0</tex>, зависящая только от <tex>\mathcal{P}</tex>, такая что любой граф условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex>, обозначаемый <tex>G \circ \mathcal{C}</tex>, такой что <tex>size(G')=M(|\Sigma|) \cdot size(G)</tex> и <tex>\beta_3 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

==Основная теорема==
Основываясь на операциях с графами условий мы можем доказать основную теорему.
{{Теорема
|about=Основная теорема
|statement=Для любого <tex>\Sigma</tex>, <tex>|\Sigma|=O(1)</tex> существуют константы <tex>C > 0</tex> и <tex>0 < \alpha < 1</tex> такие, что для данного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> за полиномиальное время можно построить граф условий <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex> такой, что:
* <tex>size(G') \le C \cdot size(G)</tex> и <tex>|\Sigma_0| = O(1)</tex>
* (Полнота) Если <tex>UNSAT(G)=0</tex>, то <tex>UNSAT(G')=0</tex>
* (Обоснованность) <tex>UNSAT(G') \ge min(2 \cdot UNSAT(G), \alpha)</tex>
|proof=
Построим <tex>G'</tex> по <tex>G</tex> следующим образом: <tex>G'=(prep(G))^t \circ \mathcal{P}</tex>.
# (Препроцессинг) Пусть <tex>H_1=prep(G)</tex>. Существуют некоторые глобальные константы <tex>\lambda < d </tex> и <tex>\beta_1 >0</tex> такие, что <tex>H_1</tex> <tex>d</tex>-регулярный, имеет тот же алфавит, что и <tex>G</tex>, <tex>\lambda(H_1) \le \lambda < d</tex> и <tex>\beta_1 \cdot UNSAT*G( \le UNSAT(H_1) \le UNSAT(G)</tex>.
# (Усиление) Пусть <tex>H_2=(H_1)^t</tex> для достаточно большой константы <tex> t > 1</tex>, которую определим ниже. Существует некоторая константа <tex>\beta_2=\beta(\lambda, d, |\Sigma|) > 0</tex>, для которой <tex>UNSAT(H_2) \ge \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex>. Однако, алфавит вырос до <tex>\Sigma^{d^{\lceil t / 2 \rceil}}</tex>.
# (Композиция) Пусть <tex>G'=H_2 \circ \mathcal{P}</tex>. Это уменьшит алфавит до <tex>\Sigma_0</tex>, при <tex>\beta_3 \cdot UNSAT(H_2) \le UNSAT(G') \le UNSAT(H_2)</tex> для некоторой <tex>\beta_3 > 0 </tex>.

Проверим выполнение условий теоремы. Размер <tex>G'</tex> линеен относительно размера<tex>G</tex>, поскольку на каждом шагу увеличивался линейно. Полнота явно поддерживается на каждом шаге. Теперь выберем <tex>t=\left\lceil\left({\frac 2 {\beta_1\beta_2\beta_3}}\right)^2\right\rceil</tex>. Пусть <tex>\alpha=\frac {\beta_3\beta_2} {sqrt{t}}</tex>.
Таким образом,

<tex>UNSAT(G') \ge \beta_3 \cdot UNSAT(H_2)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(\beta_1 UNSAT(G_, \frac 1 t) </tex> <tex>\ge min(2 \cdot UNSAT(G), \alpha)</tex>
}}
===Доказательство PCP теоремы===
{{Лемма
|statement=Следствием из основной теоремы является <tex>\mathrm{NP}</tex>-трудность <tex>GAP-3SAT_s</tex>.
|proof=Сведем удовлетворимость графа условий к нашей задаче. Пусть <tex>G</tex> задача удовлетворимости некоторого графа с <tex>|\Sigma|=3</tex>. Идей состоит в повторении применения основной теоремы до тех пор, пока число неудовлетворенности не станет постоянным.

Пусть <tex>G_0 = G</tex> и <tex>G_i(i \ge 1)</tex> — результат применения основной теоремы к <tex>G_{i-1}</tex>. Тогда для <tex>i \ge 1</tex> <tex>G</tex> — граф условий с алфавитом <tex>\Sigma_0</tex>. Пусть <tex>E_0</tex> — множество ребер <tex>G_0<tex> и <tex>k=\log|E_0|=O(\log n)</tex>.

Полнота показывается тривиально: если <tex>UNSAT(G_0)=0</tex>, то для всех <tex>i</tex> <tex>UNSAT(G_i)=0</tex>. Для обоснованности рассмотрим <tex>UNSAT(G_0) > 0</tex>. Если для некоторого <tex>i*<k</tex>, <tex>UNSAT(G_{i*}) \ge \frac \alpha 2</tex>, то из основной теоремы следует, что для всех <tex>i>i*</tex> <tex>UNSAT(G_i)\ge \alpha</tex>. На остальные <tex>i</tex> это распространяется по индукции <tex>UNSAT(G_i) \ge min(2^i UNSAT(G_0), \alpha)</tex>.

Если <tex>UNSAT(G_0)>0</tex>, то <tex>UNSAT(G_0)\ge \frac 1 {|E_0|}</tex>. Конечно, <tex>2^k UNSAT(G_0) > \alpha</tex>. Таким образом <tex>UNSAT(G_k) \ge \alpha</tex>.

Такми образом <tex>\rho -GAP2CSP</tex> <tex>\mathrm{NP}</tex>-трудная. Достичь обоснованности <tex>\frac 1 2</tex> можно последовательным повторением <tex>u=\frac 1 {\log(\frac 1 {1 - \alpha})} </tex> раз. Тоесть создать новые условия, представляющие собой <tex>AND</tex> всех возможных <tex>u</tex>-наборов прежних условий. Конечно, при этом количество запросов на условие увеличится до <tex>2u</tex>.

}}

==Дополнительные материалы==
* [http://www.math.ias.edu/boaz/ExpanderCourse/|N. Linial and A. Wigderson. Expander graphs and their applications. Lecture notes of a course, 2003].
* Michael Sipser and Daniel A. Spielman. Expander codes. IEEE Trans. Inform. Theory, 42(6, part 1):1710–1722, 1996. Codes and complexity.
* C. Papadimitriou and M. Yannakakis. Optimization, approximation and complexity classes. Journal of Computer and System Sciences, 3:425–440, 1991.
* Irit Dinur and Omer Reingold. Assignment testers: Towards combinatorial proofs of the PCP theorem. In Proceedings of the 45th Symposium on Foundations of Computer Science (FOCS), 2004.
==Источники==
* [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005].
* [http://www.cs.utah.edu/~alfeld/LecturePDFs/pcp.pdf The PCP Theorem, Notes by Scott Alfeld, 2008].

PCP-теорема

2013-03-12T06:07:36Z

194.85.161.34: /* Композиция */

{{Теорема
|id=pcp_th
|about=<tex>\mathrm{PCP}</tex> теорема
|statement=<tex>\mathrm{PCP}[\log n, O(1)] = \mathrm{NP}</tex>
}}

Классическое доказательство [[Класс PCP|<tex>\mathrm{PCP}</tex>]] теоремы громоздкое и довольно сложное для восприятия,
рассмотрим вариант докаательства, предложенный Динуром. Оно основано на том, что <tex>\mathrm{PCP}</tex>-теорема [[Эквивалентность_PCP-теоремы_и_теоремы_о_трудности_аппроксимации | эквивалентна <tex>\mathrm{NP}</tex>-трудности задачи <tex>\rho-GAPqCSP</tex>]].

==Определения и леммы, используемые в доказательстве==
{{Определение
|definition= <tex>\mathcal{C}=\lbrace c_1,..., c_n\rbrace</tex> назовем множеством условий над
множеством переменных <tex>V</tex>.
}}
{{Определение
|definition=Число неудовлетворенности <tex>UNSAT(\mathcal{C})</tex> — минимальное подмножество неудовлетворенных условий для любых возможных назначений <tex>V</tex>. <tex>\mathcal{C}</tex> удовлетворимо тогда и только тогда, когда <tex>UNSAT(\mathcal{C})=0</tex>. Если же <tex>\mathcal{C}</tex> неудовлетворимо, тогда <tex>UNSAT(\mathcal{C}) \ge \frac 1 n</tex>.
}}

===Графы условий===
Нам понадобятся графы ограничений для двух переменных, которые определяются следующим образом:
{{Определение
|definition=
<tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex> называется графом условий, если:
* <tex>(V,E)</tex> — неориентированный граф, называемый графом, леащим в основе <tex>G</tex>.
* Множество <tex>V</tex> также представляется в виде множества переменных принимающих значениями из алфавита <tex>\Sigma</tex>
* Каждое ребро <tex>e \in E</tex> содержит условие <tex>c(e) \subseteq \Sigma^2</tex> и <tex>\mathcal{C}=\lbrace c(e)\rbrace_{e \in E}</tex>. Условие <tex>c(e)</tex> называется удовлетворенным парой <tex>(a, b)</tex>, если <tex>(a, b) \in c(e)</tex>
}}

Присваивание это отображение <tex>\sigma:V \rightarrow \Sigma</tex>, которое назначает каждой вершине из <tex>V</tex>
значение из <tex>\Sigma</tex>. Для любого присвоения <tex>\sigma</tex> определим <tex>UNSAT_\sigma(G) = \operatorname*{Pr}\limits_{(u,v)\in E} [(\sigma(u),\sigma(v)) \notin c(e)]</tex> и <tex>UNSAT(G) = \operatorname*{min}\limits_\sigma UNSAT_\sigma(G)</tex>.

Назовем <tex>UNSAT(G)</tex> числом неудовлетворенности графа <tex>G</tex>. Размером графа будем считать размер его описания <tex>size(G)=O(|V|+|E| \cdot |\Sigma|^2)</tex>

{{Лемма
|statement=Для заданного графа условий <tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex>, где <tex>|\Sigma|=3</tex> проверка утверждения <tex>UNSAT(G)=0</tex> — <tex>\mathrm{NP}</tex>-трудная задача.
|proof=
Сведем <tex>3Color</tex> к нашей задаче. Дан граф <tex>G</tex>, алфавит <tex>\Sigma=\lbrace 1,2,3 \rbrace</tex> для трех цветов. Оснастим ребра условиями неравенства. Очевидно, что <tex>G \in 3Color</tex> тогда и только тогда, когда <tex>UNSAT(G)=0<tex> (Иногда удобно использовать одно и то же обозначение <tex>G</tex> для графа условий и графа, лежащего в его основе).
}}

===Экспандер графы===
Экспандер графы играют важную роль во многих теоретических результатах.

{{Определение
|definition= <tex>G=(V,E)</tex> <tex>d</tex>-регулярный граф. Положим <tex>E(S,\overline{S})=|(S \times \overline{S}) \cap E|</tex> равным количеству ребер их подмножества <tex>S\in V</tex> в его дополнение. Определим реберное расширение как
<tex>h(G)=\operatorname*{min}\limits_{S:|S|<\frac {|V|} 2} \frac {E(S, \overline S)} {|S|}</tex>
}}

{{Лемма
|about=О экспандерах
|statement=Существует <tex>d_0 \in \mathbb{N}</tex> и <tex>h_0 >0</tex> такие, что есть построимое за полиномиальное время семейство <tex>\lbrace X_n\rbrace_{n \in \mathbb{N}}</tex> <tex>d_0</tex>-регулярных графов <tex>X_n</tex> с <tex>n</tex> вершинами таких, что <tex>h(X_n) \ge h_0</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

{{Лемма
|statement= Пусть <tex>G</tex> <tex>d</tex>-регулярный граф, а <tex>h(G)</tex> его реберное расширение. Тогда <tex>\lambda(G) \le d - \frac {h(G)^2} d</tex>
}}

{{Определение
|definition=Собственным числом графа <tex>\lambda</tex> называют собственное число его матрицы смежности.
}}

{{Лемма
|statement=Пусть <tex>G</tex> <tex>d</tex>-регулярный граф со вторым по величине собственным числом <tex>\lambda</tex>. Пусть <tex>F \subseteq E</tex> множество ребер. Вероятность <tex>p</tex> того, что случайный путь, начинающийся со случайного ребра из <tex>F</tex> на <tex>i+1</tex> шаге попадет <tex>F</tex> ограничена <tex>\frac {|F|} {|E|} + \left({\frac {|\lambda|} d}\right)^i</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

==Операции на графах условий==
Для доказательства <tex>\mathrm{PCP}</tex> теоремы потребуются три операции над графами уловий:
* Препроцессинг. Простая операция, сохраняющая чило неудовлетворенности(примерно) и размер алфавита, но делающая граф лучше.
* Усиление. Эта операция увеоичивает чило неудовлетворенности за счет увеличения размера алфавита.
* Композицияю Эта операция уменьшает размер алфавита, сохраняя число неудовлетворенности(приблизительно).

===Препроцессинг===
Под хорошим графом будем понимать регулярный, фиксированной степени экспандер граф.
{{Лемма
|about=Препроцессинг
|statement= существуют константы <tex>0 < \lambda < d</tex> и <tex>\beta_1 >0</tex> такие, что любой граф условий <tex>G</tex> может быть преобразован в граф условий <tex>G'=prep(G)</tex> такой, что:
* <tex>G'</tex> <tex>d</tex>-регулярный
* <tex>G'</tex> имеет тот же алфавит, что и <tex>G</tex> и <tex>size(G') = O(size(G))</tex>.
* <tex>\beta_1 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
}}

Заметим, что третий пункт теммы гарантирует поддержание полноты, т.е. если <tex>UNSAT(G)=0</tex>, то и <tex>UNSAT(G')=0</tex>. Доказательство этой леммы состоит из двух следующих лемм (<tex>\beta_1=c \cdot \frac d {d + d_0 + 1}</tex>).

{{Лемма
|about=Константная степень
|statement=Любой граф условий <tex>G = \langle (V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>(d_0 + 1)</tex>-регулярный граф условий <tex>G'=\langle (V',E'),\Sigma,\mathcal{C}'\rangle</tex> такой, что <tex>|V'|</tex>=2|E|</tex> и <tex>c \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>. Для некоторых заданных констант <tex>d_0,c>0</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

Эта лемма известна как экспандер-замена(expander-replacement transformation).

{{Лемма
|about=О расширении
|statement=
Пусть <tex>d_0, h_0 >0</tex> некоторые константы. Любой <tex>d</tex>-регулярный граф условий <tex>G</tex> может быть преобразован в <tex>G'</tex> такой, что:
* <tex>G'</tex> <tex>(d + d_0 + 1)</tex>-регулярный, имеет собственные циклы и <tex>\lambda(G') \le d + d_0 + 1 - \frac {h_0^2} {d + d_0 + 1} < deg(G')</tex>
* <tex>size(G')=O(size(G))</tex>
* <tex> \frac d {d + d_0 + 1} \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

===Усиление===
Это новая операция на системах условий, которая увеличивает число неудовлетворенности.
Пусть <tex>G=\langle (V,E),\Sigma,\mathcal{C}\rangle<tex> граф условий, <tex>t \in \mathbb{N}</tex>. Определим <tex>G^t=\langle (V,\mathbf{E}),\Sigma^{d^{\lceil t/2\rceil}}, \mathcal{C}^t \rangle</tex> как следующий граф условий:
* Веришины <tex>G^t</tex> совпадают с вершинами <tex>G</tex>
* Ребра: <tex>u</tex> и <tex>v</tex> соединены <tex>k</tex> ребрами в <tex>\mathbf{E}</tex>, если количество путей длины <tex>t</tex> из <tex>u</tex> в <tex>v</tex> в графе <tex>G</tex> равно <tex>k</tex>
* Алфавит: алфавит графа <tex>G^t</tex> <tex>\Sigma^{d^{\lceil t/2\rceil}}</tex>, где каждой вершине сопоставлены значения ее соседей, достижимых за <tex>\frac t 2</tex> шагов.
* Условия: Условия сопоставленные ребру <tex>e=(u,v) \in \mathbf{E}</tex> удовлетворены, если назначения для <tex>u</tex> и <tex>v</tex> согласованы с назначениями, удовлетворяющими условия, порожденные <tex>\frac t 2</tex> соседями <tex>u</tex> и <tex>v</tex>.

Если <tex>UNSAT(G)=0</tex> тогда очевидно <tex>UNSAT(G^t)=0</tex>. Интереснее доказательство того, что <tex>UNSAT(G^t) \ge O(\sqrt{t} \cdot UNSAT(G)</tex>.

{{Лемма
|about=Усиление
|statement= Пусть <tex>\lambda < d</tex> и <tex>|\Sigma|</tex> произвольные константы. Тогда существует константа <tex>\beta_2=\beta_2(\lambda,d,|\Sigma|)>0</rex> такая, что для любого <tex>t \in \mathbb N</tex> и для любого <tex>d</tex>-регулярного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> с собственными циклами и <tex>\lambda(G)\le \lambda</tex>, <tex>UNSAT(G^t) \ge \beta_2 \sqrt{t} \cdot min \left({UNSAT(G), \frac 1 t}\right)</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

Поскольку <tex>UNSAT(G) \le \frac 1 t</tex>, из жтой леммы следует что <tex>UNSAT(G^t) \ge O(\sqrt{t}) \cdot UNSAT(G)</tex>. Это основная техническая лемма.
===Композиция===
{{Определение
|about=Тестер присвоений
|definition=Тестер присвоений с алфавитом <tex>\Sigma_0</tex> и вероятностью отклонения <tex>\epsilon > 0</tex> это полиномиальное преобразование <tex>\mathcal{P}</tex>, принимающее на вход схему <tex>\Phi</tex> над будевыми переменными <tex>X</tex> и дающую на выходе граф условий <tex>G=\langle(V,E),\Sigma_0,\mathcal{C}\rangle</tex> такой, что <tex>V \subset X</tex>(в условном графе <tex>V</tex> играет одновременно две роли: переменных и вершин. <tex>Y \subset X</tex> подразумевает, что некоторые вершины из <tex>V</tex> определены с помощью переменных <tex>X</tex>). Пусть <tex>V'=V \setminus X</tex> и <tex>a : X \rightarrow \lbrace 0,1 \rbrace</tex> — присваивание.
* (Полнота) Если <tex>a \in SAT(\Phi)</tex> то существует <tex>b : V' \rightarrow \Sigma_0</tex> такое, что <tex>UNSAT_{a\cup{b}}(G)=0</tex>
* (Обоснованность) Если <tex>a \notin SAT(\Phi)</tex> то для всех <tex>b : V' \rightarrow \Sigma_0</tex>, <tex>UNSAT_{a\cup{b}}(G) \ge \epsilon \cdot dist(a, SAT(\Phi))</tex>.
}}

Следует заметить, что не накладывается никаких ограничений ни на время работы <tex>\mathcal{P}</tex> ни на <tex>size(G)</tex>. Мы игнорируем размер схемы <Tex>\Phi</tex>, которая может быть экспоненциальна относительно <tex>|X|</tex>.

{{Лемма
|about=Композиция
|statement=Пусть существует тестер присвоений <tex>\mathcal{P}</tex> с константной вероятностью отклонения <tex>\epsilon > 0</tex> и алфавитом <tex>\Sigma_0</tex>, <tex>|\Sigma_0|=O(1)</tex>. Тогда существует <tex>\beta_3 > 0</tex>, зависящая только от <tex>\mathcal{P}</tex>, такая что любой граф условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex>, обозначаемый <tex>G \circ \mathcal{C}</tex>, такой что <tex>size(G')=M(|\Sigma|) \cdot size(G)</tex> и <tex>\beta_3 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005]
}}

==Основная теорема==
Основываясь на операциях с графами условий мы можем доказать основную теорему.
{{Теорема
|about=Основная теорема
|statement=Для любого <tex>\Sigma</tex>, <tex>|\Sigma|=O(1)</tex> существуют константы <tex>C > 0</tex> и <tex>0 < \alpha < 1</tex> такие, что для данного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> за полиномиальное время можно построить граф условий <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex> такой, что:
* <tex>size(G') \le C \cdot size(G)</tex> и <tex>|\Sigma_0| = O(1)</tex>
* (Полнота) Если <tex>UNSAT(G)=0</tex>, то <tex>UNSAT(G')=0</tex>
* (Обоснованность) <tex>UNSAT(G') \ge min(2 \cdot UNSAT(G), \alpha)</tex>
|proof=
Построим <tex>G'</tex> по <tex>G</tex> следующим образом: <tex>G'=(prep(G))^t \circ \mathcal{P}</tex>.
# (Препроцессинг) Пусть <tex>H_1=prep(G)</tex>. Существуют некоторые глобальные константы <tex>\lambda < d </tex> и <tex>\beta_1 >0</tex> такие, что <tex>H_1</tex> <tex>d</tex>-регулярный, имеет тот же алфавит, что и <tex>G</tex>, <tex>\lambda(H_1) \le \lambda < d</tex> и <tex>\beta_1 \cdot UNSAT*G( \le UNSAT(H_1) \le UNSAT(G)</tex>.
# (Усиление) Пусть <tex>H_2=(H_1)^t</tex> для достаточно большой константы <tex> t > 1</tex>, которую определим ниже. Существует некоторая константа <tex>\beta_2=\beta(\lambda, d, |\Sigma|) > 0</tex>, для которой <tex>UNSAT(H_2) \ge \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex>. Однако, алфавит вырос до <tex>\Sigma^{d^{\lceil t / 2 \rceil}}</tex>.
# (Композиция) Пусть <tex>G'=H_2 \circ \mathcal{P}</tex>. Это уменьшит алфавит до <tex>\Sigma_0</tex>, при <tex>\beta_3 \cdot UNSAT(H_2) \le UNSAT(G') \le UNSAT(H_2)</tex> для некоторой <tex>\beta_3 > 0 </tex>.

Проверим выполнение условий теоремы. Размер <tex>G'</tex> линеен относительно размера<tex>G</tex>, поскольку на каждом шагу увеличивался линейно. Полнота явно поддерживается на каждом шаге. Теперь выберем <tex>t=\left\lceil\left({\frac 2 {\beta_1\beta_2\beta_3}}\right)^2\right\rceil</tex>. Пусть <tex>\alpha=\frac {\beta_3\beta_2} {sqrt{t}}</tex>.
Таким образом,

<tex>UNSAT(G') \ge \beta_3 \cdot UNSAT(H_2)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(\beta_1 UNSAT(G_, \frac 1 t) </tex> <tex>\ge min(2 \cdot UNSAT(G), \alpha)</tex>
}}
===Доказательство PCP теоремы===
{{Лемма
|statement=Следствием из основной теоремы является <tex>\mathrm{NP}</tex>-трудность <tex>GAP-3SAT_s</tex>.
|proof=Сведем удовлетворимость графа условий к нашей задаче. Пусть <tex>G</tex> задача удовлетворимости некоторого графа с <tex>|\Sigma|=3</tex>. Идей состоит в повторении применения основной теоремы до тех пор, пока число неудовлетворенности не станет постоянным.

Пусть <tex>G_0 = G</tex> и <tex>G_i(i \ge 1)</tex> — результат применения основной теоремы к <tex>G_{i-1}</tex>. Тогда для <tex>i \ge 1</tex> <tex>G</tex> — граф условий с алфавитом <tex>\Sigma_0</tex>. Пусть <tex>E_0</tex> — множество ребер <tex>G_0<tex> и <tex>k=\log|E_0|=O(\log n)</tex>.

Полнота показывается тривиально: если <tex>UNSAT(G_0)=0</tex>, то для всех <tex>i</tex> <tex>UNSAT(G_i)=0</tex>. Для обоснованности рассмотрим <tex>UNSAT(G_0) > 0</tex>. Если для некоторого <tex>i*<k</tex>, <tex>UNSAT(G_{i*}) \ge \frac \alpha 2</tex>, то из основной теоремы следует, что для всех <tex>i>i*</tex> <tex>UNSAT(G_i)\ge \alpha</tex>. На остальные <tex>i</tex> это распространяется по индукции <tex>UNSAT(G_i) \ge min(2^i UNSAT(G_0), \alpha)</tex>.

Если <tex>UNSAT(G_0)>0</tex>, то <tex>UNSAT(G_0)\ge \frac 1 {|E_0|}</tex>. Конечно, <tex>2^k UNSAT(G_0) > \alpha</tex>. Таким образом <tex>UNSAT(G_k) \ge \alpha</tex>.

Такми образом <tex>\rho -GAP2CSP</tex> <tex>\mathrm{NP}</tex>-трудная. Достичь обоснованности <tex>\frac 1 2</tex> можно последовательным повторением <tex>u=\frac 1 {\log(\frac 1 {1 - \alpha})} </tex> раз. Тоесть создать новые условия, представляющие собой <tex>AND</tex> всех возможных <tex>u</tex>-наборов прежних условий. Конечно, при этом количество запросов на условие увеличится до <tex>2u</tex>.

}}

==Дополнительные материалы==
* [http://www.math.ias.edu/boaz/ExpanderCourse/|N. Linial and A. Wigderson. Expander graphs and their applications. Lecture notes of a course, 2003].
* Michael Sipser and Daniel A. Spielman. Expander codes. IEEE Trans. Inform. Theory, 42(6, part 1):1710–1722, 1996. Codes and complexity.
* C. Papadimitriou and M. Yannakakis. Optimization, approximation and complexity classes. Journal of Computer and System Sciences, 3:425–440, 1991.
* Irit Dinur and Omer Reingold. Assignment testers: Towards combinatorial proofs of the PCP theorem. In Proceedings of the 45th Symposium on Foundations of Computer Science (FOCS), 2004.
==Источники==
* [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005].
* [http://www.cs.utah.edu/~alfeld/LecturePDFs/pcp.pdf The PCP Theorem, Notes by Scott Alfeld, 2008].

PCP-теорема

2013-03-12T06:06:41Z

194.85.161.34: /* Источники */

{{Теорема
|id=pcp_th
|about=<tex>\mathrm{PCP}</tex> теорема
|statement=<tex>\mathrm{PCP}[\log n, O(1)] = \mathrm{NP}</tex>
}}

Классическое доказательство [[Класс PCP|<tex>\mathrm{PCP}</tex>]] теоремы громоздкое и довольно сложное для восприятия,
рассмотрим вариант докаательства, предложенный Динуром. Оно основано на том, что <tex>\mathrm{PCP}</tex>-теорема [[Эквивалентность_PCP-теоремы_и_теоремы_о_трудности_аппроксимации | эквивалентна <tex>\mathrm{NP}</tex>-трудности задачи <tex>\rho-GAPqCSP</tex>]].

==Определения и леммы, используемые в доказательстве==
{{Определение
|definition= <tex>\mathcal{C}=\lbrace c_1,..., c_n\rbrace</tex> назовем множеством условий над
множеством переменных <tex>V</tex>.
}}
{{Определение
|definition=Число неудовлетворенности <tex>UNSAT(\mathcal{C})</tex> — минимальное подмножество неудовлетворенных условий для любых возможных назначений <tex>V</tex>. <tex>\mathcal{C}</tex> удовлетворимо тогда и только тогда, когда <tex>UNSAT(\mathcal{C})=0</tex>. Если же <tex>\mathcal{C}</tex> неудовлетворимо, тогда <tex>UNSAT(\mathcal{C}) \ge \frac 1 n</tex>.
}}

===Графы условий===
Нам понадобятся графы ограничений для двух переменных, которые определяются следующим образом:
{{Определение
|definition=
<tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex> называется графом условий, если:
* <tex>(V,E)</tex> — неориентированный граф, называемый графом, леащим в основе <tex>G</tex>.
* Множество <tex>V</tex> также представляется в виде множества переменных принимающих значениями из алфавита <tex>\Sigma</tex>
* Каждое ребро <tex>e \in E</tex> содержит условие <tex>c(e) \subseteq \Sigma^2</tex> и <tex>\mathcal{C}=\lbrace c(e)\rbrace_{e \in E}</tex>. Условие <tex>c(e)</tex> называется удовлетворенным парой <tex>(a, b)</tex>, если <tex>(a, b) \in c(e)</tex>
}}

Присваивание это отображение <tex>\sigma:V \rightarrow \Sigma</tex>, которое назначает каждой вершине из <tex>V</tex>
значение из <tex>\Sigma</tex>. Для любого присвоения <tex>\sigma</tex> определим <tex>UNSAT_\sigma(G) = \operatorname*{Pr}\limits_{(u,v)\in E} [(\sigma(u),\sigma(v)) \notin c(e)]</tex> и <tex>UNSAT(G) = \operatorname*{min}\limits_\sigma UNSAT_\sigma(G)</tex>.

Назовем <tex>UNSAT(G)</tex> числом неудовлетворенности графа <tex>G</tex>. Размером графа будем считать размер его описания <tex>size(G)=O(|V|+|E| \cdot |\Sigma|^2)</tex>

{{Лемма
|statement=Для заданного графа условий <tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex>, где <tex>|\Sigma|=3</tex> проверка утверждения <tex>UNSAT(G)=0</tex> — <tex>\mathrm{NP}</tex>-трудная задача.
|proof=
Сведем <tex>3Color</tex> к нашей задаче. Дан граф <tex>G</tex>, алфавит <tex>\Sigma=\lbrace 1,2,3 \rbrace</tex> для трех цветов. Оснастим ребра условиями неравенства. Очевидно, что <tex>G \in 3Color</tex> тогда и только тогда, когда <tex>UNSAT(G)=0<tex> (Иногда удобно использовать одно и то же обозначение <tex>G</tex> для графа условий и графа, лежащего в его основе).
}}

===Экспандер графы===
Экспандер графы играют важную роль во многих теоретических результатах.

{{Определение
|definition= <tex>G=(V,E)</tex> <tex>d</tex>-регулярный граф. Положим <tex>E(S,\overline{S})=|(S \times \overline{S}) \cap E|</tex> равным количеству ребер их подмножества <tex>S\in V</tex> в его дополнение. Определим реберное расширение как
<tex>h(G)=\operatorname*{min}\limits_{S:|S|<\frac {|V|} 2} \frac {E(S, \overline S)} {|S|}</tex>
}}

{{Лемма
|about=О экспандерах
|statement=Существует <tex>d_0 \in \mathbb{N}</tex> и <tex>h_0 >0</tex> такие, что есть построимое за полиномиальное время семейство <tex>\lbrace X_n\rbrace_{n \in \mathbb{N}}</tex> <tex>d_0</tex>-регулярных графов <tex>X_n</tex> с <tex>n</tex> вершинами таких, что <tex>h(X_n) \ge h_0</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

{{Лемма
|statement= Пусть <tex>G</tex> <tex>d</tex>-регулярный граф, а <tex>h(G)</tex> его реберное расширение. Тогда <tex>\lambda(G) \le d - \frac {h(G)^2} d</tex>
}}

{{Определение
|definition=Собственным числом графа <tex>\lambda</tex> называют собственное число его матрицы смежности.
}}

{{Лемма
|statement=Пусть <tex>G</tex> <tex>d</tex>-регулярный граф со вторым по величине собственным числом <tex>\lambda</tex>. Пусть <tex>F \subseteq E</tex> множество ребер. Вероятность <tex>p</tex> того, что случайный путь, начинающийся со случайного ребра из <tex>F</tex> на <tex>i+1</tex> шаге попадет <tex>F</tex> ограничена <tex>\frac {|F|} {|E|} + \left({\frac {|\lambda|} d}\right)^i</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

==Операции на графах условий==
Для доказательства <tex>\mathrm{PCP}</tex> теоремы потребуются три операции над графами уловий:
* Препроцессинг. Простая операция, сохраняющая чило неудовлетворенности(примерно) и размер алфавита, но делающая граф лучше.
* Усиление. Эта операция увеоичивает чило неудовлетворенности за счет увеличения размера алфавита.
* Композицияю Эта операция уменьшает размер алфавита, сохраняя число неудовлетворенности(приблизительно).

===Препроцессинг===
Под хорошим графом будем понимать регулярный, фиксированной степени экспандер граф.
{{Лемма
|about=Препроцессинг
|statement= существуют константы <tex>0 < \lambda < d</tex> и <tex>\beta_1 >0</tex> такие, что любой граф условий <tex>G</tex> может быть преобразован в граф условий <tex>G'=prep(G)</tex> такой, что:
* <tex>G'</tex> <tex>d</tex>-регулярный
* <tex>G'</tex> имеет тот же алфавит, что и <tex>G</tex> и <tex>size(G') = O(size(G))</tex>.
* <tex>\beta_1 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
}}

Заметим, что третий пункт теммы гарантирует поддержание полноты, т.е. если <tex>UNSAT(G)=0</tex>, то и <tex>UNSAT(G')=0</tex>. Доказательство этой леммы состоит из двух следующих лемм (<tex>\beta_1=c \cdot \frac d {d + d_0 + 1}</tex>).

{{Лемма
|about=Константная степень
|statement=Любой граф условий <tex>G = \langle (V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>(d_0 + 1)</tex>-регулярный граф условий <tex>G'=\langle (V',E'),\Sigma,\mathcal{C}'\rangle</tex> такой, что <tex>|V'|</tex>=2|E|</tex> и <tex>c \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>. Для некоторых заданных констант <tex>d_0,c>0</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

Эта лемма известна как экспандер-замена(expander-replacement transformation).

{{Лемма
|about=О расширении
|statement=
Пусть <tex>d_0, h_0 >0</tex> некоторые константы. Любой <tex>d</tex>-регулярный граф условий <tex>G</tex> может быть преобразован в <tex>G'</tex> такой, что:
* <tex>G'</tex> <tex>(d + d_0 + 1)</tex>-регулярный, имеет собственные циклы и <tex>\lambda(G') \le d + d_0 + 1 - \frac {h_0^2} {d + d_0 + 1} < deg(G')</tex>
* <tex>size(G')=O(size(G))</tex>
* <tex> \frac d {d + d_0 + 1} \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

===Усиление===
Это новая операция на системах условий, которая увеличивает число неудовлетворенности.
Пусть <tex>G=\langle (V,E),\Sigma,\mathcal{C}\rangle<tex> граф условий, <tex>t \in \mathbb{N}</tex>. Определим <tex>G^t=\langle (V,\mathbf{E}),\Sigma^{d^{\lceil t/2\rceil}}, \mathcal{C}^t \rangle</tex> как следующий граф условий:
* Веришины <tex>G^t</tex> совпадают с вершинами <tex>G</tex>
* Ребра: <tex>u</tex> и <tex>v</tex> соединены <tex>k</tex> ребрами в <tex>\mathbf{E}</tex>, если количество путей длины <tex>t</tex> из <tex>u</tex> в <tex>v</tex> в графе <tex>G</tex> равно <tex>k</tex>
* Алфавит: алфавит графа <tex>G^t</tex> <tex>\Sigma^{d^{\lceil t/2\rceil}}</tex>, где каждой вершине сопоставлены значения ее соседей, достижимых за <tex>\frac t 2</tex> шагов.
* Условия: Условия сопоставленные ребру <tex>e=(u,v) \in \mathbf{E}</tex> удовлетворены, если назначения для <tex>u</tex> и <tex>v</tex> согласованы с назначениями, удовлетворяющими условия, порожденные <tex>\frac t 2</tex> соседями <tex>u</tex> и <tex>v</tex>.

Если <tex>UNSAT(G)=0</tex> тогда очевидно <tex>UNSAT(G^t)=0</tex>. Интереснее доказательство того, что <tex>UNSAT(G^t) \ge O(\sqrt{t} \cdot UNSAT(G)</tex>.

{{Лемма
|about=Усиление
|statement= Пусть <tex>\lambda < d</tex> и <tex>|\Sigma|</tex> произвольные константы. Тогда существует константа <tex>\beta_2=\beta_2(\lambda,d,|\Sigma|)>0</rex> такая, что для любого <tex>t \in \mathbb N</tex> и для любого <tex>d</tex>-регулярного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> с собственными циклами и <tex>\lambda(G)\le \lambda</tex>, <tex>UNSAT(G^t) \ge \beta_2 \sqrt{t} \cdot min \left({UNSAT(G), \frac 1 t}\right)</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

Поскольку <tex>UNSAT(G) \le \frac 1 t</tex>, из жтой леммы следует что <tex>UNSAT(G^t) \ge O(\sqrt{t}) \cdot UNSAT(G)</tex>. Это основная техническая лемма.
===Композиция===
{{Определение
|about=Тестер присвоений
|definition=Тестер присвоений с алфавитом <tex>\Sigma_0</tex> и вероятностью отклонения <tex>\epsilon > 0</tex> это полиномиальное преобразование <tex>\mathcal{P}</tex>, принимающее на вход схему <tex>\Phi</tex> над будевыми переменными <tex>X</tex> и дающую на выходе граф условий <tex>G=\langle(V,E),\Sigma_0,\mathcal{C}\rangle</tex> такой, что <tex>V \subset X</tex>(в условном графе <tex>V</tex> играет одновременно две роли: переменных и вершин. <tex>Y \subset X</tex> подразумевает, что некоторые вершины из <tex>V</tex> определены с помощью переменных <tex>X</tex>). Пусть <tex>V'=V \setminus X</tex> и <tex>a : X \rightarrow \lbrace 0,1 \rbrace</tex> — присваивание.
* (Полнота) Если <tex>a \in SAT(\Phi)</tex> то существует <tex>b : V' \rightarrow \Sigma_0</tex> такое, что <tex>UNSAT_{a\cup{b}}(G)=0</tex>
* (Обоснованность) Если <tex>a \notin SAT(\Phi)</tex> то для всех <tex>b : V' \rightarrow \Sigma_0</tex>, <tex>UNSAT_{a\cup{b}}(G) \ge \epsilon \cdot dist(a, SAT(\Phi))</tex>.
}}

Следует заметить, что не накладывается никаких ограничений ни на время работы <tex>\mathcal{P}</tex> ни на <tex>size(G)</tex>. Мы игнорируем размер схемы <Tex>\Phi</tex>, которая может быть экспоненциальна относительно <tex>|X|</tex>.

{{Лемма
|about=Композиция
|statement=Пусть существует тестер присвоений <tex>\mathcal{P}</tex> с константной вероятностью отклонения <tex>\epsilon > 0</tex> и алфавитом <tex>\Sigma_0</tex>, <tex>|\Sigma_0|=O(1)</tex>. Тогда существует <tex>\beta_3 > 0</tex>, зависящая только от <tex>\mathcal{P}</tex>, такая что любой граф условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex>, обозначаемый <tex>G \circ \mathcal{C}</tex>, такой что <tex>size(G')=M(|\Sigma|) \cdot size(G)</tex> и <tex>\beta_3 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

==Основная теорема==
Основываясь на операциях с графами условий мы можем доказать основную теорему.
{{Теорема
|about=Основная теорема
|statement=Для любого <tex>\Sigma</tex>, <tex>|\Sigma|=O(1)</tex> существуют константы <tex>C > 0</tex> и <tex>0 < \alpha < 1</tex> такие, что для данного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> за полиномиальное время можно построить граф условий <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex> такой, что:
* <tex>size(G') \le C \cdot size(G)</tex> и <tex>|\Sigma_0| = O(1)</tex>
* (Полнота) Если <tex>UNSAT(G)=0</tex>, то <tex>UNSAT(G')=0</tex>
* (Обоснованность) <tex>UNSAT(G') \ge min(2 \cdot UNSAT(G), \alpha)</tex>
|proof=
Построим <tex>G'</tex> по <tex>G</tex> следующим образом: <tex>G'=(prep(G))^t \circ \mathcal{P}</tex>.
# (Препроцессинг) Пусть <tex>H_1=prep(G)</tex>. Существуют некоторые глобальные константы <tex>\lambda < d </tex> и <tex>\beta_1 >0</tex> такие, что <tex>H_1</tex> <tex>d</tex>-регулярный, имеет тот же алфавит, что и <tex>G</tex>, <tex>\lambda(H_1) \le \lambda < d</tex> и <tex>\beta_1 \cdot UNSAT*G( \le UNSAT(H_1) \le UNSAT(G)</tex>.
# (Усиление) Пусть <tex>H_2=(H_1)^t</tex> для достаточно большой константы <tex> t > 1</tex>, которую определим ниже. Существует некоторая константа <tex>\beta_2=\beta(\lambda, d, |\Sigma|) > 0</tex>, для которой <tex>UNSAT(H_2) \ge \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex>. Однако, алфавит вырос до <tex>\Sigma^{d^{\lceil t / 2 \rceil}}</tex>.
# (Композиция) Пусть <tex>G'=H_2 \circ \mathcal{P}</tex>. Это уменьшит алфавит до <tex>\Sigma_0</tex>, при <tex>\beta_3 \cdot UNSAT(H_2) \le UNSAT(G') \le UNSAT(H_2)</tex> для некоторой <tex>\beta_3 > 0 </tex>.

Проверим выполнение условий теоремы. Размер <tex>G'</tex> линеен относительно размера<tex>G</tex>, поскольку на каждом шагу увеличивался линейно. Полнота явно поддерживается на каждом шаге. Теперь выберем <tex>t=\left\lceil\left({\frac 2 {\beta_1\beta_2\beta_3}}\right)^2\right\rceil</tex>. Пусть <tex>\alpha=\frac {\beta_3\beta_2} {sqrt{t}}</tex>.
Таким образом,

<tex>UNSAT(G') \ge \beta_3 \cdot UNSAT(H_2)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(\beta_1 UNSAT(G_, \frac 1 t) </tex> <tex>\ge min(2 \cdot UNSAT(G), \alpha)</tex>
}}
===Доказательство PCP теоремы===
{{Лемма
|statement=Следствием из основной теоремы является <tex>\mathrm{NP}</tex>-трудность <tex>GAP-3SAT_s</tex>.
|proof=Сведем удовлетворимость графа условий к нашей задаче. Пусть <tex>G</tex> задача удовлетворимости некоторого графа с <tex>|\Sigma|=3</tex>. Идей состоит в повторении применения основной теоремы до тех пор, пока число неудовлетворенности не станет постоянным.

Пусть <tex>G_0 = G</tex> и <tex>G_i(i \ge 1)</tex> — результат применения основной теоремы к <tex>G_{i-1}</tex>. Тогда для <tex>i \ge 1</tex> <tex>G</tex> — граф условий с алфавитом <tex>\Sigma_0</tex>. Пусть <tex>E_0</tex> — множество ребер <tex>G_0<tex> и <tex>k=\log|E_0|=O(\log n)</tex>.

Полнота показывается тривиально: если <tex>UNSAT(G_0)=0</tex>, то для всех <tex>i</tex> <tex>UNSAT(G_i)=0</tex>. Для обоснованности рассмотрим <tex>UNSAT(G_0) > 0</tex>. Если для некоторого <tex>i*<k</tex>, <tex>UNSAT(G_{i*}) \ge \frac \alpha 2</tex>, то из основной теоремы следует, что для всех <tex>i>i*</tex> <tex>UNSAT(G_i)\ge \alpha</tex>. На остальные <tex>i</tex> это распространяется по индукции <tex>UNSAT(G_i) \ge min(2^i UNSAT(G_0), \alpha)</tex>.

Если <tex>UNSAT(G_0)>0</tex>, то <tex>UNSAT(G_0)\ge \frac 1 {|E_0|}</tex>. Конечно, <tex>2^k UNSAT(G_0) > \alpha</tex>. Таким образом <tex>UNSAT(G_k) \ge \alpha</tex>.

Такми образом <tex>\rho -GAP2CSP</tex> <tex>\mathrm{NP}</tex>-трудная. Достичь обоснованности <tex>\frac 1 2</tex> можно последовательным повторением <tex>u=\frac 1 {\log(\frac 1 {1 - \alpha})} </tex> раз. Тоесть создать новые условия, представляющие собой <tex>AND</tex> всех возможных <tex>u</tex>-наборов прежних условий. Конечно, при этом количество запросов на условие увеличится до <tex>2u</tex>.

}}

==Дополнительные материалы==
* [http://www.math.ias.edu/boaz/ExpanderCourse/|N. Linial and A. Wigderson. Expander graphs and their applications. Lecture notes of a course, 2003].
* Michael Sipser and Daniel A. Spielman. Expander codes. IEEE Trans. Inform. Theory, 42(6, part 1):1710–1722, 1996. Codes and complexity.
* C. Papadimitriou and M. Yannakakis. Optimization, approximation and complexity classes. Journal of Computer and System Sciences, 3:425–440, 1991.
* Irit Dinur and Omer Reingold. Assignment testers: Towards combinatorial proofs of the PCP theorem. In Proceedings of the 45th Symposium on Foundations of Computer Science (FOCS), 2004.
==Источники==
* [http://eccc.hpi-web.de/report/2005/046 The PCP Theorem by Gap Amplification, Irit Dinur, 2005].
* [http://www.cs.utah.edu/~alfeld/LecturePDFs/pcp.pdf The PCP Theorem, Notes by Scott Alfeld, 2008].

PCP-теорема

2013-03-12T06:05:22Z

194.85.161.34: очепятка

{{Теорема
|id=pcp_th
|about=<tex>\mathrm{PCP}</tex> теорема
|statement=<tex>\mathrm{PCP}[\log n, O(1)] = \mathrm{NP}</tex>
}}

Классическое доказательство [[Класс PCP|<tex>\mathrm{PCP}</tex>]] теоремы громоздкое и довольно сложное для восприятия,
рассмотрим вариант докаательства, предложенный Динуром. Оно основано на том, что <tex>\mathrm{PCP}</tex>-теорема [[Эквивалентность_PCP-теоремы_и_теоремы_о_трудности_аппроксимации | эквивалентна <tex>\mathrm{NP}</tex>-трудности задачи <tex>\rho-GAPqCSP</tex>]].

==Определения и леммы, используемые в доказательстве==
{{Определение
|definition= <tex>\mathcal{C}=\lbrace c_1,..., c_n\rbrace</tex> назовем множеством условий над
множеством переменных <tex>V</tex>.
}}
{{Определение
|definition=Число неудовлетворенности <tex>UNSAT(\mathcal{C})</tex> — минимальное подмножество неудовлетворенных условий для любых возможных назначений <tex>V</tex>. <tex>\mathcal{C}</tex> удовлетворимо тогда и только тогда, когда <tex>UNSAT(\mathcal{C})=0</tex>. Если же <tex>\mathcal{C}</tex> неудовлетворимо, тогда <tex>UNSAT(\mathcal{C}) \ge \frac 1 n</tex>.
}}

===Графы условий===
Нам понадобятся графы ограничений для двух переменных, которые определяются следующим образом:
{{Определение
|definition=
<tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex> называется графом условий, если:
* <tex>(V,E)</tex> — неориентированный граф, называемый графом, леащим в основе <tex>G</tex>.
* Множество <tex>V</tex> также представляется в виде множества переменных принимающих значениями из алфавита <tex>\Sigma</tex>
* Каждое ребро <tex>e \in E</tex> содержит условие <tex>c(e) \subseteq \Sigma^2</tex> и <tex>\mathcal{C}=\lbrace c(e)\rbrace_{e \in E}</tex>. Условие <tex>c(e)</tex> называется удовлетворенным парой <tex>(a, b)</tex>, если <tex>(a, b) \in c(e)</tex>
}}

Присваивание это отображение <tex>\sigma:V \rightarrow \Sigma</tex>, которое назначает каждой вершине из <tex>V</tex>
значение из <tex>\Sigma</tex>. Для любого присвоения <tex>\sigma</tex> определим <tex>UNSAT_\sigma(G) = \operatorname*{Pr}\limits_{(u,v)\in E} [(\sigma(u),\sigma(v)) \notin c(e)]</tex> и <tex>UNSAT(G) = \operatorname*{min}\limits_\sigma UNSAT_\sigma(G)</tex>.

Назовем <tex>UNSAT(G)</tex> числом неудовлетворенности графа <tex>G</tex>. Размером графа будем считать размер его описания <tex>size(G)=O(|V|+|E| \cdot |\Sigma|^2)</tex>

{{Лемма
|statement=Для заданного графа условий <tex>G=\left\langle(V,E,\Sigma,\mathcal{C}\right\rangle</tex>, где <tex>|\Sigma|=3</tex> проверка утверждения <tex>UNSAT(G)=0</tex> — <tex>\mathrm{NP}</tex>-трудная задача.
|proof=
Сведем <tex>3Color</tex> к нашей задаче. Дан граф <tex>G</tex>, алфавит <tex>\Sigma=\lbrace 1,2,3 \rbrace</tex> для трех цветов. Оснастим ребра условиями неравенства. Очевидно, что <tex>G \in 3Color</tex> тогда и только тогда, когда <tex>UNSAT(G)=0<tex> (Иногда удобно использовать одно и то же обозначение <tex>G</tex> для графа условий и графа, лежащего в его основе).
}}

===Экспандер графы===
Экспандер графы играют важную роль во многих теоретических результатах.

{{Определение
|definition= <tex>G=(V,E)</tex> <tex>d</tex>-регулярный граф. Положим <tex>E(S,\overline{S})=|(S \times \overline{S}) \cap E|</tex> равным количеству ребер их подмножества <tex>S\in V</tex> в его дополнение. Определим реберное расширение как
<tex>h(G)=\operatorname*{min}\limits_{S:|S|<\frac {|V|} 2} \frac {E(S, \overline S)} {|S|}</tex>
}}

{{Лемма
|about=О экспандерах
|statement=Существует <tex>d_0 \in \mathbb{N}</tex> и <tex>h_0 >0</tex> такие, что есть построимое за полиномиальное время семейство <tex>\lbrace X_n\rbrace_{n \in \mathbb{N}}</tex> <tex>d_0</tex>-регулярных графов <tex>X_n</tex> с <tex>n</tex> вершинами таких, что <tex>h(X_n) \ge h_0</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

{{Лемма
|statement= Пусть <tex>G</tex> <tex>d</tex>-регулярный граф, а <tex>h(G)</tex> его реберное расширение. Тогда <tex>\lambda(G) \le d - \frac {h(G)^2} d</tex>
}}

{{Определение
|definition=Собственным числом графа <tex>\lambda</tex> называют собственное число его матрицы смежности.
}}

{{Лемма
|statement=Пусть <tex>G</tex> <tex>d</tex>-регулярный граф со вторым по величине собственным числом <tex>\lambda</tex>. Пусть <tex>F \subseteq E</tex> множество ребер. Вероятность <tex>p</tex> того, что случайный путь, начинающийся со случайного ребра из <tex>F</tex> на <tex>i+1</tex> шаге попадет <tex>F</tex> ограничена <tex>\frac {|F|} {|E|} + \left({\frac {|\lambda|} d}\right)^i</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

==Операции на графах условий==
Для доказательства <tex>\mathrm{PCP}</tex> теоремы потребуются три операции над графами уловий:
* Препроцессинг. Простая операция, сохраняющая чило неудовлетворенности(примерно) и размер алфавита, но делающая граф лучше.
* Усиление. Эта операция увеоичивает чило неудовлетворенности за счет увеличения размера алфавита.
* Композицияю Эта операция уменьшает размер алфавита, сохраняя число неудовлетворенности(приблизительно).

===Препроцессинг===
Под хорошим графом будем понимать регулярный, фиксированной степени экспандер граф.
{{Лемма
|about=Препроцессинг
|statement= существуют константы <tex>0 < \lambda < d</tex> и <tex>\beta_1 >0</tex> такие, что любой граф условий <tex>G</tex> может быть преобразован в граф условий <tex>G'=prep(G)</tex> такой, что:
* <tex>G'</tex> <tex>d</tex>-регулярный
* <tex>G'</tex> имеет тот же алфавит, что и <tex>G</tex> и <tex>size(G') = O(size(G))</tex>.
* <tex>\beta_1 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
}}

Заметим, что третий пункт теммы гарантирует поддержание полноты, т.е. если <tex>UNSAT(G)=0</tex>, то и <tex>UNSAT(G')=0</tex>. Доказательство этой леммы состоит из двух следующих лемм (<tex>\beta_1=c \cdot \frac d {d + d_0 + 1}</tex>).

{{Лемма
|about=Константная степень
|statement=Любой граф условий <tex>G = \langle (V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>(d_0 + 1)</tex>-регулярный граф условий <tex>G'=\langle (V',E'),\Sigma,\mathcal{C}'\rangle</tex> такой, что <tex>|V'|</tex>=2|E|</tex> и <tex>c \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>. Для некоторых заданных констант <tex>d_0,c>0</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

Эта лемма известна как экспандер-замена(expander-replacement transformation).

{{Лемма
|about=О расширении
|statement=
Пусть <tex>d_0, h_0 >0</tex> некоторые константы. Любой <tex>d</tex>-регулярный граф условий <tex>G</tex> может быть преобразован в <tex>G'</tex> такой, что:
* <tex>G'</tex> <tex>(d + d_0 + 1)</tex>-регулярный, имеет собственные циклы и <tex>\lambda(G') \le d + d_0 + 1 - \frac {h_0^2} {d + d_0 + 1} < deg(G')</tex>
* <tex>size(G')=O(size(G))</tex>
* <tex> \frac d {d + d_0 + 1} \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

===Усиление===
Это новая операция на системах условий, которая увеличивает число неудовлетворенности.
Пусть <tex>G=\langle (V,E),\Sigma,\mathcal{C}\rangle<tex> граф условий, <tex>t \in \mathbb{N}</tex>. Определим <tex>G^t=\langle (V,\mathbf{E}),\Sigma^{d^{\lceil t/2\rceil}}, \mathcal{C}^t \rangle</tex> как следующий граф условий:
* Веришины <tex>G^t</tex> совпадают с вершинами <tex>G</tex>
* Ребра: <tex>u</tex> и <tex>v</tex> соединены <tex>k</tex> ребрами в <tex>\mathbf{E}</tex>, если количество путей длины <tex>t</tex> из <tex>u</tex> в <tex>v</tex> в графе <tex>G</tex> равно <tex>k</tex>
* Алфавит: алфавит графа <tex>G^t</tex> <tex>\Sigma^{d^{\lceil t/2\rceil}}</tex>, где каждой вершине сопоставлены значения ее соседей, достижимых за <tex>\frac t 2</tex> шагов.
* Условия: Условия сопоставленные ребру <tex>e=(u,v) \in \mathbf{E}</tex> удовлетворены, если назначения для <tex>u</tex> и <tex>v</tex> согласованы с назначениями, удовлетворяющими условия, порожденные <tex>\frac t 2</tex> соседями <tex>u</tex> и <tex>v</tex>.

Если <tex>UNSAT(G)=0</tex> тогда очевидно <tex>UNSAT(G^t)=0</tex>. Интереснее доказательство того, что <tex>UNSAT(G^t) \ge O(\sqrt{t} \cdot UNSAT(G)</tex>.

{{Лемма
|about=Усиление
|statement= Пусть <tex>\lambda < d</tex> и <tex>|\Sigma|</tex> произвольные константы. Тогда существует константа <tex>\beta_2=\beta_2(\lambda,d,|\Sigma|)>0</rex> такая, что для любого <tex>t \in \mathbb N</tex> и для любого <tex>d</tex>-регулярного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> с собственными циклами и <tex>\lambda(G)\le \lambda</tex>, <tex>UNSAT(G^t) \ge \beta_2 \sqrt{t} \cdot min \left({UNSAT(G), \frac 1 t}\right)</tex>.
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

Поскольку <tex>UNSAT(G) \le \frac 1 t</tex>, из жтой леммы следует что <tex>UNSAT(G^t) \ge O(\sqrt{t}) \cdot UNSAT(G)</tex>. Это основная техническая лемма.
===Композиция===
{{Определение
|about=Тестер присвоений
|definition=Тестер присвоений с алфавитом <tex>\Sigma_0</tex> и вероятностью отклонения <tex>\epsilon > 0</tex> это полиномиальное преобразование <tex>\mathcal{P}</tex>, принимающее на вход схему <tex>\Phi</tex> над будевыми переменными <tex>X</tex> и дающую на выходе граф условий <tex>G=\langle(V,E),\Sigma_0,\mathcal{C}\rangle</tex> такой, что <tex>V \subset X</tex>(в условном графе <tex>V</tex> играет одновременно две роли: переменных и вершин. <tex>Y \subset X</tex> подразумевает, что некоторые вершины из <tex>V</tex> определены с помощью переменных <tex>X</tex>). Пусть <tex>V'=V \setminus X</tex> и <tex>a : X \rightarrow \lbrace 0,1 \rbrace</tex> — присваивание.
* (Полнота) Если <tex>a \in SAT(\Phi)</tex> то существует <tex>b : V' \rightarrow \Sigma_0</tex> такое, что <tex>UNSAT_{a\cup{b}}(G)=0</tex>
* (Обоснованность) Если <tex>a \notin SAT(\Phi)</tex> то для всех <tex>b : V' \rightarrow \Sigma_0</tex>, <tex>UNSAT_{a\cup{b}}(G) \ge \epsilon \cdot dist(a, SAT(\Phi))</tex>.
}}

Следует заметить, что не накладывается никаких ограничений ни на время работы <tex>\mathcal{P}</tex> ни на <tex>size(G)</tex>. Мы игнорируем размер схемы <Tex>\Phi</tex>, которая может быть экспоненциальна относительно <tex>|X|</tex>.

{{Лемма
|about=Композиция
|statement=Пусть существует тестер присвоений <tex>\mathcal{P}</tex> с константной вероятностью отклонения <tex>\epsilon > 0</tex> и алфавитом <tex>\Sigma_0</tex>, <tex>|\Sigma_0|=O(1)</tex>. Тогда существует <tex>\beta_3 > 0</tex>, зависящая только от <tex>\mathcal{P}</tex>, такая что любой граф условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> может быть преобразован в <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex>, обозначаемый <tex>G \circ \mathcal{C}</tex>, такой что <tex>size(G')=M(|\Sigma|) \cdot size(G)</tex> и <tex>\beta_3 \cdot UNSAT(G) \le UNSAT(G') \le UNSAT(G)</tex>
|proof=см. The PCP Theorem by Gap Amplification, Irit Dinur, 2005
}}

==Основная теорема==
Основываясь на операциях с графами условий мы можем доказать основную теорему.
{{Теорема
|about=Основная теорема
|statement=Для любого <tex>\Sigma</tex>, <tex>|\Sigma|=O(1)</tex> существуют константы <tex>C > 0</tex> и <tex>0 < \alpha < 1</tex> такие, что для данного графа условий <tex>G=\langle(V,E),\Sigma,\mathcal{C}\rangle</tex> за полиномиальное время можно построить граф условий <tex>G'=\langle(V',E'),\Sigma_0,\mathcal{C}'\rangle</tex> такой, что:
* <tex>size(G') \le C \cdot size(G)</tex> и <tex>|\Sigma_0| = O(1)</tex>
* (Полнота) Если <tex>UNSAT(G)=0</tex>, то <tex>UNSAT(G')=0</tex>
* (Обоснованность) <tex>UNSAT(G') \ge min(2 \cdot UNSAT(G), \alpha)</tex>
|proof=
Построим <tex>G'</tex> по <tex>G</tex> следующим образом: <tex>G'=(prep(G))^t \circ \mathcal{P}</tex>.
# (Препроцессинг) Пусть <tex>H_1=prep(G)</tex>. Существуют некоторые глобальные константы <tex>\lambda < d </tex> и <tex>\beta_1 >0</tex> такие, что <tex>H_1</tex> <tex>d</tex>-регулярный, имеет тот же алфавит, что и <tex>G</tex>, <tex>\lambda(H_1) \le \lambda < d</tex> и <tex>\beta_1 \cdot UNSAT*G( \le UNSAT(H_1) \le UNSAT(G)</tex>.
# (Усиление) Пусть <tex>H_2=(H_1)^t</tex> для достаточно большой константы <tex> t > 1</tex>, которую определим ниже. Существует некоторая константа <tex>\beta_2=\beta(\lambda, d, |\Sigma|) > 0</tex>, для которой <tex>UNSAT(H_2) \ge \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex>. Однако, алфавит вырос до <tex>\Sigma^{d^{\lceil t / 2 \rceil}}</tex>.
# (Композиция) Пусть <tex>G'=H_2 \circ \mathcal{P}</tex>. Это уменьшит алфавит до <tex>\Sigma_0</tex>, при <tex>\beta_3 \cdot UNSAT(H_2) \le UNSAT(G') \le UNSAT(H_2)</tex> для некоторой <tex>\beta_3 > 0 </tex>.

Проверим выполнение условий теоремы. Размер <tex>G'</tex> линеен относительно размера<tex>G</tex>, поскольку на каждом шагу увеличивался линейно. Полнота явно поддерживается на каждом шаге. Теперь выберем <tex>t=\left\lceil\left({\frac 2 {\beta_1\beta_2\beta_3}}\right)^2\right\rceil</tex>. Пусть <tex>\alpha=\frac {\beta_3\beta_2} {sqrt{t}}</tex>.
Таким образом,

<tex>UNSAT(G') \ge \beta_3 \cdot UNSAT(H_2)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(UNSAT(H_1), \frac 1 t)</tex> <tex>\ge \beta_3 \cdot \beta_2 \sqrt{t} \cdot min(\beta_1 UNSAT(G_, \frac 1 t) </tex> <tex>\ge min(2 \cdot UNSAT(G), \alpha)</tex>
}}
===Доказательство PCP теоремы===
{{Лемма
|statement=Следствием из основной теоремы является <tex>\mathrm{NP}</tex>-трудность <tex>GAP-3SAT_s</tex>.
|proof=Сведем удовлетворимость графа условий к нашей задаче. Пусть <tex>G</tex> задача удовлетворимости некоторого графа с <tex>|\Sigma|=3</tex>. Идей состоит в повторении применения основной теоремы до тех пор, пока число неудовлетворенности не станет постоянным.

Пусть <tex>G_0 = G</tex> и <tex>G_i(i \ge 1)</tex> — результат применения основной теоремы к <tex>G_{i-1}</tex>. Тогда для <tex>i \ge 1</tex> <tex>G</tex> — граф условий с алфавитом <tex>\Sigma_0</tex>. Пусть <tex>E_0</tex> — множество ребер <tex>G_0<tex> и <tex>k=\log|E_0|=O(\log n)</tex>.

Полнота показывается тривиально: если <tex>UNSAT(G_0)=0</tex>, то для всех <tex>i</tex> <tex>UNSAT(G_i)=0</tex>. Для обоснованности рассмотрим <tex>UNSAT(G_0) > 0</tex>. Если для некоторого <tex>i*<k</tex>, <tex>UNSAT(G_{i*}) \ge \frac \alpha 2</tex>, то из основной теоремы следует, что для всех <tex>i>i*</tex> <tex>UNSAT(G_i)\ge \alpha</tex>. На остальные <tex>i</tex> это распространяется по индукции <tex>UNSAT(G_i) \ge min(2^i UNSAT(G_0), \alpha)</tex>.

Если <tex>UNSAT(G_0)>0</tex>, то <tex>UNSAT(G_0)\ge \frac 1 {|E_0|}</tex>. Конечно, <tex>2^k UNSAT(G_0) > \alpha</tex>. Таким образом <tex>UNSAT(G_k) \ge \alpha</tex>.

Такми образом <tex>\rho -GAP2CSP</tex> <tex>\mathrm{NP}</tex>-трудная. Достичь обоснованности <tex>\frac 1 2</tex> можно последовательным повторением <tex>u=\frac 1 {\log(\frac 1 {1 - \alpha})} </tex> раз. Тоесть создать новые условия, представляющие собой <tex>AND</tex> всех возможных <tex>u</tex>-наборов прежних условий. Конечно, при этом количество запросов на условие увеличится до <tex>2u</tex>.

}}

==Дополнительные материалы==
* [http://www.math.ias.edu/boaz/ExpanderCourse/|N. Linial and A. Wigderson. Expander graphs and their applications. Lecture notes of a course, 2003].
* Michael Sipser and Daniel A. Spielman. Expander codes. IEEE Trans. Inform. Theory, 42(6, part 1):1710–1722, 1996. Codes and complexity.
* C. Papadimitriou and M. Yannakakis. Optimization, approximation and complexity classes. Journal of Computer and System Sciences, 3:425–440, 1991.
* Irit Dinur and Omer Reingold. Assignment testers: Towards combinatorial proofs of the PCP theorem. In Proceedings of the 45th Symposium on Foundations of Computer Science (FOCS), 2004.
==Источники==
* [http://eccc.hpi-web.de/report/2005/046 |The PCP Theorem by Gap Amplification, Irit Dinur, 2005].
* [http://www.cs.utah.edu/~alfeld/LecturePDFs/pcp.pdf |The PCP Theorem, Notes by Scott Alfeld, 2008].

Участник:Yurik

2012-12-11T07:43:49Z

194.85.161.34: Новая страница: «Александров Юрий, 2537»

Александров Юрий, 2537

QpmtnriLmax

2012-06-09T08:57:32Z

194.85.161.34: /* Время работы */

<includeonly>[[Категория: В разработке]]</includeonly>

[[Файл:Figure_5.2.png|400px|thumb|right|Рис. 1 - Исходная сеть]]

==Постановка задачи==
Рассмотрим задачу на нахождение расписания:

# У нас есть несколько станков, работающих параллельно. У всех станков разные скорости выполнения работ.
# Есть несколько заданий, каждое имеет своё время появления <tex>r_i</tex> и время окончания <tex>d_i</tex>.
# Работа может быть прервана и продолжена позже.

Требуется минимизировать максимальное опоздание <tex>L_i = C_i - d_i</tex>

==Алгоритм решения==
[[Файл:Figure_5.9.b.png|500px|thumb|right|Рис. 2 - Расширение сети]]

Как в задаче [[PprecriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]] сведем задачу к поиску потока в сети.

Пусть <tex> t_1 \le t_2 \le ... \le t_r </tex> упорядоченная последовательность всех значений <tex>r_i</tex> и <tex>d_i</tex>.
Определим произвольный интервал-узел на исходной сети (Рис. 1) <tex> I_K := [t_{K-1}, t_K], \ T_K = t_K-t_{K-−1} </tex> для <tex> K = 2,..., r </tex>.

Расширим эту сеть. Обозначим через <tex> J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> набор предшественников узла <tex>I_K</tex>, тогда замененная нами подсеть определяется как <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex>.

Расширение сети показано на Рис. 2.

Cчитаем, что станки индексируются в порядке невозрастания скоростей <tex> s_1 \ge s_2 \ge . . . \ge s_m </tex>, кроме того <tex>s_{m+1} = 0</tex>.

Расширенная подсеть строится путем добавления к вершинам <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> вершин <tex>(K, 1), (K, 2), . . . (K, m) </tex>. При <tex>j = 1,..., m </tex>, есть дуги от <tex>(K, j)</tex> до <tex>I_K</tex> с пропускной способностью <tex> j(s_j - s_{j+1}) T_K </tex> и для всех <tex>\nu = 1,. . . , s</tex> и <tex>j = 1,. . ., m</tex> существует дуга из <tex>J_{i_\nu}</tex> в <tex>(K, J)</tex> с пропускной способностью <tex> (s_j - s_{j+1}) T_K </tex>. Это выполняется для каждой вершины <tex>I_K</tex>. Кроме того, мы сохраняем дуги из <tex>s</tex> в <tex>J_i</tex> пропускной способностью <tex>p_i</tex> и дуги из <tex>I_K</tex> в <tex>t</tex> пропускной способностью <tex>S_mT_K</tex> (Рис. 1).

{{Теорема
|statement=Следующие утверждения эквивалентны:

<tex>(a)</tex> Существует допустимое расписание.

<tex>(b)</tex> В расширенной сети существует поток от <tex>s</tex> до <tex>t</tex> со значением <tex>\sum\limits_{i=1}^n p_i</tex>

|proof=<tex>(b) \Rightarrow (a):</tex>
Рассмотрим в расширенной сети поток величиной <tex>\sum\limits_{i = 1}^n {p_i}</tex>. Обозначим через <tex>x_{iK}</tex> общий поток, который идет от <tex>J_i</tex> до <tex>I_K</tex>. Заметим, что <tex>\sum\limits_{i = 1}^n \sum\limits_{K = 2}^r x_{iK} = \sum\limits_{i = 1}^n p_i</tex>. Достаточно показать, что для каждого подмножества <tex>A \subseteq \{ 1, . . . , n \}</tex> выполняется

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> ,где <tex>h(A) =
\begin{cases}
S_{|A|}, & \text{if }|A| \le m \\
S_m, & \text{otherwise}
\end{cases} </tex>.

Это означает, что условие <tex>\sum\limits_{i \in A} p_i \le Th(A), \forall A \subseteq \{ 1, ... , n \}</tex> выполняется и требования к обработке <tex>x_{1K}, . . . , x_{nK}</tex> могут быть запланированы как <tex>I_K</tex> для <tex>K = 2, . . . , r</tex>. Рассмотрим подсеть в расширенной сети в подмножестве <tex>A</tex> и соответствующие части потока. Фрагмент частичного потока, который проходит через <tex>(K, j)</tex> ограничен

<tex>\min \{ j(s_j −- s_{j + 1})T_K, |A|(s_j - s_{j+1})T_K \} = T_K(s_j - s_{j+1}) \min \{ j, |A| \}</tex>.

Таким образом, мы имеем

<tex>\sum\limits_{i \in A} x_{iK} \ge T_K \sum\limits_{j = 1}^m(s_j −- s_{j+1}) \min \{ j, |A| \} = T_Kh(A)</tex>. <tex>(*)</tex>

То, что равенство <tex>(*)</tex> справедливо, может рассматриваться как следствие. Если <tex>|A| > m</tex>, то

<tex>\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - 3s_4 + ... + ms_s - ms_{m+1} =\ </tex>
<tex>S_m = h(A)</tex>.

В противном случае

<tex>\sum\limits_{j = 1} \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - ... + (|A| - 1)s_{|A| - 1} -\ </tex>
<tex>(|A| - 1)s_{|A|} + |A|(s_{|A|} - s_{|A| - 1} - ... - s_m + s_m - s_{m + 1}) = S_{|A|} = h(A)</tex>.

<tex>(a) \Rightarrow (b):</tex>
Предположим, что допустимое расписание существует. Для <tex>i = 1, ... , n </tex> и <tex>K = 2, ..., r</tex> пусть <tex>x_{iK}</tex> является "объемом работ", который будет выполняться в интервале <tex>I_K</tex> в соответствии с нашим возможным расписанием. Тогда для всех <tex>K = 2, ..., r</tex> и произвольных наборов <tex>A \subseteq \{ 1, . . . , n \}</tex>, неравенство

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> <tex>(**)</tex>

выполняется. Кроме того, для <tex>i = 1, . . . , n</tex> у нас <tex>p_i = \sum\limits_{K = 2}^r s_{iK}</tex>. Остается показать, что можно отправить <tex>x_{iK}</tex> от <tex>J_i</tex> до <tex>I_K</tex> <tex>(i = 1, . . . , n; K = 2, . . . , r)</tex> в расширенной сети. Такой поток существует, если <tex>\forall A \subseteq \{ 1, . . . , n \}</tex> и <tex>K = 2, . . . , r</tex> значение <tex>\sum\limits_{i \in A} x_{iK}</tex> ограничено величиной минимального разреза части сети с истоками <tex>J_i(i \in A)</tex> и стоком <tex>I_K</tex>. Тем не менее, это значение

<tex>T_K\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

Используя <tex>(**)</tex> и правую часть <tex>(*)</tex>, получаем

<tex>\sum\limits_{i \in A} x_{iK} \le T_K h(A) = T_K \sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

что и является искомым неравенством.
}}

==Время работы==

Работа с максимальным потоком в расширенной сети занимает <tex>O (m n^3)</tex> шагов, проверка может быть сделана с такой же скоростью. Для решения <tex>Q \mid pmtn; r_{i} \mid L_{max}</tex> мы используем бинарный поиск, а значит, получаем алгоритм с <tex>\varepsilon</tex>-приближенной сложностью <tex>O (mn^3(log(n) + log(1 / \varepsilon) + log(\max\limits_{i=1}^{n} p_i)) </tex>, потому как <tex>L_{max}</tex>, ограничен <tex>n \max\limits_{i=1}^{n}p_i</tex>, при <tex>s_1 = 1</tex>.

Задача <tex>Q \mid pmtn; r_i \mid C_{max}</tex> представляет собой частный случай <tex>Q \mid pmtn; r_i \mid L_{max}</tex>, и может быть решена более эффективно. Лабетоуль (Labetoulle J.), Лаулер (Lawler E.L.), Ленстра (Lenstra. J.K.), и Ринной Кан (Rinnooy Kan A.H.G.) разработали алгоритм работающий за <tex> O(n log(n) + mn) </tex> специально для этого случая.

==Источники==
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8

[[Категория: Теория расписаний]]

QpmtnriLmax

2012-06-09T08:48:25Z

194.85.161.34: /* Алгоритм решения */

<includeonly>[[Категория: В разработке]]</includeonly>

[[Файл:Figure_5.2.png|400px|thumb|right|Рис. 1 - Исходная сеть]]

==Постановка задачи==
Рассмотрим задачу на нахождение расписания:

# У нас есть несколько станков, работающих параллельно. У всех станков разные скорости выполнения работ.
# Есть несколько заданий, каждое имеет своё время появления <tex>r_i</tex> и время окончания <tex>d_i</tex>.
# Работа может быть прервана и продолжена позже.

Требуется минимизировать максимальное опоздание <tex>L_i = C_i - d_i</tex>

==Алгоритм решения==
[[Файл:Figure_5.9.b.png|500px|thumb|right|Рис. 2 - Расширение сети]]

Как в задаче [[PprecriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]] сведем задачу к поиску потока в сети.

Пусть <tex> t_1 \le t_2 \le ... \le t_r </tex> упорядоченная последовательность всех значений <tex>r_i</tex> и <tex>d_i</tex>.
Определим произвольный интервал-узел на исходной сети (Рис. 1) <tex> I_K := [t_{K-1}, t_K], \ T_K = t_K-t_{K-−1} </tex> для <tex> K = 2,..., r </tex>.

Расширим эту сеть. Обозначим через <tex> J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> набор предшественников узла <tex>I_K</tex>, тогда замененная нами подсеть определяется как <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex>.

Расширение сети показано на Рис. 2.

Cчитаем, что станки индексируются в порядке невозрастания скоростей <tex> s_1 \ge s_2 \ge . . . \ge s_m </tex>, кроме того <tex>s_{m+1} = 0</tex>.

Расширенная подсеть строится путем добавления к вершинам <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> вершин <tex>(K, 1), (K, 2), . . . (K, m) </tex>. При <tex>j = 1,..., m </tex>, есть дуги от <tex>(K, j)</tex> до <tex>I_K</tex> с пропускной способностью <tex> j(s_j - s_{j+1}) T_K </tex> и для всех <tex>\nu = 1,. . . , s</tex> и <tex>j = 1,. . ., m</tex> существует дуга из <tex>J_{i_\nu}</tex> в <tex>(K, J)</tex> с пропускной способностью <tex> (s_j - s_{j+1}) T_K </tex>. Это выполняется для каждой вершины <tex>I_K</tex>. Кроме того, мы сохраняем дуги из <tex>s</tex> в <tex>J_i</tex> пропускной способностью <tex>p_i</tex> и дуги из <tex>I_K</tex> в <tex>t</tex> пропускной способностью <tex>S_mT_K</tex> (Рис. 1).

{{Теорема
|statement=Следующие утверждения эквивалентны:

<tex>(a)</tex> Существует допустимое расписание.

<tex>(b)</tex> В расширенной сети существует поток от <tex>s</tex> до <tex>t</tex> со значением <tex>\sum\limits_{i=1}^n p_i</tex>

|proof=<tex>(b) \Rightarrow (a):</tex>
Рассмотрим в расширенной сети поток величиной <tex>\sum\limits_{i = 1}^n {p_i}</tex>. Обозначим через <tex>x_{iK}</tex> общий поток, который идет от <tex>J_i</tex> до <tex>I_K</tex>. Заметим, что <tex>\sum\limits_{i = 1}^n \sum\limits_{K = 2}^r x_{iK} = \sum\limits_{i = 1}^n p_i</tex>. Достаточно показать, что для каждого подмножества <tex>A \subseteq \{ 1, . . . , n \}</tex> выполняется

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> ,где <tex>h(A) =
\begin{cases}
S_{|A|}, & \text{if }|A| \le m \\
S_m, & \text{otherwise}
\end{cases} </tex>.

Это означает, что условие <tex>\sum\limits_{i \in A} p_i \le Th(A), \forall A \subseteq \{ 1, ... , n \}</tex> выполняется и требования к обработке <tex>x_{1K}, . . . , x_{nK}</tex> могут быть запланированы как <tex>I_K</tex> для <tex>K = 2, . . . , r</tex>. Рассмотрим подсеть в расширенной сети в подмножестве <tex>A</tex> и соответствующие части потока. Фрагмент частичного потока, который проходит через <tex>(K, j)</tex> ограничен

<tex>\min \{ j(s_j −- s_{j + 1})T_K, |A|(s_j - s_{j+1})T_K \} = T_K(s_j - s_{j+1}) \min \{ j, |A| \}</tex>.

Таким образом, мы имеем

<tex>\sum\limits_{i \in A} x_{iK} \ge T_K \sum\limits_{j = 1}^m(s_j −- s_{j+1}) \min \{ j, |A| \} = T_Kh(A)</tex>. <tex>(*)</tex>

То, что равенство <tex>(*)</tex> справедливо, может рассматриваться как следствие. Если <tex>|A| > m</tex>, то

<tex>\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - 3s_4 + ... + ms_s - ms_{m+1} =\ </tex>
<tex>S_m = h(A)</tex>.

В противном случае

<tex>\sum\limits_{j = 1} \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - ... + (|A| - 1)s_{|A| - 1} -\ </tex>
<tex>(|A| - 1)s_{|A|} + |A|(s_{|A|} - s_{|A| - 1} - ... - s_m + s_m - s_{m + 1}) = S_{|A|} = h(A)</tex>.

<tex>(a) \Rightarrow (b):</tex>
Предположим, что допустимое расписание существует. Для <tex>i = 1, ... , n </tex> и <tex>K = 2, ..., r</tex> пусть <tex>x_{iK}</tex> является "объемом работ", который будет выполняться в интервале <tex>I_K</tex> в соответствии с нашим возможным расписанием. Тогда для всех <tex>K = 2, ..., r</tex> и произвольных наборов <tex>A \subseteq \{ 1, . . . , n \}</tex>, неравенство

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> <tex>(**)</tex>

выполняется. Кроме того, для <tex>i = 1, . . . , n</tex> у нас <tex>p_i = \sum\limits_{K = 2}^r s_{iK}</tex>. Остается показать, что можно отправить <tex>x_{iK}</tex> от <tex>J_i</tex> до <tex>I_K</tex> <tex>(i = 1, . . . , n; K = 2, . . . , r)</tex> в расширенной сети. Такой поток существует, если <tex>\forall A \subseteq \{ 1, . . . , n \}</tex> и <tex>K = 2, . . . , r</tex> значение <tex>\sum\limits_{i \in A} x_{iK}</tex> ограничено величиной минимального разреза части сети с истоками <tex>J_i(i \in A)</tex> и стоком <tex>I_K</tex>. Тем не менее, это значение

<tex>T_K\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

Используя <tex>(**)</tex> и правую часть <tex>(*)</tex>, получаем

<tex>\sum\limits_{i \in A} x_{iK} \le T_K h(A) = T_K \sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

что и является искомым неравенством.
}}

==Время работы==

Работа с максимальным потоком в расширенной сети занимает <tex>O (m n^3)</tex> шагов, проверка может быть сделана с такой же скоростью. Для решения <tex>Q \mid pmtn; r_{i} \mid L_{max}</tex> мы используем бинарный поиск, а значит, получаем алгоритм с <tex>\varepsilon</tex>-приближенной сложностью <tex>O (mn^3(log(n) + log(1 / \varepsilon) + log(\max\limits_{i=1}^{n} p_i)) </tex>, потому как <tex>L_{max}</tex>, ограничен <tex>n \max\limits_{i=1}^{n}p_i</tex>, при <tex>s_1 = 1</tex>.

Задача <tex>Q \mid pmtn; r_i \mid C_{max}</tex> представляет собой частный случай <tex>Q \mid pmtn; r_i \mid L_{max}</tex>, и может быть решена более эффективно. Labetoulle, Lawler, Lenstra, и Rinnooy Kan разработали алгоритм работающий за <tex> O(n log(n) + mn) </tex> специально для этого случая.

==Источники==
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8

[[Категория: Теория расписаний]]

QpmtnriLmax

2012-06-09T08:46:36Z

194.85.161.34: /* Алгоритм решения */

<includeonly>[[Категория: В разработке]]</includeonly>

[[Файл:Figure_5.2.png|400px|thumb|right|Рис. 1 - Исходная сеть]]

==Постановка задачи==
Рассмотрим задачу на нахождение расписания:

# У нас есть несколько станков, работающих параллельно. У всех станков разные скорости выполнения работ.
# Есть несколько заданий, каждое имеет своё время появления <tex>r_i</tex> и время окончания <tex>d_i</tex>.
# Работа может быть прервана и продолжена позже.

Требуется минимизировать максимальное опоздание <tex>L_i = C_i - d_i</tex>

==Алгоритм решения==
[[Файл:Figure_5.9.b.png|500px|thumb|right|Рис. 2 - Расширение сети]]

Как в задаче [[PprecriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]] сведем задачу к поиску потока в сети.

Пусть <tex> t_1 < t_2 <...< t_r </tex> упорядоченная последовательность всех значений <tex>r_i</tex> и <tex>d_i</tex>.
Определим произвольный интервал-узел на исходной сети (Рис. 1) <tex> I_K := [t_{K-1}, t_K], \ T_K = t_K-t_{K-−1} </tex> для <tex> K = 2,..., r </tex>.

Расширим эту сеть. Обозначим через <tex> J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> набор предшественников узла <tex>I_K</tex>, тогда замененная нами подсеть определяется как <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex>.

Расширение сети показано на Рис. 2.

Cчитаем, что станки индексируются в порядке невозрастания скоростей <tex> s_1 \ge s_2 \ge . . . \ge s_m </tex>, кроме того <tex>s_{m+1} = 0</tex>.

Расширенная подсеть строится путем добавления к вершинам <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> вершин <tex>(K, 1), (K, 2), . . . (K, m) </tex>. При <tex>j = 1,..., m </tex>, есть дуги от <tex>(K, j)</tex> до <tex>I_K</tex> с пропускной способностью <tex> j(s_j - s_{j+1}) T_K </tex> и для всех <tex>\nu = 1,. . . , s</tex> и <tex>j = 1,. . ., m</tex> существует дуга из <tex>J_{i_\nu}</tex> в <tex>(K, J)</tex> с пропускной способностью <tex> (s_j - s_{j+1}) T_K </tex>. Это выполняется для каждой вершины <tex>I_K</tex>. Кроме того, мы сохраняем дуги из <tex>s</tex> в <tex>J_i</tex> пропускной способностью <tex>p_i</tex> и дуги из <tex>I_K</tex> в <tex>t</tex> пропускной способностью <tex>S_mT_K</tex> (Рис. 1).

{{Теорема
|statement=Следующие утверждения эквивалентны:

<tex>(a)</tex> Существует допустимое расписание.

<tex>(b)</tex> В расширенной сети существует поток от <tex>s</tex> до <tex>t</tex> со значением <tex>\sum\limits_{i=1}^n p_i</tex>

|proof=<tex>(b) \Rightarrow (a):</tex>
Рассмотрим в расширенной сети поток величиной <tex>\sum\limits_{i = 1}^n {p_i}</tex>. Обозначим через <tex>x_{iK}</tex> общий поток, который идет от <tex>J_i</tex> до <tex>I_K</tex>. Заметим, что <tex>\sum\limits_{i = 1}^n \sum\limits_{K = 2}^r x_{iK} = \sum\limits_{i = 1}^n p_i</tex>. Достаточно показать, что для каждого подмножества <tex>A \subseteq \{ 1, . . . , n \}</tex> выполняется

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> ,где <tex>h(A) =
\begin{cases}
S_{|A|}, & \text{if }|A| \le m \\
S_m, & \text{otherwise}
\end{cases} </tex>.

Это означает, что условие <tex>\sum\limits_{i \in A} p_i \le Th(A), \forall A \subseteq \{ 1, ... , n \}</tex> выполняется и требования к обработке <tex>x_{1K}, . . . , x_{nK}</tex> могут быть запланированы как <tex>I_K</tex> для <tex>K = 2, . . . , r</tex>. Рассмотрим подсеть в расширенной сети в подмножестве <tex>A</tex> и соответствующие части потока. Фрагмент частичного потока, который проходит через <tex>(K, j)</tex> ограничен

<tex>\min \{ j(s_j −- s_{j + 1})T_K, |A|(s_j - s_{j+1})T_K \} = T_K(s_j - s_{j+1}) \min \{ j, |A| \}</tex>.

Таким образом, мы имеем

<tex>\sum\limits_{i \in A} x_{iK} \ge T_K \sum\limits_{j = 1}^m(s_j −- s_{j+1}) \min \{ j, |A| \} = T_Kh(A)</tex>. <tex>(*)</tex>

То, что равенство <tex>(*)</tex> справедливо, может рассматриваться как следствие. Если <tex>|A| > m</tex>, то

<tex>\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - 3s_4 + ... + ms_s - ms_{m+1} =\ </tex>
<tex>S_m = h(A)</tex>.

В противном случае

<tex>\sum\limits_{j = 1} \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - ... + (|A| - 1)s_{|A| - 1} -\ </tex>
<tex>(|A| - 1)s_{|A|} + |A|(s_{|A|} - s_{|A| - 1} - ... - s_m + s_m - s_{m + 1}) = S_{|A|} = h(A)</tex>.

<tex>(a) \Rightarrow (b):</tex>
Предположим, что допустимое расписание существует. Для <tex>i = 1, ... , n </tex> и <tex>K = 2, ..., r</tex> пусть <tex>x_{iK}</tex> является "объемом работ", который будет выполняться в интервале <tex>I_K</tex> в соответствии с нашим возможным расписанием. Тогда для всех <tex>K = 2, ..., r</tex> и произвольных наборов <tex>A \subseteq \{ 1, . . . , n \}</tex>, неравенство

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> <tex>(**)</tex>

выполняется. Кроме того, для <tex>i = 1, . . . , n</tex> у нас <tex>p_i = \sum\limits_{K = 2}^r s_{iK}</tex>. Остается показать, что можно отправить <tex>x_{iK}</tex> от <tex>J_i</tex> до <tex>I_K</tex> <tex>(i = 1, . . . , n; K = 2, . . . , r)</tex> в расширенной сети. Такой поток существует, если <tex>\forall A \subseteq \{ 1, . . . , n \}</tex> и <tex>K = 2, . . . , r</tex> значение <tex>\sum\limits_{i \in A} x_{iK}</tex> ограничено величиной минимального разреза части сети с истоками <tex>J_i(i \in A)</tex> и стоком <tex>I_K</tex>. Тем не менее, это значение

<tex>T_K\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

Используя <tex>(**)</tex> и правую часть <tex>(*)</tex>, получаем

<tex>\sum\limits_{i \in A} x_{iK} \le T_K h(A) = T_K \sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

что и является искомым неравенством.
}}

==Время работы==

Работа с максимальным потоком в расширенной сети занимает <tex>O (m n^3)</tex> шагов, проверка может быть сделана с такой же скоростью. Для решения <tex>Q \mid pmtn; r_{i} \mid L_{max}</tex> мы используем бинарный поиск, а значит, получаем алгоритм с <tex>\varepsilon</tex>-приближенной сложностью <tex>O (mn^3(log(n) + log(1 / \varepsilon) + log(\max\limits_{i=1}^{n} p_i)) </tex>, потому как <tex>L_{max}</tex>, ограничен <tex>n \max\limits_{i=1}^{n}p_i</tex>, при <tex>s_1 = 1</tex>.

Задача <tex>Q \mid pmtn; r_i \mid C_{max}</tex> представляет собой частный случай <tex>Q \mid pmtn; r_i \mid L_{max}</tex>, и может быть решена более эффективно. Labetoulle, Lawler, Lenstra, и Rinnooy Kan разработали алгоритм работающий за <tex> O(n log(n) + mn) </tex> специально для этого случая.

==Источники==
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8

[[Категория: Теория расписаний]]

QpmtnriLmax

2012-06-09T08:45:22Z

194.85.161.34: /* Время работы */

<includeonly>[[Категория: В разработке]]</includeonly>

[[Файл:Figure_5.2.png|400px|thumb|right|Рис. 1 - Исходная сеть]]

==Постановка задачи==
Рассмотрим задачу на нахождение расписания:

# У нас есть несколько станков, работающих параллельно. У всех станков разные скорости выполнения работ.
# Есть несколько заданий, каждое имеет своё время появления <tex>r_i</tex> и время окончания <tex>d_i</tex>.
# Работа может быть прервана и продолжена позже.

Требуется минимизировать максимальное опоздание <tex>L_i = C_i - d_i</tex>

==Алгоритм решения==
[[Файл:Figure_5.9.b.png|500px|thumb|right|Рис. 2 - Расширение сети]]

Как в задаче [[PprecriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]] сведем задачу к поиску потока сети.

Пусть <tex> t_1 < t_2 <...< t_r </tex> упорядоченная последовательность всех значений <tex>r_i</tex> и <tex>d_i</tex>.
Определим произвольный интервал-узел на исходной сети (Рис. 1) <tex> I_K := [t_{K-1}, t_K], \ T_K = t_K-t_{K-−1} </tex> для <tex> K = 2,..., r </tex>.

Расширим эту сеть. Обозначим через <tex> J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> набор предшественников узла <tex>I_K</tex>, тогда замененная нами подсеть определяется как <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex>.

Расширение сети показано на Рис. 2.

Cчитаем, что станки индексируются в порядке невозрастания скоростей <tex> s_1 \ge s_2 \ge . . . \ge s_m </tex>, кроме того <tex>s_{m+1} = 0</tex>.

Расширенная подсеть строится путем добавления к вершинам <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> вершин <tex>(K, 1), (K, 2), . . . (K, m) </tex>. При <tex>j = 1,..., m </tex>, есть дуги от <tex>(K, j)</tex> до <tex>I_K</tex> с пропускной способностью <tex> j(s_j - s_{j+1}) T_K </tex> и для всех <tex>\nu = 1,. . . , s</tex> и <tex>j = 1,. . ., m</tex> существует дуга из <tex>J_{i_\nu}</tex> в <tex>(K, J)</tex> с пропускной способностью <tex> (s_j - s_{j+1}) T_K </tex>. Это выполняется для каждой вершины <tex>I_K</tex>. Кроме того, мы сохраняем дуги из <tex>s</tex> в <tex>J_i</tex> пропускной способностью <tex>p_i</tex> и дуги из <tex>I_K</tex> в <tex>t</tex> пропускной способностью <tex>S_mT_K</tex> (Рис. 1).

{{Теорема
|statement=Следующие утверждения эквивалентны:

<tex>(a)</tex> Существует допустимое расписание.

<tex>(b)</tex> В расширенной сети существует поток от <tex>s</tex> до <tex>t</tex> со значением <tex>\sum\limits_{i=1}^n p_i</tex>

|proof=<tex>(b) \Rightarrow (a):</tex>
Рассмотрим в расширенной сети поток величиной <tex>\sum\limits_{i = 1}^n {p_i}</tex>. Обозначим через <tex>x_{iK}</tex> общий поток, который идет от <tex>J_i</tex> до <tex>I_K</tex>. Заметим, что <tex>\sum\limits_{i = 1}^n \sum\limits_{K = 2}^r x_{iK} = \sum\limits_{i = 1}^n p_i</tex>. Достаточно показать, что для каждого подмножества <tex>A \subseteq \{ 1, . . . , n \}</tex> выполняется

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> ,где <tex>h(A) =
\begin{cases}
S_{|A|}, & \text{if }|A| \le m \\
S_m, & \text{otherwise}
\end{cases} </tex>.

Это означает, что условие <tex>\sum\limits_{i \in A} p_i \le Th(A), \forall A \subseteq \{ 1, ... , n \}</tex> выполняется и требования к обработке <tex>x_{1K}, . . . , x_{nK}</tex> могут быть запланированы как <tex>I_K</tex> для <tex>K = 2, . . . , r</tex>. Рассмотрим подсеть в расширенной сети в подмножестве <tex>A</tex> и соответствующие части потока. Фрагмент частичного потока, который проходит через <tex>(K, j)</tex> ограничен

<tex>\min \{ j(s_j −- s_{j + 1})T_K, |A|(s_j - s_{j+1})T_K \} = T_K(s_j - s_{j+1}) \min \{ j, |A| \}</tex>.

Таким образом, мы имеем

<tex>\sum\limits_{i \in A} x_{iK} \ge T_K \sum\limits_{j = 1}^m(s_j −- s_{j+1}) \min \{ j, |A| \} = T_Kh(A)</tex>. <tex>(*)</tex>

То, что равенство <tex>(*)</tex> справедливо, может рассматриваться как следствие. Если <tex>|A| > m</tex>, то

<tex>\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - 3s_4 + ... + ms_s - ms_{m+1} =\ </tex>
<tex>S_m = h(A)</tex>.

В противном случае

<tex>\sum\limits_{j = 1} \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - ... + (|A| - 1)s_{|A| - 1} -\ </tex>
<tex>(|A| - 1)s_{|A|} + |A|(s_{|A|} - s_{|A| - 1} - ... - s_m + s_m - s_{m + 1}) = S_{|A|} = h(A)</tex>.

<tex>(a) \Rightarrow (b):</tex>
Предположим, что допустимое расписание существует. Для <tex>i = 1, ... , n </tex> и <tex>K = 2, ..., r</tex> пусть <tex>x_{iK}</tex> является "объемом работ", который будет выполняться в интервале <tex>I_K</tex> в соответствии с нашим возможным расписанием. Тогда для всех <tex>K = 2, ..., r</tex> и произвольных наборов <tex>A \subseteq \{ 1, . . . , n \}</tex>, неравенство

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> <tex>(**)</tex>

выполняется. Кроме того, для <tex>i = 1, . . . , n</tex> у нас <tex>p_i = \sum\limits_{K = 2}^r s_{iK}</tex>. Остается показать, что можно отправить <tex>x_{iK}</tex> от <tex>J_i</tex> до <tex>I_K</tex> <tex>(i = 1, . . . , n; K = 2, . . . , r)</tex> в расширенной сети. Такой поток существует, если <tex>\forall A \subseteq \{ 1, . . . , n \}</tex> и <tex>K = 2, . . . , r</tex> значение <tex>\sum\limits_{i \in A} x_{iK}</tex> ограничено величиной минимального разреза части сети с истоками <tex>J_i(i \in A)</tex> и стоком <tex>I_K</tex>. Тем не менее, это значение

<tex>T_K\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

Используя <tex>(**)</tex> и правую часть <tex>(*)</tex>, получаем

<tex>\sum\limits_{i \in A} x_{iK} \le T_K h(A) = T_K \sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

что и является искомым неравенством.
}}

==Время работы==

Работа с максимальным потоком в расширенной сети занимает <tex>O (m n^3)</tex> шагов, проверка может быть сделана с такой же скоростью. Для решения <tex>Q \mid pmtn; r_{i} \mid L_{max}</tex> мы используем бинарный поиск, а значит, получаем алгоритм с <tex>\varepsilon</tex>-приближенной сложностью <tex>O (mn^3(log(n) + log(1 / \varepsilon) + log(\max\limits_{i=1}^{n} p_i)) </tex>, потому как <tex>L_{max}</tex>, ограничен <tex>n \max\limits_{i=1}^{n}p_i</tex>, при <tex>s_1 = 1</tex>.

Задача <tex>Q \mid pmtn; r_i \mid C_{max}</tex> представляет собой частный случай <tex>Q \mid pmtn; r_i \mid L_{max}</tex>, и может быть решена более эффективно. Labetoulle, Lawler, Lenstra, и Rinnooy Kan разработали алгоритм работающий за <tex> O(n log(n) + mn) </tex> специально для этого случая.

==Источники==
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8

[[Категория: Теория расписаний]]

QpmtnriLmax

2012-06-09T08:43:08Z

194.85.161.34: /* Алгоритм решения */

<includeonly>[[Категория: В разработке]]</includeonly>

[[Файл:Figure_5.2.png|400px|thumb|right|Рис. 1 - Исходная сеть]]

==Постановка задачи==
Рассмотрим задачу на нахождение расписания:

# У нас есть несколько станков, работающих параллельно. У всех станков разные скорости выполнения работ.
# Есть несколько заданий, каждое имеет своё время появления <tex>r_i</tex> и время окончания <tex>d_i</tex>.
# Работа может быть прервана и продолжена позже.

Требуется минимизировать максимальное опоздание <tex>L_i = C_i - d_i</tex>

==Алгоритм решения==
[[Файл:Figure_5.9.b.png|500px|thumb|right|Рис. 2 - Расширение сети]]

Как в задаче [[PprecriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]] сведем задачу к поиску потока сети.

Пусть <tex> t_1 < t_2 <...< t_r </tex> упорядоченная последовательность всех значений <tex>r_i</tex> и <tex>d_i</tex>.
Определим произвольный интервал-узел на исходной сети (Рис. 1) <tex> I_K := [t_{K-1}, t_K], \ T_K = t_K-t_{K-−1} </tex> для <tex> K = 2,..., r </tex>.

Расширим эту сеть. Обозначим через <tex> J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> набор предшественников узла <tex>I_K</tex>, тогда замененная нами подсеть определяется как <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex>.

Расширение сети показано на Рис. 2.

Cчитаем, что станки индексируются в порядке невозрастания скоростей <tex> s_1 \ge s_2 \ge . . . \ge s_m </tex>, кроме того <tex>s_{m+1} = 0</tex>.

Расширенная подсеть строится путем добавления к вершинам <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> вершин <tex>(K, 1), (K, 2), . . . (K, m) </tex>. При <tex>j = 1,..., m </tex>, есть дуги от <tex>(K, j)</tex> до <tex>I_K</tex> с пропускной способностью <tex> j(s_j - s_{j+1}) T_K </tex> и для всех <tex>\nu = 1,. . . , s</tex> и <tex>j = 1,. . ., m</tex> существует дуга из <tex>J_{i_\nu}</tex> в <tex>(K, J)</tex> с пропускной способностью <tex> (s_j - s_{j+1}) T_K </tex>. Это выполняется для каждой вершины <tex>I_K</tex>. Кроме того, мы сохраняем дуги из <tex>s</tex> в <tex>J_i</tex> пропускной способностью <tex>p_i</tex> и дуги из <tex>I_K</tex> в <tex>t</tex> пропускной способностью <tex>S_mT_K</tex> (Рис. 1).

{{Теорема
|statement=Следующие утверждения эквивалентны:

<tex>(a)</tex> Существует допустимое расписание.

<tex>(b)</tex> В расширенной сети существует поток от <tex>s</tex> до <tex>t</tex> со значением <tex>\sum\limits_{i=1}^n p_i</tex>

|proof=<tex>(b) \Rightarrow (a):</tex>
Рассмотрим в расширенной сети поток величиной <tex>\sum\limits_{i = 1}^n {p_i}</tex>. Обозначим через <tex>x_{iK}</tex> общий поток, который идет от <tex>J_i</tex> до <tex>I_K</tex>. Заметим, что <tex>\sum\limits_{i = 1}^n \sum\limits_{K = 2}^r x_{iK} = \sum\limits_{i = 1}^n p_i</tex>. Достаточно показать, что для каждого подмножества <tex>A \subseteq \{ 1, . . . , n \}</tex> выполняется

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> ,где <tex>h(A) =
\begin{cases}
S_{|A|}, & \text{if }|A| \le m \\
S_m, & \text{otherwise}
\end{cases} </tex>.

Это означает, что условие <tex>\sum\limits_{i \in A} p_i \le Th(A), \forall A \subseteq \{ 1, ... , n \}</tex> выполняется и требования к обработке <tex>x_{1K}, . . . , x_{nK}</tex> могут быть запланированы как <tex>I_K</tex> для <tex>K = 2, . . . , r</tex>. Рассмотрим подсеть в расширенной сети в подмножестве <tex>A</tex> и соответствующие части потока. Фрагмент частичного потока, который проходит через <tex>(K, j)</tex> ограничен

<tex>\min \{ j(s_j −- s_{j + 1})T_K, |A|(s_j - s_{j+1})T_K \} = T_K(s_j - s_{j+1}) \min \{ j, |A| \}</tex>.

Таким образом, мы имеем

<tex>\sum\limits_{i \in A} x_{iK} \ge T_K \sum\limits_{j = 1}^m(s_j −- s_{j+1}) \min \{ j, |A| \} = T_Kh(A)</tex>. <tex>(*)</tex>

То, что равенство <tex>(*)</tex> справедливо, может рассматриваться как следствие. Если <tex>|A| > m</tex>, то

<tex>\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - 3s_4 + ... + ms_s - ms_{m+1} =\ </tex>
<tex>S_m = h(A)</tex>.

В противном случае

<tex>\sum\limits_{j = 1} \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - ... + (|A| - 1)s_{|A| - 1} -\ </tex>
<tex>(|A| - 1)s_{|A|} + |A|(s_{|A|} - s_{|A| - 1} - ... - s_m + s_m - s_{m + 1}) = S_{|A|} = h(A)</tex>.

<tex>(a) \Rightarrow (b):</tex>
Предположим, что допустимое расписание существует. Для <tex>i = 1, ... , n </tex> и <tex>K = 2, ..., r</tex> пусть <tex>x_{iK}</tex> является "объемом работ", который будет выполняться в интервале <tex>I_K</tex> в соответствии с нашим возможным расписанием. Тогда для всех <tex>K = 2, ..., r</tex> и произвольных наборов <tex>A \subseteq \{ 1, . . . , n \}</tex>, неравенство

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> <tex>(**)</tex>

выполняется. Кроме того, для <tex>i = 1, . . . , n</tex> у нас <tex>p_i = \sum\limits_{K = 2}^r s_{iK}</tex>. Остается показать, что можно отправить <tex>x_{iK}</tex> от <tex>J_i</tex> до <tex>I_K</tex> <tex>(i = 1, . . . , n; K = 2, . . . , r)</tex> в расширенной сети. Такой поток существует, если <tex>\forall A \subseteq \{ 1, . . . , n \}</tex> и <tex>K = 2, . . . , r</tex> значение <tex>\sum\limits_{i \in A} x_{iK}</tex> ограничено величиной минимального разреза части сети с истоками <tex>J_i(i \in A)</tex> и стоком <tex>I_K</tex>. Тем не менее, это значение

<tex>T_K\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

Используя <tex>(**)</tex> и правую часть <tex>(*)</tex>, получаем

<tex>\sum\limits_{i \in A} x_{iK} \le T_K h(A) = T_K \sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

что и является искомым неравенством.
}}

==Время работы==

Работа с максимальным потоком в расширенной сети занимает <tex>O (m n^3)</tex> шагов, проверка может быть сделана с такой же скоростью. Для решения <tex>Q \mid pmtn; r_{i} \mid L_{max}</tex> мы используем бинарный поиск, значит получаем алгоритм с <tex>\varepsilon</tex>-приближенной сложностью <tex>O (mn^3(log(n) + log(1 / \varepsilon) + log(\max\limits_{i=1}^{n} p_i)) </tex>, потому как <tex>L_{max}</tex>, ограничен <tex>n \max\limits_{i=1}^{n}p_i</tex>, при <tex>s_1 = 1</tex>.

Задача <tex>Q \mid pmtn; r_i \mid C_{max}</tex> представляет собой частный случай <tex>Q \mid pmtn; r_i \mid L_{max}</tex>, и может быть решена более эффективно. Labetoulle, Lawler, Lenstra, и Rinnooy Kan разработали алгоритм работающий за <tex> O(n log(n) + mn) </tex> специально для этого случая.

==Источники==
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8

[[Категория: Теория расписаний]]

QpmtnriLmax

2012-06-09T08:41:26Z

194.85.161.34: /* Алгоритм решения */

<includeonly>[[Категория: В разработке]]</includeonly>

[[Файл:Figure_5.2.png|400px|thumb|right|Рис. 1 - Исходная сеть]]

==Постановка задачи==
Рассмотрим задачу на нахождение расписания:

# У нас есть несколько станков, работающих параллельно. У всех станков разные скорости выполнения работ.
# Есть несколько заданий, каждое имеет своё время появления <tex>r_i</tex> и время окончания <tex>d_i</tex>.
# Работа может быть прервана и продолжена позже.

Требуется минимизировать максимальное опоздание <tex>L_i = C_i - d_i</tex>

==Алгоритм решения==
[[Файл:Figure_5.9.b.png|500px|thumb|right|Рис. 2 - Расширение сети]]

Как в задаче [[PprecriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]] сведем задачу к поиску потока сети.

Пусть <tex> t_1 < t_2 <...< t_r </tex> упорядоченная последовательность всех значений <tex>r_i</tex> и <tex>d_i</tex>.
Определим произвольный интервал-узел на исходной сети (Рис. 1) <tex> I_K := [t_{K-1}, t_K], \ T_K = t_K-t_{K-−1} </tex> для <tex> K = 2,..., r </tex>.

Расширим эту сеть. Обозначим через <tex> J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> набор предшественников узла <tex>I_K</tex>, тогда замененная нами подсеть определяется как <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex>.

Расширение сети показано на Рис. 2.

Cчитаем, что станки индексируются в порядке невозрастания скоростей <tex> s_1 \ge s_2 \ge . . . \ge s_m </tex>, кроме того <tex>s_{m+1} = 0</tex>.

Расширенная подсеть строится путем добавления к вершинам <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> вершин <tex>(K, 1), (K, 2), . . . (K, m) </tex>. При <tex>j = 1,..., m </tex>, есть дуги от <tex>(K, j)</tex> до <tex>I_K</tex> с пропускной способностью <tex> j(s_j - s_{j+1}) T_K </tex> и для всех <tex>\nu = 1,. . . , s</tex> и <tex>j = 1,. . ., m</tex> существует дуга из <tex>J_{i_\nu}</tex> в <tex>(K, J)</tex> с пропускной способностью <tex> (s_j - s_{j+1}) T_K </tex>. Это выполняется для каждой вершины <tex>I_K</tex>. Кроме того, мы сохраняем дуги из <tex>s</tex> в <tex>J_i</tex> пропускной способностью <tex>p_i</tex> и дуги из <tex>I_K</tex> в <tex>t</tex> пропускной способностью <tex>S_mT_K</tex> (Рис. 1).

{{Теорема
|statement=Следующие свойства эквивалентны:

<tex>(a)</tex> Существует допустимое расписание.

<tex>(b)</tex> В расширенной сети существует поток от <tex>s</tex> до <tex>t</tex> со значением <tex>\sum\limits_{i=1}^n p_i</tex>

|proof=<tex>(b) \Rightarrow (a):</tex>
Рассмотрим в расширенной сети поток величиной <tex>\sum\limits_{i = 1}^n {p_i}</tex>. Обозначим через <tex>x_{iK}</tex> общий поток, который идет от <tex>J_i</tex> до <tex>I_K</tex>. Заметим, что <tex>\sum\limits_{i = 1}^n \sum\limits_{K = 2}^r x_{iK} = \sum\limits_{i = 1}^n p_i</tex>. Достаточно показать, что для каждого подмножества <tex>A \subseteq \{ 1, . . . , n \}</tex> выполняется

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> ,где <tex>h(A) =
\begin{cases}
S_{|A|}, & \text{if }|A| \le m \\
S_m, & \text{otherwise}
\end{cases} </tex>.

Это означает, что условие <tex>\sum\limits_{i \in A} p_i \le Th(A), \forall A \subseteq \{ 1, ... , n \}</tex> выполняется и требования к обработке <tex>x_{1K}, . . . , x_{nK}</tex> могут быть запланированы как <tex>I_K</tex> для <tex>K = 2, . . . , r</tex>. Рассмотрим подсеть в расширенной сети в подмножестве <tex>A</tex> и соответствующие части потока. Фрагмент частичного потока, который проходит через <tex>(K, j)</tex> ограничен

<tex>\min \{ j(s_j −- s_{j + 1})T_K, |A|(s_j - s_{j+1})T_K \} = T_K(s_j - s_{j+1}) \min \{ j, |A| \}</tex>.

Таким образом, мы имеем

<tex>\sum\limits_{i \in A} x_{iK} \ge T_K \sum\limits_{j = 1}^m(s_j −- s_{j+1}) \min \{ j, |A| \} = T_Kh(A)</tex>. <tex>(*)</tex>

То, что равенство <tex>(*)</tex> справедливо, может рассматриваться как следствие. Если <tex>|A| > m</tex>, то

<tex>\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - 3s_4 + ... + ms_s - ms_{m+1} =\ </tex>
<tex>S_m = h(A)</tex>.

В противном случае

<tex>\sum\limits_{j = 1} \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - ... + (|A| - 1)s_{|A| - 1} -\ </tex>
<tex>(|A| - 1)s_{|A|} + |A|(s_{|A|} - s_{|A| - 1} - ... - s_m + s_m - s_{m + 1}) = S_{|A|} = h(A)</tex>.

<tex>(a) \Rightarrow (b):</tex>
Предположим, что допустимое расписание существует. Для <tex>i = 1, ... , n </tex> и <tex>K = 2, ..., r</tex> пусть <tex>x_{iK}</tex> является "объемом работ", который будет выполняться в интервале <tex>I_K</tex> в соответствии с нашим возможным расписанием. Тогда для всех <tex>K = 2, ..., r</tex> и произвольных наборов <tex>A \subseteq \{ 1, . . . , n \}</tex>, неравенство

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> <tex>(**)</tex>

выполняется. Кроме того, для <tex>i = 1, . . . , n</tex> у нас <tex>p_i = \sum\limits_{K = 2}^r s_{iK}</tex>. Остается показать, что можно отправить <tex>x_{iK}</tex> от <tex>J_i</tex> до <tex>I_K</tex> <tex>(i = 1, . . . , n; K = 2, . . . , r)</tex> в расширенной сети. Такой поток существует, если <tex>\forall A \subseteq \{ 1, . . . , n \}</tex> и <tex>K = 2, . . . , r</tex> значение <tex>\sum\limits_{i \in A} x_{iK}</tex> ограничено величиной минимального разреза части сети с истоками <tex>J_i(i \in A)</tex> и стоком <tex>I_K</tex>. Тем не менее, это значение

<tex>T_K\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

Используя <tex>(**)</tex> и правую часть <tex>(*)</tex>, получаем

<tex>\sum\limits_{i \in A} x_{iK} \le T_K h(A) = T_K \sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

что и является искомым неравенством.
}}

==Время работы==

Работа с максимальным потоком в расширенной сети занимает <tex>O (m n^3)</tex> шагов, проверка может быть сделана с такой же скоростью. Для решения <tex>Q \mid pmtn; r_{i} \mid L_{max}</tex> мы используем бинарный поиск, значит получаем алгоритм с <tex>\varepsilon</tex>-приближенной сложностью <tex>O (mn^3(log(n) + log(1 / \varepsilon) + log(\max\limits_{i=1}^{n} p_i)) </tex>, потому как <tex>L_{max}</tex>, ограничен <tex>n \max\limits_{i=1}^{n}p_i</tex>, при <tex>s_1 = 1</tex>.

Задача <tex>Q \mid pmtn; r_i \mid C_{max}</tex> представляет собой частный случай <tex>Q \mid pmtn; r_i \mid L_{max}</tex>, и может быть решена более эффективно. Labetoulle, Lawler, Lenstra, и Rinnooy Kan разработали алгоритм работающий за <tex> O(n log(n) + mn) </tex> специально для этого случая.

==Источники==
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8

[[Категория: Теория расписаний]]

QpmtnriLmax

2012-06-09T08:10:16Z

194.85.161.34: /* Время работы */

<includeonly>[[Категория: В разработке]]</includeonly>

[[Файл:Figure_5.2.png|400px|thumb|right|Рис. 1 - Исходная сеть]]

==Постановка задачи==
Рассмотрим задачу на нахождение расписания:

# У нас есть несколько станков, работающих параллельно. У всех станков разные скорости выполнения работ.
# Есть несколько заданий, каждое имеет своё время появления <tex>r_i</tex> и время окончания <tex>d_i</tex>.
# Работа может быть прервана и продолжена позже.

Требуется минимизировать максимальное опоздание <tex>L_i = C_i - d_i</tex>

==Алгоритм решения==
[[Файл:Figure_5.9.b.png|500px|thumb|right|Рис. 2 - Расширение сети]]

Как в задаче [[PprecriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]] сведем задачу к поиску потока сети. Также будем использовать бинарный поиск.

Пусть <tex> t_1 < t_2 <...< t_r </tex> упорядоченная последовательность всех значений <tex>r_i</tex> и <tex>d_i</tex>.
Определим произвольный интервал-узел на исходной сети (Рис. 1) <tex> I_K := [t_{K-1}, t_K], \ T_K = t_K-t_{K-−1} </tex> для <tex> K = 2,..., r </tex>.

Расширим эту сеть. Обозначим через <tex> J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> набор предшественников узла <tex>I_K</tex>, тогда замененная нами подсеть определяется как <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex>.

Расширение сети показано на Рис. 2.

Cчитаем, что станки индексируются в порядке невозрастания скоростей <tex> s_1 \ge s_2 \ge . . . \ge s_m </tex>, кроме того <tex>s_{m+1} = 0</tex>.

Расширенная подсеть строится путем добавления к вершинам <tex> I_K, J_{i_1}, J_{i_2}, . . . , J_{i_s} </tex> вершин <tex>(K, 1), (K, 2), . . . (K, m) </tex>. При <tex>j = 1,..., m </tex>, есть дуги от <tex>(K, j)</tex> до <tex>I_K</tex> с пропускной способностью <tex> j(s_j - s_{j+1}) T_K </tex> и для всех <tex>\nu = 1,. . . , s</tex> и <tex>j = 1,. . ., m</tex> существует дуга из <tex>J_{i_\nu}</tex> в <tex>(K, J)</tex> с пропускной способностью <tex> (s_j - s_{j+1}) T_K </tex>. Это выполняется для каждой вершины <tex>I_K</tex>. Кроме того, мы сохраняем дуги из <tex>s</tex> в <tex>J_i</tex> пропускной способностью <tex>p_i</tex> и дуги из <tex>I_K</tex> в <tex>t</tex> пропускной способностью <tex>S_mT_K</tex> (Рис. 1).

{{Теорема
|statement=Следующие свойства эквивалентны:

<tex>(a)</tex> Существует допустимое расписание.

<tex>(b)</tex> В расширенной сети существует поток от <tex>s</tex> до <tex>t</tex> со значением <tex>\sum\limits_{i=1}^n p_i</tex>

|proof=<tex>(b) \Rightarrow (a):</tex>
Рассмотрим в расширенной сети поток величиной <tex>\sum\limits_{i = 1}^n {p_i}</tex>. Обозначим через <tex>x_{iK}</tex> общий поток, который идет от <tex>J_i</tex> до <tex>I_K</tex>. Заметим, что <tex>\sum\limits_{i = 1}^n \sum\limits_{K = 2}^r x_{iK} = \sum\limits_{i = 1}^n p_i</tex>. Достаточно показать, что для каждого подмножества <tex>A \subseteq \{ 1, . . . , n \}</tex> выполняется

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> ,где <tex>h(A) =
\begin{cases}
S_{|A|}, & \text{if }|A| \le m \\
S_m, & \text{otherwise}
\end{cases} </tex>.

Это означает, что условие <tex>\sum\limits_{i \in A} p_i \le Th(A), \forall A \subseteq \{ 1, ... , n \}</tex> выполняется и требования к обработке <tex>x_{1K}, . . . , x_{nK}</tex> могут быть запланированы как <tex>I_K</tex> для <tex>K = 2, . . . , r</tex>. Рассмотрим подсеть в расширенной сети в подмножестве <tex>A</tex> и соответствующие части потока. Фрагмент частичного потока, который проходит через <tex>(K, j)</tex> ограничен

<tex>\min \{ j(s_j −- s_{j + 1})T_K, |A|(s_j - s_{j+1})T_K \} = T_K(s_j - s_{j+1}) \min \{ j, |A| \}</tex>.

Таким образом, мы имеем

<tex>\sum\limits_{i \in A} x_{iK} \ge T_K \sum\limits_{j = 1}^m(s_j −- s_{j+1}) \min \{ j, |A| \} = T_Kh(A)</tex>. <tex>(*)</tex>

То, что равенство <tex>(*)</tex> справедливо, может рассматриваться как следствие. Если <tex>|A| > m</tex>, то

<tex>\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - 3s_4 + ... + ms_s - ms_{m+1} =\ </tex>
<tex>S_m = h(A)</tex>.

В противном случае

<tex>\sum\limits_{j = 1} \min \{ j, |A| \}(s_j - s_{j + 1}) = s_1 - s_2 + 2s_2 - 2s_3 + 3s_3 - ... + (|A| - 1)s_{|A| - 1} -\ </tex>
<tex>(|A| - 1)s_{|A|} + |A|(s_{|A|} - s_{|A| - 1} - ... - s_m + s_m - s_{m + 1}) = S_{|A|} = h(A)</tex>.

<tex>(a) \Rightarrow (b):</tex>
Предположим, что допустимое расписание существует. Для <tex>i = 1, ... , n </tex> и <tex>K = 2, ..., r</tex> пусть <tex>x_{iK}</tex> является "объемом работ", который будет выполняться в интервале <tex>I_K</tex> в соответствии с нашим возможным расписанием. Тогда для всех <tex>K = 2, ..., r</tex> и произвольных наборов <tex>A \subseteq \{ 1, . . . , n \}</tex>, неравенство

<tex>\sum\limits_{i \in A} x_{iK} \le T_Kh(A)</tex> <tex>(**)</tex>

выполняется. Кроме того, для <tex>i = 1, . . . , n</tex> у нас <tex>p_i = \sum\limits_{K = 2}^r s_{iK}</tex>. Остается показать, что можно отправить <tex>x_{iK}</tex> от <tex>J_i</tex> до <tex>I_K</tex> <tex>(i = 1, . . . , n; K = 2, . . . , r)</tex> в расширенной сети. Такой поток существует, если <tex>\forall A \subseteq \{ 1, . . . , n \}</tex> и <tex>K = 2, . . . , r</tex> значение <tex>\sum\limits_{i \in A} x_{iK}</tex> ограничено величиной минимального разреза части сети с истоками <tex>J_i(i \in A)</tex> и стоком <tex>I_K</tex>. Тем не менее, это значение

<tex>T_K\sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

Используя <tex>(**)</tex> и правую часть <tex>(*)</tex>, получаем

<tex>\sum\limits_{i \in A} x_{iK} \le T_K h(A) = T_K \sum\limits_{j = 1}^m \min \{ j, |A| \}(s_j - s_{j+1})</tex>

что и является искомым неравенством.
}}

==Время работы==

Работа с максимальным потоком в расширенной сети занимает <tex>O (m n^3)</tex> шагов, проверка может быть сделана с такой же скоростью. Для решения <tex>Q \mid pmtn; r_{i} \mid L_{max}</tex> мы используем бинарный поиск, значит получаем алгоритм с <tex>\varepsilon</tex>-приближенной сложностью <tex>O (mn^3(log(n) + log(1 / \varepsilon) + log(\max\limits_{i=1}^{n} p_i)) </tex>, потому как <tex>L_{max}</tex>, ограничен <tex>n \max\limits_{i=1}^{n}p_i</tex>, при <tex>s_1 = 1</tex>.

Задача <tex>Q \mid pmtn; r_i \mid C_{max}</tex> представляет собой частный случай <tex>Q \mid pmtn; r_i \mid L_{max}</tex>, и может быть решена более эффективно. Labetoulle, Lawler, Lenstra, и Rinnooy Kan разработали алгоритм работающий за <tex> O(n log(n) + mn) </tex> специально для этого случая.

==Источники==
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8

[[Категория: Теория расписаний]]

Классы NP, coNP, Σ₁, Π₁

2012-06-05T13:09:10Z

194.85.161.34:

== Определение ==
{{Определение
|definition=<tex>\mathrm{NP}=\bigcup\limits_{p(n) \in poly}\mathrm{NTIME}(p(n))</tex>.
}}
То есть <tex>\mathrm{NP}</tex> — это множество языков, разрешимых недетерминированной программой за полиномиальное время.
{{Определение
|definition=<tex>\mathrm{\Sigma_1}=\{L\bigm|\exists R(x,y)\in \tilde{\mathrm{P}}, p(n) - poly:x\in L\Leftrightarrow\exists y : |y|\le p(|x|), R(x,y)=1\}</tex>.
}}
Нестрого говоря, <tex>\mathrm{\Sigma_1}</tex> — это множество языков, для которых существует работающая за полиномиальное время детерминированная программа-верификатор <tex>R(x,y)</tex>, а для каждого слова из языка (и только для слова из языка) можно предъявить сертификат полиномиальной длины, подтверждающий принадлежность слова языку и проверяемый верификатором.

{{Теорема
|statement=
<tex>\mathrm{\Sigma_1}=\mathrm{NP}</tex>.
|proof=
*<tex>\mathrm{\Sigma_1} \subset \mathrm{NP}</tex>.
Пусть <tex>L \in \mathrm{\Sigma_1}</tex>. Тогда существуют <tex>R(x,y)</tex> и полином <tex>p</tex> из определения <tex>\mathrm{\Sigma_1}</tex>. Построим недетерминированную программу <tex>q(x)</tex>, разрешающую <tex>L</tex>.
q(x):
y <tex>\leftarrow?\{0,1\}^{\le p(|x|)}</tex>
return <tex>R(x,y)</tex>
Если <tex>x\in L</tex>, то программа сможет «угадать» подходящий сертификат. Если <tex>x\notin L</tex>, то подходящего сертификата не существует по определению. Таким образом, <tex>q</tex> разрешает <tex>L</tex>, следовательно <tex>L\in \mathrm{NP}</tex>.
*<tex>\mathrm{NP} \subset \mathrm{\Sigma_1}</tex>.
Пусть <tex>L\in \mathrm{NP}</tex>. Тогда существует недетерминированная программа <tex>q(x)</tex>, разрешающая этот язык. Построим верификатор <tex>R(x,y)</tex>. В качестве сертификата будем использовать последовательность выборов в программе <tex>q</tex>, приводящую к допуску слова (такой сертификат имеет полиномиальную длину, поскольку выборов в <tex>q</tex> может быть сделано не более, чем время ее работы, то есть не более, чем полином). Верификатор будет аналогичен программе <tex>q</tex>, только вместо каждого недетерминированного выбора он будет присваивать значение, указанное в сертификате. Если <tex>x\in L</tex>, то в <tex>q</tex> существует последовательность выборов таких, что <tex>q(x)=1</tex>, следовательно существует и верный сертификат. Если <tex>x\notin L</tex>, то для любой последовательности выборов <tex>q(x)=0</tex>, следовательно подходящего сертификата не существует. Таким образом, <tex>L \in \mathrm{\Sigma_1}</tex>.
}}
'''Примечание:''' определение <tex>\mathrm{\Sigma_1}</tex> часто называют также «определением NP на языке сертификатов».

== Свойства ==
{{Теорема
|statement=
Пусть <tex>L_1,L_2\in \mathrm{NP}</tex>. Тогда:
#<tex>L_1\cap L_2\in \mathrm{NP}</tex>;
#<tex>L_1\cup L_2\in \mathrm{NP}</tex>;
#<tex>L_1L_2\in \mathrm{NP}</tex>;
#<tex>L_1^*\in \mathrm{NP}</tex>.
|proof=
Пусть <tex>p</tex> разрешает <tex>L_1</tex>, а <tex>q</tex> разрешает <tex>L_2</tex>.

1. Построим программу <tex>r</tex>, разрешающую <tex>L_1\cap L_2</tex>:
r(x):
return p(x) <tex>\&\&</tex> q(x)
2. Построим программу <tex>r</tex>, разрешающую <tex>L_1\cup L_2</tex>:
r(x):
return p(x) <tex>||</tex> q(x)
3. Построим программу <tex>r</tex>, разрешающую <tex>L_1L_2</tex>:
r(x):
n <tex>\leftarrow|x|</tex>
mid <tex>\leftarrow?</tex> {1..n}
return p(x[1..mid]) <tex>\&\&</tex> q(x[mid+1..n])
4. Построим программу <tex>r</tex>, разрешающую <tex>L_1^*</tex>:
r(x):
n <tex>\leftarrow|x|</tex>
prev <tex>\leftarrow</tex> 1
do
cur <tex>\leftarrow?</tex> {prev..n}
if (!p(x[prev..cur]))
return false
prev <tex>\leftarrow</tex> cur+1
while (cur != n)
return true
 
}}

== Примеры NP-языков ==
* Язык раскрасок графа в <tex>k</tex> цветов;
* Задача о клике;
* [http://arxiv.org/abs/cs.CC/0210020 Тетрис]
Все эти языки также являются [[Примеры_NP-полных_языков._Теорема_Кука|<tex>\mathrm{NP}</tex>-полными]]. О существовании <tex>\mathrm{NP}</tex> языка, не являющегося <tex>\mathrm{NP}</tex>-полным гласит [[Теорема Ладнера|теорема Ладнера]].

== Связь P и NP ==
Очевидно, что <tex>\mathrm{P} \subseteq \mathrm{NP}</tex>, так как детерминированные программы можно рассматривать как недетерминированные, в которых не используется недетерминированный выбор. Вопрос о равенстве данных классов до сих пор остается открытым. Были осуществлены различные подходы к разрешению этой задачи: попытка найти [[Теорема_Махэни|редкий <tex>\mathrm{NP}</tex>-полный язык]]; было доказано, что [[Теорема_Бейкера_—_Гилла_—_Соловэя|доказательство должно быть нерелятивизующимся]]; различные попытки найти полиномиальные решения для задач из <tex>\mathrm{NPC}</tex>:
*[http://arxiv.org/abs/1011.3944 «решение» 3SAT за полиномиальное время];
*[http://www.cse.yorku.ca/~aaw/Zambito/TSP_Survey.pdf задача о коммивояжере].

Некоторые задачи из <tex>\mathrm{P}</tex> очень похожи на задачи из <tex>\mathrm{NP}</tex>. В каждой из приведенных ниже пар задач первая разрешима за полиномиальное время, а вторая является <tex>\mathrm{NP}</tex>-полной. При этом различие между задачами кажется совершенно незначительным.
*Поиск [[Обход_в_ширину|самых коротких]] и самых длинных простых путей;
*[[Эйлеров_цикл,_Эйлеров_путь,_Эйлеровы_графы,_Эйлеровость_орграфов|Эйлеров]] и [[Гамильтоновы_графы|гамильтонов]] циклы;
*2-CNF и 3-CNF выполнимость.

== См. также ==
* [[Недетерминированные вычисления]]

[[Категория: Теория сложности]]

PCP-система

2012-06-05T11:42:07Z

194.85.161.34:

[[Категория: Теория сложности]]
'''PCP(probabilistically checkable proof)''' - вид доказательства, проверяемого рандомизированным алгоритмом, использующим ограниченное число случайных бит и читающим ограниченное число бит доказательства. Такой алгоритм должен с достаточно высокими вероятностями принимать корректные доказательства и отвергать ошибочные.

== Определения ==
{{Определение
|definition =
<tex>\mathrm{PCP}</tex>'''-системой''' (системой вероятностно проверяемых доказательств) с полнотой <tex>c(n)</tex> и обоснованностью <tex>s(n)</tex> над алфавитом <tex>\Sigma</tex> для языка <tex>L</tex>, где <tex>0 \le s(n) \le c(n) \le 1</tex>, называется верификатор <tex>V</tex> {{---}} [[Вероятностные вычисления. Вероятностная машина Тьюринга#Основные определения|вероятностная машина Тьюринга]], имеющая доступ к доказательству <tex>\pi</tex> {{---}} цепочке из <tex>\Sigma^{*}</tex>, удовлетворяющая следующим свойствам:
* '''Полнота''': если <tex>x \in L</tex>, то вероятность того, что <tex>V^{\pi}</tex> допустит <tex>x</tex>, не меньше <tex>c(n)</tex> для некоторого <tex>\pi</tex>,
* '''Обоснованность''': если <tex>x \notin L</tex>, то вероятность того, что <tex>V^{\pi}</tex> допустит <tex>x</tex>, не больше <tex>s(n)</tex> для любого <tex>\pi</tex>.
}}
{{Определение
|definition =
'''Randomness complexity''' (вероятностной сложностью) <tex>r(n)</tex> верификатора <tex>V</tex> называется число случайных битов, используемых за всё время работы со входом длины <tex>n</tex>.
}}
{{Определение
|definition =
'''Query complexity''' (запросной сложностью) <tex>q(n)</tex> верификатора <tex>V</tex> называется число запросов битов из <tex>\pi</tex>, отсылаемых за всё время работы со входом длины <tex>n</tex>.
}}
{{Определение
|definition =
Верификатор <tex>V</tex> называется '''non-adaptive''' (неадаптивным), если при отправке запроса не использует ответы на предыдущие. Иными словами, его работа не изменится, если все запросы отправить одновременно.
}}
{{Определение
|definition =
Сложностный класс <tex>\mathrm{PCP}_{c(n), s(n)}[r(n), q(n)]</tex> {{---}} это объединение всех языков, для которых существует <tex>\mathrm{PCP}</tex>-система над бинарным алфавитом с полнотой <tex>c(n)</tex> и обоснованностью <tex>s(n)</tex>, в которой неадаптивный верификатор <tex>V</tex> работает за полиномиальное время и имеет вероятностную и запросную сложности соответственно <tex>r(n)</tex> и <tex>q(n)</tex>, а доказательства имеют экспоненциальную длину. 
Часто <tex>\mathrm{PCP}_{1, \frac{1}{2}}[r(n), q(n)]</tex> обозначают как <tex>\mathrm{PCP}[r(n), q(n)]</tex>.
}}

== Свойства ==
{{Теорема
|statement = <tex>\mathrm{PCP}[0, 0]</tex> = <tex>\mathrm{PCP}[O(\log(n)), 0]</tex> = <tex>\mathrm{PCP}[0, O(\log(n))]</tex> = <tex>\mathrm{P}</tex>.
|proof =
* <tex>\mathrm{PCP}[0, 0]</tex> = <tex>\mathrm{P}</tex>: вероятностная МТ не использует случайные биты и не обращается к доказательству, то есть работает как детерминированная МТ, работающая за полиномиальное время.
* <tex>\mathrm{PCP}[O(\log(n)), 0]</tex> = <tex>\mathrm{P}</tex>: доступ к <tex>O(\log(n))</tex> случайных бит не меняет ситуации, так как все возможные битовые цепочки логарифмической длины детерминированная МТ может сгенерировать и проверить за полиномиальное время.
* <tex>\mathrm{PCP}[0, O(\log(n))]</tex> = <tex>\mathrm{P}</tex>: так как доступа к случайным битам нет, <tex>\pi</tex> можно рассматривать как битовую цепочку логарифмической длины. Все возможные такие цепочки детерминированная МТ может сгенерировать и проверить за полиномиальное время.
}}
{{Теорема
|statement = <tex>\mathrm{PCP}[poly(n), 0]</tex> = <tex>\mathrm{coRP}</tex>.
|proof =
Очевидно следует из [[Вероятностные вычисления. Вероятностная машина Тьюринга#Вероятностные сложностные классы|определения coRP]].
}}
{{Теорема
|statement = <tex>\mathrm{PCP}[0, poly(n)]</tex> = <tex>\mathrm{NP}</tex>.
|proof =
Очевидно следует из [[Классы_NP_и_Σ₁|определения Σ₁]].
}}

== Пример ==
{{Теорема
|statement = '''Graph Nonisomorphism(GNI)''' <tex>\in \mathrm{PCP}[poly(n), O(1)]</tex>.
|proof =
<tex>G_1</tex> и <tex>G_2</tex> {{---}} графы на <tex>n</tex> вершинах. Требуется проверить, неизоморфны ли они друг другу. 
Сперва пронумеруем все возможные графы на <tex>n</tex> вершинах. Не умаляя общности, будем считать, что <tex>\pi</tex> над троичным алфавитом. 
Будем считать корректной <tex>\pi</tex>: 
* <tex>\pi[k] = 0</tex> тогда и только тогда, когда граф номер <tex>k</tex> изоморфен <tex>G_1</tex> и <tex>G_2</tex>,
* <tex>\pi[k] = 1</tex> тогда и только тогда, когда граф номер <tex>k</tex> изоморфен <tex>G_1</tex> и неизоморфен <tex>G_2</tex>,
* <tex>\pi[k] = 2</tex> тогда и только тогда, когда граф номер <tex>k</tex> неизоморфен <tex>G_1</tex> и изоморфен <tex>G_2</tex>.
Верификатором <tex>V</tex> будет вероятностная МТ, работающая эквивалентно следующему псевдокоду: 
p(<tex>\langle G_1, G_2 \rangle</tex>) {
i = random{1, 2};
<tex>\phi</tex> = random permutation{1..n};
<tex>H</tex> = <tex>\phi(G_i)</tex>;
if (<tex>\pi[\#H]</tex> == 0) or (<tex>\pi[\#H]</tex> == 3-i) {
return 0;
}
// <tex>\pi[\#H]</tex> == i
return 1;
}
Проверим полноту и обоснованность:
* '''Полнота''': если графы неизоморфны, то существует <tex>\pi</tex> такая, что всякий её символ равен 1 или 2 и задан корректно. Тогда на этой <tex>\pi</tex> верификатор всегда вернёт 1;
* '''Обоснованность''': если графы изоморфны, то фиксируем <tex>\pi</tex>. Пусть <tex>\Omega</tex> {{---}} это множество всех конфигураций случайной ленты, с которой работает <tex>V</tex>. Заметим, что все конфигурации из <tex>\Omega</tex> будут переданы <tex>V</tex> с равными вероятностями. Теперь рассмотрим произвольную конфигурацию типа <tex>\psi</tex> из <tex>\Omega</tex>, то есть конфигурацию, на которой <tex>V</tex> допускает <tex>\langle G_1, G_2 \rangle</tex>. Заметим, что для каждой такой конфигурации существует однозначно определяемая конфигурация типа <tex>\overline \psi</tex>, отличающаяся от <tex>\psi</tex> только первым битом и также принадлежащая <tex>\Omega</tex>. Запустившись на <tex>\overline \psi</tex>, <tex>V</tex>, очевидно, отвергнет <tex>\langle G_1, G_2 \rangle</tex>. Таким образом, конфигураций типа <tex>\psi</tex> в <tex>\Omega</tex> не больше половины. Как уже отмечалось, конфигурации из <tex>\Omega</tex> подаются <tex>V</tex> с равными вероятностями, а конфигураций не из <tex>\Omega</tex>, по определению, <tex>V</tex> не подаётся. Таким образом, вероятность ошибки не превышает <tex>\frac{1}{2}</tex>.
}}

PCP-система

2012-06-05T11:40:11Z

194.85.161.34:

[[Категория: Теория сложности]]
'''PCP(probabilistically checkable proof)''' - вид доказательства, проверяемого рандомизированным алгоритмом, использующим ограниченное число случайных бит и читающим ограниченное число бит доказательства. Такой алгоритм должен с достаточно высокими вероятностями принимать корректные доказательства и отвергать ошибочные.

== Определения ==
{{Определение
|definition =
<tex>\mathrm{PCP}</tex>'''-системой''' (системой вероятностно проверяемых доказательств) с полнотой <tex>c(n)</tex> и обоснованностью <tex>s(n)</tex> над алфавитом <tex>\Sigma</tex> для языка <tex>L</tex>, где <tex>0 \le s(n) \le c(n) \le 1</tex>, называется верификатор <tex>V</tex> {{---}} [[Вероятностные вычисления. Вероятностная машина Тьюринга#Основные определения|вероятностная машина Тьюринга]], имеющая доступ к доказательству <tex>\pi</tex> {{---}} цепочке из <tex>\Sigma^{*}</tex>, удовлетворяющая следующим свойствам:
* '''Полнота''': если <tex>x \in L</tex>, то вероятность того, что <tex>V^{\pi}</tex> допустит <tex>x</tex>, не меньше <tex>c(n)</tex> для некоторого <tex>\pi</tex>,
* '''Обоснованность''': если <tex>x \notin L</tex>, то вероятность того, что <tex>V^{\pi}</tex> допустит <tex>x</tex>, не больше <tex>s(n)</tex> для любого <tex>\pi</tex>.
}}
{{Определение
|definition =
'''Randomness complexity''' (вероятностной сложностью) <tex>r(n)</tex> верификатора <tex>V</tex> называется число случайных битов, используемых за всё время работы со входом длины <tex>n</tex>.
}}
{{Определение
|definition =
'''Query complexity''' (запросной сложностью) <tex>q(n)</tex> верификатора <tex>V</tex> называется число запросов битов из <tex>\pi</tex>, отсылаемых за всё время работы со входом длины <tex>n</tex>.
}}
{{Определение
|definition =
Верификатор <tex>V</tex> называется '''non-adaptive''' (неадаптивным), если при отправке запроса не использует ответы на предыдущие. Иными словами, его работа не изменится, если все запросы отправить одновременно.
}}
{{Определение
|definition =
Сложностный класс <tex>\mathrm{PCP}_{c(n), s(n)}[r(n), q(n)]</tex> {{---}} это объединение всех языков, для которых существует <tex>\mathrm{PCP}</tex>-система над бинарным алфавитом с полнотой <tex>c(n)</tex> и обоснованностью <tex>s(n)</tex>, в которой неадаптивный верификатор <tex>V</tex> работает за полиномиальное время и имеет вероятностную и запросную сложности соответственно <tex>r(n)</tex> и <tex>q(n)</tex>, а доказательства имеют экспоненциальную длину. 
Часто <tex>\mathrm{PCP}_{1, \frac{1}{2}}[r(n), q(n)]</tex> обозначают как <tex>\mathrm{PCP}[r(n), q(n)]</tex>.
}}

== Свойства ==
{{Теорема
|statement = <tex>\mathrm{PCP}[0, 0]</tex> = <tex>\mathrm{PCP}[O(log(n)), 0]</tex> = <tex>\mathrm{PCP}[0, O(log(n))]</tex> = <tex>\mathrm{P}</tex>.
|proof =
* <tex>\mathrm{PCP}[0, 0]</tex> = <tex>\mathrm{P}</tex>: вероятностная МТ не использует случайные биты и не обращается к доказательству, то есть работает как детерминированная МТ, работающая за полиномиальное время.
* <tex>\mathrm{PCP}[O(\log(n)), 0]</tex> = <tex>\mathrm{P}</tex>: доступ к <tex>O(\log(n))</tex> случайных бит не меняет ситуации, так как все возможные битовые цепочки логарифмической длины детерминированная МТ может сгенерировать и проверить за полиномиальное время.
* <tex>\mathrm{PCP}[0, O(\log(n))]</tex> = <tex>\mathrm{P}</tex>: так как доступа к случайным битам нет, <tex>\pi</tex> можно рассматривать как битовую цепочку логарифмической длины. Все возможные такие цепочки детерминированная МТ может сгенерировать и проверить за полиномиальное время.
}}
{{Теорема
|statement = <tex>\mathrm{PCP}[poly(n), 0]</tex> = <tex>\mathrm{coRP}</tex>.
|proof =
Очевидно следует из [[Вероятностные вычисления. Вероятностная машина Тьюринга#Вероятностные сложностные классы|определения coRP]].
}}
{{Теорема
|statement = <tex>\mathrm{PCP}[0, poly(n)]</tex> = <tex>\mathrm{NP}</tex>.
|proof =
Очевидно следует из [[Классы_NP_и_Σ₁|определения Σ₁]].
}}

== Пример ==
{{Теорема
|statement = '''Graph Nonisomorphism(GNI)''' <tex>\in \mathrm{PCP}[poly(n), O(1)]</tex>.
|proof =
<tex>G_1</tex> и <tex>G_2</tex> {{---}} графы на <tex>n</tex> вершинах. Требуется проверить, неизоморфны ли они друг другу. 
Сперва пронумеруем все возможные графы на <tex>n</tex> вершинах. Не умаляя общности, будем считать, что <tex>\pi</tex> над троичным алфавитом. 
Будем считать корректной <tex>\pi</tex>: 
* <tex>\pi[k] = 0</tex> тогда и только тогда, когда граф номер <tex>k</tex> изоморфен <tex>G_1</tex> и <tex>G_2</tex>,
* <tex>\pi[k] = 1</tex> тогда и только тогда, когда граф номер <tex>k</tex> изоморфен <tex>G_1</tex> и неизоморфен <tex>G_2</tex>,
* <tex>\pi[k] = 2</tex> тогда и только тогда, когда граф номер <tex>k</tex> неизоморфен <tex>G_1</tex> и изоморфен <tex>G_2</tex>.
Верификатором <tex>V</tex> будет вероятностная МТ, работающая эквивалентно следующему псевдокоду: 
p(<tex>\langle G_1, G_2 \rangle</tex>) {
i = random{1, 2};
<tex>\phi</tex> = random permutation{1..n};
<tex>H</tex> = <tex>\phi(G_i)</tex>;
if (<tex>\pi[\#H]</tex> == 0) or (<tex>\pi[\#H]</tex> == 3-i) {
return 0;
}
// <tex>\pi[\#H]</tex> == i
return 1;
}
Проверим полноту и обоснованность:
* '''Полнота''': если графы неизоморфны, то существует <tex>\pi</tex> такая, что всякий её символ равен 1 или 2 и задан корректно. Тогда на этой <tex>\pi</tex> верификатор всегда вернёт 1;
* '''Обоснованность''': если графы изоморфны, то фиксируем <tex>\pi</tex>. Пусть <tex>\Omega</tex> {{---}} это множество всех конфигураций случайной ленты, с которой работает <tex>V</tex>. Заметим, что все конфигурации из <tex>\Omega</tex> будут переданы <tex>V</tex> с равными вероятностями. Теперь рассмотрим произвольную конфигурацию типа <tex>\psi</tex> из <tex>\Omega</tex>, то есть конфигурацию, на которой <tex>V</tex> допускает <tex>\langle G_1, G_2 \rangle</tex>. Заметим, что для каждой такой конфигурации существует однозначно определяемая конфигурация типа <tex>\overline \psi</tex>, отличающаяся от <tex>\psi</tex> только первым битом и также принадлежащая <tex>\Omega</tex>. Запустившись на <tex>\overline \psi</tex>, <tex>V</tex>, очевидно, отвергнет <tex>\langle G_1, G_2 \rangle</tex>. Таким образом, конфигураций типа <tex>\psi</tex> в <tex>\Omega</tex> не больше половины. Как уже отмечалось, конфигурации из <tex>\Omega</tex> подаются <tex>V</tex> с равными вероятностями, а конфигураций не из <tex>\Omega</tex>, по определению, <tex>V</tex> не подаётся. Таким образом, вероятность ошибки не превышает <tex>\frac{1}{2}</tex>.
}}

Классы PH, Σ и Π

2012-06-05T09:27:28Z

194.85.161.34:

== Классы Σ и Π ==
{{Определение
|definition =
<tex>\Sigma_{i} = \{L \bigm| \exists R(x,y_{1},\cdots,y_{i}) \in \mathrm{P}, p</tex> {{---}} <tex>poly : \forall x \in L \Leftrightarrow \exists y_{1} \forall y_{2} \exists y_{3} \cdots Q y_{i} : \forall j |y_{j}|~\le~p(|x|), R(x,y_{1},\cdots,y_{i})\},</tex> 
где <tex>L</tex> — формальный язык <tex>,Q = \exists</tex> для <tex>i = 2k$-$1,</tex> <tex>Q = \forall</tex> для <tex>i = 2k</tex>.
}}

{{Определение
|definition =
<tex>\Pi_{i} = \{L \bigm| \exists R(x, y_{1},\cdots,y_{i}) \in \mathrm{P}, p</tex> {{---}} <tex>poly : \forall x \in L \Leftrightarrow \forall y_{1} \exists y_{2} \forall y_{3} \cdots Q y_{i} : \forall j |y_{j}|~\le~p(|x|), R(x, y_{1}, \cdots, y_{i}) \},</tex> 
где <tex>L</tex> — формальный язык <tex>,Q = \forall</tex> для <tex>i = 2k$-$1,</tex> <tex>Q = \exists</tex> для <tex>i = 2k</tex>.
}}

== Соотношения между классами Σ и Π ==
{{Теорема
|statement = <tex>\Sigma_{i} \subset \Sigma_{i+1} \cap \Pi_{i+1}</tex>.
|proof = Пусть <tex>L \in \Sigma_{i} \Rightarrow \exists R : x \in L \Leftrightarrow \exists y_{1} \cdots Q y_{i} : R(x,y_{1},\cdots,y_{i}), \forall j |y_{j}| \le poly(|x|)</tex>. 
Проверим, что <tex>L \in \Sigma_{i+1} \Leftrightarrow \exists R' : x \in L \Leftrightarrow \exists y_{1} \cdots Q y_{i} \bar{Q} y_{i+1} : R'(x,y_{1},\cdots,y_{i},y_{i+1})</tex>.
 
<tex>R'(x,y_{1},\cdots,y_{i+1})</tex> {
return <tex>R(x,y_{1},\cdots,y_{i})</tex>;
}
Проверим, что <tex>L \in \Pi_{i+1} \Leftrightarrow \exists R'' : x \in L \Leftrightarrow \forall y_{0} \exists y_{1} \cdots Q y_{i} : R''(x,y_{0},y_{1},\cdots,y_{i})</tex>.
 
<tex>R''(x,y_{0},y_{1},\cdots,y_{i})</tex> {
return <tex>R(x,y_{1},\cdots,y_{i})</tex>;
}
Таким образом, <tex>\Sigma_{i} \subset \Sigma_{i+1}, \Sigma_{i} \subset \Pi_{i+1} \Rightarrow \Sigma_{i} \subset \Sigma_{i+1} \cap \Pi_{i+1}</tex>.
}}

{{Теорема
|statement = <tex>\Sigma_{i} = \mathrm{co\Pi_{i}}</tex>.
|proof = <tex>\mathrm{co\Pi_{i}} = \{L \bigm| \exists R(x,y_{1},\cdots,y_{i}) \in \mathrm{P}, p</tex> {{---}} <tex>poly: x \in L \Leftrightarrow \exists y_{1} \forall y_{2} \cdots Q y_{i} : \forall j |y_j|~\le~p(|x|), R(x,y_{1},\cdots,y_{i})\}.</tex> 
Из самого выражения для <tex>\mathrm{co\Pi_{i}}</tex> очевидно равенство.
}}

== Пример Σ и Π-полных задач ==
{{Определение
|definition = Задачей <tex>\mathrm{QBF^{\Sigma}_{k}}</tex> называется объединение удовлетворимых булевых формул с <tex>k</tex> изменениями кванторов, где первым квантором является <tex>\exists</tex>. 
<tex>\mathrm{QBF^{\Sigma}_{k}} = \{\phi \bigm| \exists X_{1} \forall X_{2} \exists X_{3} \cdots : \phi(X_{1} \cdots X_{k})\}</tex>, 
где <tex>X_{i}</tex> {{---}} попарно непересекающиеся множества аргументов <tex>\phi</tex>.
}}
<tex>\mathrm{QBF^{\Sigma}_{k}}</tex> {{---}} <tex>\mathrm{\Sigma_{k}}</tex>-полная задача (доказательство аналогично доказательству [[Теорема Бермана — Форчуна|coNP-полноты TAUT]]).

{{Определение
|definition = Задачей <tex>\mathrm{QBF^{\Pi}_{k}}</tex> называется объединение удовлетворимых булевых формул с <tex>k</tex> изменениями кванторов, где первым квантором является <tex>\forall</tex>. 
<tex>\mathrm{QBF^{\Pi}_{k}} = \{\phi \bigm| \forall X_{1} \exists X_{2} \forall X_{3} \cdots : \phi(X_{1} \cdots X_{k})\}</tex>, 
где <tex>X_{i}</tex> {{---}} попарно непересекающиеся множества аргументов <tex>\phi</tex>.
}}
Аналогично предыдущей, <tex>\mathrm{QBF^{\Pi}_{k}}</tex> {{---}} <tex>\mathrm{\Pi_{k}}</tex>-полная задача.

== Класс PH ==
{{Определение
|definition =
<tex>\mathrm{PH} = {\bigcup \atop {i \in \mathbb{N}}} \Sigma_{i}</tex>. 
}}
Замечание: иногда удобнее пользоваться альтернативными определениями <tex>\mathrm{PH}</tex>. Например:
* <tex>\mathrm{PH} = {\bigcup \atop {i \in \mathbb{N}}} \Pi_{i}</tex>, 
* <tex>\mathrm{PH} = {\bigcup \atop {i \in \mathbb{N}}} (\Sigma_{i} \cup \Pi_{i})</tex>.

{{Теорема
|statement = <tex>\mathrm{PH} \subset \mathrm{PS}</tex>.
|proof = Пусть <tex>L \in \Sigma_{i} \Rightarrow \exists R : x \in L \Leftrightarrow \exists y_{1} \cdots Q y_{i} : R(x,y_{1},\cdots,y_{i}), \forall j |y_{j}| \le poly(|x|)</tex>. 
То есть, для перебора всех возможных значений <tex>y_{j}</tex> потребуется не более, чем <tex>i \cdot poly(|x|)</tex> памяти. Заметим, что <tex>i \cdot poly(|x|)</tex> тоже полином.
Таким образом, для любого формального языка из <tex>\mathrm{PH}</tex> существует программа, разрешающая его на полиномиальной памяти. То есть, любой формальный язык из <tex>\mathrm{PH}</tex> принадлежит <tex>\mathrm{PS}</tex>.
}}

[[Категория: Теория сложности]]

СНМ (наивные реализации)

2012-03-15T13:22:36Z

194.85.161.34: /* С помощью списка */

{{Определение
| definition =
Система непересекающихся множеств (disjoint set union, DSU) {{ --- }} структура данных, поддерживающая операции union(x, y) {{ --- }} объединения множеств, содержащих x и y, и find(k) {{ --- }} поиск множества, которому принадлежит элемент k.
}}

__TOC__

== Пример работы ==
[[Файл:DSU_1_Example.png|400px]]

== Реализации ==
=== С помощью массива ===
'''Оценка работы:'''
{| class="wikitable" border="1"
|init
|find
|union
|-
|<tex>O(n)</tex>
|<tex>O(1)</tex>
|<tex>O(n)</tex>
|}


Пусть в массиве s хранятся номера множеств, в s[i] будет храниться номер множества, к которому принадлежит i. Этот номер отождествляет множество, find возвращает именно его. Тогда find, очевидно, будет работать за <tex>O(1)</tex>.

Чтобы объединить множества x и y, надо изменить все s[i], равные номеру множества x, на номер y. Тогда union работает за <tex>O(n)</tex>.

'''Псевдокод:'''
int s[n]
init():
for i = 0 to n - 1:
s[i] = i // сначала каждый элемент лежит в своем множестве

find(k):
return s[k]

union(x, y):
if s[x] == s[y]:
return
else:
t = s[y]
for i = 0 to n - 1:
if s[i] == t:
s[i] = s[x]

=== С помощью списка ===
'''Оценка работы:'''
{| class="wikitable" border="1"
|init
|find
|union
|-
|<tex>O(n)</tex>
|<tex>O(n)</tex>
|<tex>O(1)</tex>
|}
Будем хранить множество в виде списка. Вначале создается n списков, в котором каждый элемент является представителем своего множества. Для каждого элемента списка будем хранить ссылку на следующий элемент (next) и ссылку на голову (head). Причем ссылка на head будет корректна только у элемента-представителя. Тогда для объединения множеств надо будет просто перекинуть ссылку next на начало другого множества. Таким образом, union работает за <tex>O(1)</tex>.

Для того, чтобы найти элемент в одном из множеств, надо идти по ссылкам next, пока он не указывает на null {{ --- }} тогда мы нашли элемент-представитель. Таким образом, find работает за <tex>O(n)</tex>.

Псевдокод:
s[n]
init():
for i = 0 to n - 1:
s[i].set = i
s[i].next = null
s[i].head = s[i]

find(x): // подразумевается, что x {{ --- }} ссылка на один из элементов
while x.next != null:
x = x.next
return x.set

union(x, y): // здесь важно, что x и y {{ --- }} представители множеств
if x == y:
return
else:
x.next = y.head // соединили списки
y.head = x.head // сделали корректную ссылку на голову для представителя нового списка

'''Пример работы:'''

Два списка до операции union:

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

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

Два списка после операции union:

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

== Другие реализации ==
* [[СНМ(списки с весовой эвристикой)]]
* [[СНМ(реализация с помощью леса корневых деревьев)]]

== Источники ==
* Т. Кормен - Алгоритмы, построение и анализ. Второе издание. Часть V. Глава 21.

== Ссылки ==
* [http://habrahabr.ru/blogs/algorithm/104772/ Система непересекающихся множеств и её применения]

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

СНМ (наивные реализации)

2012-03-15T13:17:09Z

194.85.161.34: /* С помощью массива */

{{Определение
| definition =
Система непересекающихся множеств (disjoint set union, DSU) {{ --- }} структура данных, поддерживающая операции union(x, y) {{ --- }} объединения множеств, содержащих x и y, и find(k) {{ --- }} поиск множества, которому принадлежит элемент k.
}}

__TOC__

== Пример работы ==
[[Файл:DSU_1_Example.png|400px]]

== Реализации ==
=== С помощью массива ===
'''Оценка работы:'''
{| class="wikitable" border="1"
|init
|find
|union
|-
|<tex>O(n)</tex>
|<tex>O(1)</tex>
|<tex>O(n)</tex>
|}


Пусть в массиве s хранятся номера множеств, в s[i] будет храниться номер множества, к которому принадлежит i. Этот номер отождествляет множество, find возвращает именно его. Тогда find, очевидно, будет работать за <tex>O(1)</tex>.

Чтобы объединить множества x и y, надо изменить все s[i], равные номеру множества x, на номер y. Тогда union работает за <tex>O(n)</tex>.

'''Псевдокод:'''
int s[n]
init():
for i = 0 to n - 1:
s[i] = i // сначала каждый элемент лежит в своем множестве

find(k):
return s[k]

union(x, y):
if s[x] == s[y]:
return
else:
t = s[y]
for i = 0 to n - 1:
if s[i] == t:
s[i] = s[x]

=== С помощью списка ===
'''Оценка работы:'''
{| class="wikitable" border="1"
|init
|find
|union
|-
|<tex>O(n)</tex>
|<tex>O(n)</tex>
|<tex>O(1)</tex>
|}
Будем хранить множество в виде списка. Вначале создается n списков, в котором каждый элемент является представителем своего множества. Для каждого списка будем хранить ссылку на следующий элемент (next) и ссылку на голову (head). Тогда для объединения множеств надо будет просто перекинуть ссылку next на начало другого множества. Таким образом, union работает за <tex>O(1)</tex>.

Для того, чтобы найти элемент в одном из множеств, надо идти по ссылкам next, пока он не указывает на null {{ --- }} тогда мы нашли элемент-представитель. Таким образом, find работает за <tex>O(n)</tex>.

Псевдокод:
s[n]
init():
for i = 0 to n - 1:
s[i].set = i
s[i].next = null
s[i].head = s[i]

find(x): // подразумевается, что x {{ --- }} ссылка на один из элементов
while x.next != null:
x = x.next
return x.set

union(x, y): // здесь важно, что x и y {{ --- }} представители множеств
if x == y:
return
else:
x.next = y.head // соединили списки
y.head = x.head // сделали корректную ссылку на голову для представителя нового списка

'''Пример работы:'''

Два списка до операции union:

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

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

Два списка после операции union:

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

== Другие реализации ==
* [[СНМ(списки с весовой эвристикой)]]
* [[СНМ(реализация с помощью леса корневых деревьев)]]

== Источники ==
* Т. Кормен - Алгоритмы, построение и анализ. Второе издание. Часть V. Глава 21.

== Ссылки ==
* [http://habrahabr.ru/blogs/algorithm/104772/ Система непересекающихся множеств и её применения]

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

СНМ (наивные реализации)

2012-03-15T13:16:35Z

194.85.161.34:

{{Определение
| definition =
Система непересекающихся множеств (disjoint set union, DSU) {{ --- }} структура данных, поддерживающая операции union(x, y) {{ --- }} объединения множеств, содержащих x и y, и find(k) {{ --- }} поиск множества, которому принадлежит элемент k.
}}

__TOC__

== Пример работы ==
[[Файл:DSU_1_Example.png|400px]]

== Реализации ==
=== С помощью массива ===
'''Оценка работы:'''
{| class="wikitable" border="1"
|init
|find
|union
|-
|<tex>O(n)</tex>
|<tex>O(1)</tex>
|<tex>O(n)</tex>
|}

Пусть в массиве s хранятся номера множеств, в s[i] будет храниться номер множества, к которому принадлежит i. Этот номер отождествляет множество, find возвращает именно его. Тогда find, очевидно, будет работать за <tex>O(1)</tex>.

Чтобы объединить множества x и y, надо изменить все s[i], равные номеру множества x, на номер y. Тогда union работает за <tex>O(n)</tex>.

'''Псевдокод:'''
int s[n]
init():
for i = 0 to n - 1:
s[i] = i // сначала каждый элемент лежит в своем множестве

find(k):
return s[k]

union(x, y):
if s[x] == s[y]:
return
else:
t = s[y]
for i = 0 to n - 1:
if s[i] == t:
s[i] = s[x]

=== С помощью списка ===
'''Оценка работы:'''
{| class="wikitable" border="1"
|init
|find
|union
|-
|<tex>O(n)</tex>
|<tex>O(n)</tex>
|<tex>O(1)</tex>
|}
Будем хранить множество в виде списка. Вначале создается n списков, в котором каждый элемент является представителем своего множества. Для каждого списка будем хранить ссылку на следующий элемент (next) и ссылку на голову (head). Тогда для объединения множеств надо будет просто перекинуть ссылку next на начало другого множества. Таким образом, union работает за <tex>O(1)</tex>.

Для того, чтобы найти элемент в одном из множеств, надо идти по ссылкам next, пока он не указывает на null {{ --- }} тогда мы нашли элемент-представитель. Таким образом, find работает за <tex>O(n)</tex>.

Псевдокод:
s[n]
init():
for i = 0 to n - 1:
s[i].set = i
s[i].next = null
s[i].head = s[i]

find(x): // подразумевается, что x {{ --- }} ссылка на один из элементов
while x.next != null:
x = x.next
return x.set

union(x, y): // здесь важно, что x и y {{ --- }} представители множеств
if x == y:
return
else:
x.next = y.head // соединили списки
y.head = x.head // сделали корректную ссылку на голову для представителя нового списка

'''Пример работы:'''

Два списка до операции union:

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

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

Два списка после операции union:

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

== Другие реализации ==
* [[СНМ(списки с весовой эвристикой)]]
* [[СНМ(реализация с помощью леса корневых деревьев)]]

== Источники ==
* Т. Кормен - Алгоритмы, построение и анализ. Второе издание. Часть V. Глава 21.

== Ссылки ==
* [http://habrahabr.ru/blogs/algorithm/104772/ Система непересекающихся множеств и её применения]

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

Предикат "левый поворот"

2012-03-05T06:17:22Z

194.85.161.34:

Даны два отрезка, которые задаются начальной и конечной точками <tex>a,b\ \mathcal{2}\ \mathbb R^2</tex> и определяются как множества точек <tex>s\ =\ \{(1-t)a + tb,\ t\ \mathcal{2}\ [0;1]\}</tex>. Требуется проверить существование множества их общих точек. Для определения этого факта в вычислительной геометрии используется предикат "левый поворот" (или "по часовой стрелке").
Рассмотрим возможные расположения точек и самих отрезков относительно друг друга:

[[Файл:Cross.png]]
[[Файл:Two_segments.png]]
[[Файл:Touch.jpg]]

Определим, лежат ли точки концов отрезков по разные стороны от другого отрезка.
{{Определение
|definition =
<tex dpi = "120">
$$
Left\_Turn(a, b, c) =\left\{
\begin{array}{rl}
-1 &\mbox{, for}\ (b - a)\times(c - a) < 0\\
0 &\mbox{, for}\ (b - a)\times(c - a) = 0\\
1 &\mbox{, for}\ (b - a)\times(c - a) > 0
\end{array}
\right.
$$
</tex>
}}
Распишем подробнее:
<tex dpi = 120>(b - a)\times(c - a) = (b_x - a_x)(c_y - a_y) - (b_y - a_y)(c_x - a_x) = A - B</tex>

Какие при этом у нас будут погрешности?
Допустим, что все числа положительные и будем писать без модулей:

'''Замечание:''' при сложении складываются абс. погрешности,при умножении складываются отн. погрешности.

<tex dpi = "150"> \delta (b - a)\times(c - a) = A \varepsilon (\frac{(b_x + a_x)}{(b_x \cdot a_x)} + \frac{(c_y + a_y)}{(c_y \cdot a_y)}) + B \varepsilon (\frac{(b_y + a_y)}{(b_y \cdot a_y)} + \frac{(c_x + a_x)}{(c_x \cdot a_x)})</tex>

Заметим, что все координаты (а значит и наши вычисления) производятся в вещественных числах, а это значит, что при вычислениях мы можем допустить ошибку. Более точно определить знак нашего выражения поможет вычисление с [[Интервальная арифметика |"интервальной арифметикой"]]. Все исходные переменные будут вырожденными интервалами. Из-за погрешностей, возникающих при округлении вещественных чисел, истинные значения операций нам будут неизвестны, но они обязательно будет содержаться в посчитанных интервалах. Для точного вычисления необходимо
фильтрованное вычисление предикатов.

<tex dpi = 140>\overbrace {(b - a)\times(c - a)}^{v} \approx \overbrace{(b_x \ominus a_x)\otimes(c_y \ominus a_y) \ominus (b_y \ominus a_y)\otimes(c_x \ominus a_x)}^{\tilde{v}} =</tex>

<tex dpi = 130>= \big((b_x - a_x)(c_y - a_y)(1 + \delta_1)(1 + \delta_2)(1 + \delta_3)\ -</tex>

<tex dpi = 130>-\ (b_y - a_y)(c_x - a_x)(1 + \delta_4)(1 + \delta_5)(1 + \delta_6)\big)(1 + \delta_7)</tex>

<tex dpi = 130>\mid\delta_i\mid \le \varepsilon</tex>;

Именно поэтому, когда угол между отрезками АВ и АС КРАЙНЕ МАЛ, мы можем получить неверное значение предиката.

[[Файл:Tiny_angle.jpg]]

=Bounding box=
Ещё следует обратить внимание на граничные случаи, когда какие-то точки попадают на саму прямую. При этом возникает единственный особый случай, когда вышеописанные проверки ничего не дадут — случай, когда оба отрезка лежат на одной прямой. Этот случай надо рассмотреть отдельно. Для этого достаточно проверить, что проекции этих двух отрезков на оси X и Y пересекаются (часто эту проверку называют "проверкой на bounding box").

[[Файл:Bounting_box().png]]
[[Файл:Bounting_box_.png]]

[[Категория: Вычислительная геометрия]]

Алгоритм A*

2012-02-28T09:44:17Z

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

Алгоритм '''А*'''("A star", "А звёздочка") {{---}} алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.
==Описание==
В процессе работы алгоритма для вершин рассчитывается функция <tex>f(v) = g(v) + h(v)</tex>, где
*<tex>g(v)</tex> {{---}} наименьшая стоимость пути в <tex>v</tex> из стартовой вершины,
*<tex>h(v)</tex> {{---}} эвристическое приближение стоимости пути от <tex>v</tex> до конечной цели. <tex>h(v)</tex> должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели.
Чем меньше , тем раньше вершина будет открыта и исследована алгоритмом. Таким образом открытые алгоритмом вершины хранятся в очереди с приоритетом по значению <tex>f(v)</tex>. А* действует подобно [[Алгоритм Дейкстры | алгоритму Дейкстры]] и просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент являются наилучшими.

Поведение алгоритма сильно зависит от того, какая эвристика используется. В свою очередь, выбор эвристики зависит[[Файл:Diagonal.png|thumb|right|Пример А* на сетке с возможностью ходить в восьми напрвлениях]] от постановки задачи. Часто А* используется для моделирования перемещения по поверхности, покрытой [http://deep-beta.co.uk/wp-content/uploads/2010/11/terrain.0.3+grid.png координатной сеткой].

* Если мы можем перемещаться в четырех направлениях, в качестве эвристики стоит выбрать [http://en.wikipedia.org/wiki/Manhattan_distance манхэттенское расстояние] <tex>h(v) = |{v.x-goal.x}| + |{v.y-goal.y}|</tex>.

* [http://ru.wikipedia.org/wiki/Расстояние_Чебышева Расстояние Чебышева] применяется когда к четырем направлениям добавляются диагонали: <tex>h(v) = \max{(|{v.x-goal.x}|, |{v.y-goal.y}|)}</tex>.

* Если передвижение не ограниченно сеткой, то можно использовать евклидово расстояние по прямой: <tex>h(v) = \sqrt{(v.x-goal.x)^2 + (v.y-goal.y)^2}</tex>.

Также стоит обратить внимание на то как соотносятся <tex>f(v)</tex> и <tex>h(v)</tex>. Если они измеряются в разных величинах (например, <tex>g(v)</tex> {{---}} это расстояние в километрах, а <tex>h(v)</tex> {{---}} оценка времени пути в часах) А* может выдать некорректный результат.

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

[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]
void A*(start,goal)
closed := {}; // Множество вершин расстояние до которых мы уже оценили
open.push(start);// Очередь с приоритетом
f[start] = g[start] + h[start];
parent[start] = start;
while (open.size() != 0)
x := open.pop();
if (x == goal)
return succsess(x);// Кратчайший путь найден
closed.push(x);
for (y : xy in E)
if (y in closed)
continue;
tmp := g[x] + d[x,y] // Стоимость пути до y через х
if (y not in open)
open.push(y);
tentative_is_better = true;
else
if (tmp < g[y]) // можно улучшить расстояние до y
tentative_is_better = true
else
tentative_is_better = false
if (tentative_is_better == true) // найден новый, более короткий путь до y
parent[y] = x;
g[y] = tmp;
f[y] = g[y] + h[y];
return failure; // Наша цель недостижима из start

==Свойства==
===Корректность===
Если <tex>h(v)</tex> всегда меньше либо равна истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм.
{{Теорема
|statement=Пусть G - граф, h(v) - допустимая эвристическая функция. Тогда после завершения работы будет найдено кратчайшее расстояние до целевой вершины.
|proof=Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.
}}

===Оптимальность===
Любой другой алгоритм, использующий ту же эвристическую функцию <tex>h(v)</tex>, рассмотрит не меньше вершин, чем А*.
==Ссылки==
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Википедия:Алгоритм_поиска_A*]
*[http://en.wikipedia.org/wiki/A*_search_algorithm Wikipedia:A*_search_algorithm]
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей]
*[http://dl.acm.org/citation.cfm?id=3830&coll=portal&dl=ACM Generalized best-first search strategies and the optimality of A*]

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

Алгоритм A*

2012-02-28T09:42:10Z

194.85.161.34: /* Корректность */

Алгоритм '''А*'''("A star", "А звёздочка") {{---}} алгоритм поиска, который находит во взвешенном графе маршрут наименьшей стоимости от начальной вершины до выбранной конечной.
==Описание==
В процессе работы алгоритма для вершин рассчитывается функция <tex>f(v) = g(v) + h(v)</tex>, где
*<tex>g(v)</tex> {{---}} наименьшая стоимость пути в <tex>v</tex> из стартовой вершины,
*<tex>h(v)</tex> {{---}} эвристическое приближение стоимости пути от <tex>v</tex> до конечной цели. <tex>h(v)</tex> должна быть эвристически допустимой, то есть не должна переоценивать рассояние до цели.
Чем меньше , тем раньше вершина будет открыта и исследована алгоритмом. Таким образом открытые алгоритмом вершины хранятся в очереди с приоритетом по значению <tex>f(v)</tex>. А* действует подобно [[Алгоритм Дейкстры | алгоритму Дейкстры]] и просматривает среди всех маршрутов ведущих к цели сначала те, которые благодаря имеющейся информации(эвристическая функция) в данный момент являются наилучшими.

Поведение алгоритма сильно зависит от того, какая эвристика используется. В свою очередь, выбор эвристики зависит[[Файл:Diagonal.png|thumb|right|Пример А* на сетке с возможностью ходить в восьми напрвлениях]] от постановки задачи. Часто А* используется для моделирования перемещения по поверхности, покрытой [http://deep-beta.co.uk/wp-content/uploads/2010/11/terrain.0.3+grid.png координатной сеткой].

* Если мы можем перемещаться в четырех направлениях, в качестве эвристики стоит выбрать [http://en.wikipedia.org/wiki/Manhattan_distance манхэттенское расстояние] <tex>h(v) = |{v.x-goal.x}| + |{v.y-goal.y}|</tex>.

* [http://ru.wikipedia.org/wiki/Расстояние_Чебышева Расстояние Чебышева] применяется когда к четырем направлениям добавляются диагонали: <tex>h(v) = \max{(|{v.x-goal.x}|, |{v.y-goal.y}|)}</tex>.

* Если передвижение не ограниченно сеткой, то можно использовать евклидово расстояние по прямой: <tex>h(v) = \sqrt{(v.x-goal.x)^2 + (v.y-goal.y)^2}</tex>.

Также стоит обратить внимание на то как соотносятся <tex>f(v)</tex> и <tex>h(v)</tex>. Если они измеряются в разных величинах (например, <tex>g(v)</tex> {{---}} это расстояние в километрах, а <tex>h(v)</tex> {{---}} оценка времени пути в часах) А* может выдать некорректный результат.

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

[[Файл:Astar_progress_animation.gif|thumb|right|Пример работы А*. Пустые кружки принадлежат к открытому списку, а окрашенные к закрытому.]]
void A*(start,goal)
{
closed := {}; // Множество вершин расстояние до которых мы уже оценили
open.push(start);// Очередь с приоритетом
f[start] = g[start] + h[start];
parent[start] = start;
while (open.size() != 0)
{
x := open.pop();
if (x == goal)
return succsess(x);// Кратчайший путь найден
closed.push(x);
for (y : xy in E)
{
if (y in closed)
continue;
tmp := g[x] + d[x,y] // Стоимость пути до y через х
if (y not in open)
{
open.push(y);
tentative_is_better = true;
}
else
if (tmp < g[y]) // можно улучшить расстояние до y
tentative_is_better = true
else
tentative_is_better = false
if (tentative_is_better == true) // найден новый, более короткий путь до y
{
parent[y] = x;
g[y] = tmp;
f[y] = g[y] + h[y];
}
}
}
return failure; // Наша цель недостижима из start
}
==Свойства==
===Корректность===
Если <tex>h(v)</tex> всегда меньше либо равна истинной стоимости пути до цели, то А* гарантированно найдет кратчайший путь, причем чем меньше разница между эвристикой и истинной стоимостью, тем меньше вершин рассмотрит алгоритм.
{{Теорема
|statement=Пусть G - граф, h(v) - допустимая эвристическая функция. Тогда после завершения работы будет найдено кратчайшее расстояние до целевой вершины.
|proof=Когда A* завершает поиск, он, согласно определению, нашёл путь, истинная стоимость которого меньше, чем оценка стоимости любого пути через любой открытый узел. Но поскольку эти оценки являются оптимистичными, соответствующие узлы можно без сомнений отбросить. Иначе говоря, A* никогда не упустит возможности минимизировать длину пути, и потому является допустимым.
}}

===Оптимальность===
Любой другой алгоритм, использующий ту же эвристическую функцию <tex>h(v)</tex>, рассмотрит не меньше вершин, чем А*.
==Ссылки==
*[http://ru.wikipedia.org/wiki/Алгоритм_поиска_A* Википедия:Алгоритм_поиска_A*]
*[http://en.wikipedia.org/wiki/A*_search_algorithm Wikipedia:A*_search_algorithm]
*[http://theory.stanford.edu/~amitp/GameProgramming/ Статья о поиске кратчайших путей]
*[http://dl.acm.org/citation.cfm?id=3830&coll=portal&dl=ACM Generalized best-first search strategies and the optimality of A*]

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