Изменения

В основу алгоритма положем метод [[Файл:Status_line.png|200px|thumb|right|Заметающая прямая и события]] Воспользуемся методом заметающей прямой (sweep line), которая будет расположена расположенной горизонтально и двигаться двигающейся вниз (в сторону уменьшения y-координаты). Нас будут интересовать события (events, event points) трёх типов:

причем о событиях первых двух типов мы знаем заранее, а события, являющиеся пересечением отрезков, будут обнаружены и добавлены в множество необработанных событий динамически. Причём будем Будем считать, что если у двух точек равные ординаты, то выше та, что лежит левее. Таким образом верхним концом горизонтального отрезка, в силу введенного порядка, является его левый конец. Это даст нам корректную обработку вырожденного случая, когда отрезок горизонтален.  [[Файл:Sweep_line_slight_rotation.png|200px|thumb|right|Приоритет событий]] Можно представить, что заметающая прямая не горизонтальна, а повернута на малый угол против часовой стрелки, поэтому не существует такой конфигурации, что на ней лежит больше одного события (мы, для удобства, считаем точку пересечения трёх или более отрезков одним событием), а события с равными ординатами обрабатываются слева направо.

Во-первых, мы будем хранить очередь событий <tex>Q</tex> в виде сбалансированного бинарного дерева поиска, что позволит извлекать следующее событие и вставлять новое событие в очередь за <tex>O(\log{m})</tex>, где <tex>m</tex> {{---}} количество элементов в очереди. Дерево будет отсортировано согласно порядку, введённому выше. Причем Причём вместе с каждым событием мы будем хранить список отрезков, верхней точкой которых он является. Во вторых, будем хранить статус <tex>T</tex> заметающей прямой: множество отрезков, пересекающих заметающую прямую в данный момент времени, упорядоченных слева направо. От статуса нам потребуется оптимальные вставка и удаление отрезков, поэтому по-прежнему удобно воспользоваться бинарным деревом поиска. {|border="0" cellpadding="5" width=30% align=center|[[Файл: Status_structure.png|thumb|250px|center|Статус заметающей прямой]]|[[Файл: Neighbour_segments.png|thumb|250px|center|Соседние отрезки в статусе]]||} Главная идея заключается в том, что мы будем проверять, пересекаются ли два отрезка, если они являются соседними в статусе. Это означает, что каждый отрезок мы будем проверять на пересечение с его левым и правым соседями в статусе. Далее, по ходу выполнения алгоритма, у отрезка могут измениться соседи; когда это происходит мы снова проверяем, не пересекает ли отрезок его новых соседей в статусе? Далее приведен псевдокод алгоритма, а ниже подробно расписана обработка события определенного типа.  findIntersections(S) Инициализировать Q и T '''for''' s '''in''' S вставить концы s в Q (вместе с верхним концом вставить сам s) '''while''' not Q.empty() p = Q.pop() handleEventPoint(p) Рассмотрим обработку событий.

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

Главная идея заключается * Пересечение отрезков. Если событие {{---}} это точка пересечения двух отрезков, то эти отрезки меняют порядок и у каждого появляется, возможно, новый сосед. Мы проверим каждую пару новых соседей в томстатусе на пересечение. По-прежнему нас интересуют только пересечения ниже заметающей прямой. Отметим отдельно, что в этом случае найденные пересечения могли уже быть обнаружены ранее (когда пересекающиеся отрезки были соседними в статусе). * Нижний конец отрезка. В этом случае мы будем тестировать удалим отрезок из статуса и проверим пару отрезков ставших соседними на пересечение. Как и в предыдущем случае, обнаруженные пересечения могут уже находиться в очереди. {|border="0" cellpadding="5" width=30% align=center|[[Файл:Upper_and_intersection.png|thumb|250px|center|Обработка верхних концов и пересечений]]|[[Файл:Lower.png|thumb|250px|center|Обработка нижних концов]]||} Как было сказано выше, мы интерпретируем пересечение более двух отрезков в одной точке как одно событие. В этом случае обработка несколько сложнее (стоит пристально посмотреть на псевдокод и рисунок {{---}} и убедиться, если что алгоритм корректно обрабатывает такие события). Псевдокод функции обработки события:  handleEventPoint(p) U(p) = множество отрезков, верхний конец которых есть p // Напомним, что мы храним такие отрезки в Q вместе c p // Далее найдём в T все отрезки, которые содержат p (они являются будут соседними в статуседереве) L(p) = множество отрезков, нижний конец которых есть p C(p) = множество отрезков, содержащих внутри себя p '''if''' <tex> \vert L(p) \cup C(p) \cup U(p) \vert > 1</tex> report(p, <tex>L(p) \cup C(p) \cup U(p)</tex>) // сообщить о p как о точки пересечения отрезков <tex>L(p) \cup C(p) \cup U(p)</tex> T.remove(<tex>L(p) \cup C(p)</tex>) T. Далее приведен псевдокод алгоритмаinsert(<tex>C(p) \cup U(p)</tex>) // отрезки должны быть вставлены в порядке, // в котором они пересекают горизонтальную линию, // лежащую немного ниже заметающей прямой // (при удалении-вставке отрезков из C(p) - те поменяют порядок на обратный '''if''' <tex>C(p) \cup U(p) = \emptyset</tex> s_l = левый сосед p в T s_r = правый сосед p в T findIntersection(s_l, s_r, p) '''else''' s1 = самый левый отрезок из <tex>C(p) \cup U(p)</tex> в T s_l = левый сосед s1 в T findIntersection(s_l, s1, p) s2 = самый правый отрезок из <tex>C(p) \cup U(p)</tex> в T s_r = правый сосед s2 в T findIntersection(s2, s_r, p)  findIntersection(s_l, s_r, p) '''if''' not intersects(s_l, а s_r) '''return''' x = точка пересечения s_l и s_r '''if''' x лежит ниже подробно расписана обработка заметающей прямой или на ней справа от p Q.insert(x) // должно работать корректно, если x уже есть в Q  {|border="0" cellpadding="5" width=30% align=center|[[Файл:Mantaining_status.png|thumb|450px|center|Поддержание статуса при обработке события определенного типа.]]||}

{{Теорема |statement=Время работы алгоритма {{---}} <tex>O((n+I)\log{n})</tex>, где <tex>I</tex> {{---}} количество пересечений.||proof= СмИнициализация <tex>Q</tex> может быть выполнена за <tex>O(n\log{n})</tex>, инициализация <tex>T</tex> {{---}} за <tex>O(1)</tex>. Далее, по ходу алгоритма мы обрабатываем каждое событие. Обработка включает в себя удаление события (<tex>O(\log{n})</tex>), вызов функции findIntersection до двух раз, что может вызвать вставку новых событий <tex>O(\log{n})</tex>. Также при обработке события <tex>p</tex> мы <tex>m(p) = \vert L(p) \cup C(p) \cup U(p) \vert</tex> раз выполняем операции вставки, удаления, поиска над <tex>T</tex>. Каждая из этих операций требует <tex>O(\log{n})</tex> времени. Пусть <tex>m = \sum_{p} {m(p)}</tex>. Тогда время работы алгоритма {{---}} <tex>O(m\log{n})</tex> Покажем, что <tex>m = O(n + I)</tex>, где <tex>I</tex> {{---}} количество пересечений. Для этого рассмотрим планарный граф, вершинами которого являются концы отрезков, а также их точки пересечения, а ребрами {{---}} части отрезков, их соединяющие. Рассмотрим событие <tex>p</tex>. Ему соответствует вершина графа со степенью <tex>O(m(p))</tex>, следовательно <tex>m =O(\sum_{p} {deg(p)}) =O(E) = O(V) = O(2n + I)</tex>, где <tex>deg(p)</tex> {{---}} степень <tex>p</tex>, <tex>E</tex> {{---}} число ребер в графе, <tex>V</tex> {{---}} число вершин. (Предпоследний переход следует из формулы Эйлера.)* [[Алгоритм Бентли-Оттмана]]Итак, время работы алгоритма: <tex>O((n+I)\log{n})</tex>.}} == Объём памяти == Очевидно, что статус в худшем случае занимает <tex>O(n)</tex> памяти, однако очередь событий может занимать <tex>O(n + I)</tex> памяти. Если модифицировать алгоритм так, что в очереди будут храниться только точки пересечения отрезков, соседних в статусе, то объём используемой памяти сократится до <tex>O(n)</tex>. Для этого нужно удалять точки пересечения отрезков, которые перестали быть соседними. Перед тем, как мы дойдём до точки удаленной точки, обязательно найдётся соседняя в статусе пара отрезков, которые пересекаются в этой точке, и она снова будет вставлена в очередь. Ясно, что такая оптимизация не влияет на время работы алгоритма.