Ортогональный поиск

НЕТ ВОЙНЕ

24 февраля 2022 года российское руководство во главе с Владимиром Путиным развязало агрессивную войну против Украины. В глазах всего мира это военное преступление совершено от лица всей страны, всех россиян. Будучи гражданами Российской Федерации, мы против своей воли оказались ответственными за нарушение международного права, военное вторжение и массовую гибель людей. Чудовищность совершенного преступления не оставляет возможности промолчать или ограничиться пассивным несогласием. Мы убеждены в абсолютной ценности человеческой жизни, в незыблемости прав и свобод личности. Режим Путина — угроза этим ценностям. Наша задача — обьединить все силы для сопротивления ей. Эту войну начали не россияне, а обезумевший диктатор. И наш гражданский долг — сделать всё, чтобы её остановить. Антивоенный комитет России

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

meduza.io, Популярная политика, Новая газета, zona.media, Майкл Наки.

Пусть задано множество точек [math]S[/math] из пространства [math]\mathbb R^n[/math]. Пусть односвязная область [math]R \subset \mathbb R^n[/math] такова, что её границы ортогональны координатным прямым. Требуется определить множество точек [math]S' \subset S[/math], лежащих в области [math]R[/math].

Одномерный случай

Пусть дана прямая с точками на ней и отрезок. Необходимо указать, какие из точек лежат на этом отрезке.

Задача тривиальна — нужно оставить только те точки, которые лежат между началом и концом отрезка.

На практике для быстрого осуществления запроса нужно хранить точки в отсортированном массиве и пользоваться двоичным поиском. В C++ данная задача решается с помощью функций из STL - upper_bound и lower_bound.

lower_bound возвращает итератор на первый элемент, больший либо равный данного.
upper_bound возвращает итератор на первый элемент множества со значением, большим данного.

Рассмотрим на примере:

Код реализации:

template<class RauIter, class OutIter, class Scalar> OutIter range_search(RauIter p, RauIter q, OutIter out)
{
   return std::copy(lower_bound(p, q, l), upper_bound(p, q, r), out);
}

Алгоритм работает за [math]O(\log n + T)[/math], где [math]T[/math] - количество точек в ответе.

Примечание: Если задача сформулирована так, что нужно вывести все искомые точки, то запрос не может выполняться быстрее, чем за [math]O(T)[/math]. Однако, далеко не во всех задачах ортогонального поиска нужно получать все точки в явном виде. Поэтому далее время, необходимое для вывода полного ответа, будет опускаться в оценке времени запроса.

Двумерный случай

Пусть дано некоторое множество точек на плоскости. Нам необходимо ответить, какие именно из них лежат в некотором заданном прямоугольнике.

Для этого возьмем любое сбалансированное дерево поиска и наполним его точками [math](x, y)[/math] из множества. В качестве ключа будет использоваться [math]x[/math]-координата точки. Теперь модернизируем дерево: в каждой вершине дерева будем хранить отсортированный по [math]y[/math]-координате массив точек, которые содержатся в соответствующем поддереве.
Рассмотрим на примере:

Рассмотрим, как в такой структуре данных будет выглядеть поиск множества точек, находящихся в заданном прямоугольнике [math][x_{min}, x_{max}] \times [y_{min}, y_{max}][/math]. Для начала, найдем в дереве те точки, [math]x[/math]-координата которых лежит в интервале [math][x_{min}, x_{max}][/math]. Сделаем это следующим образом:

1. Найдем в дереве поиска вершины с минимальной и максимальной [math]x[/math]-координатой из прямоугольника запроса, добавим их в искомое множество, обозначим их как [math]v_l[/math] и [math]v_r[/math].
2. Добавим в искомое множество их наименьшего общего предка [math]v_n[/math].
3. Для каждой из промежуточных вершин [math]v_i[/math] на восходящем пути [math]v_l \to v_n[/math] зафиксируем, из какого ребенка мы поднялись в вершину [math]v_i[/math]. Если мы поднялись из левого сына, то добавим в искомое множество саму вершину [math]v_i[/math], а также множество точек, находящихся в поддереве правого сына вершины [math]v_i[/math]. Если же мы поднялись из правого сына, то не добавляем ничего.
4. Повторим процесс для пути [math]v_r \to v_n[/math]. Здесь ориентация сторон инвертирована: будем пополнять множество в том случае, если мы поднялись из правого сына.

Пример процесса показан на иллюстрации:

В итоге, в множество мы добавим [math]O(\log n)[/math] вершин и [math]O(\log n)[/math] поддеревьев дерева поиска. Теперь нужно просеять полученное множество — извлечь из него те элементы, [math]y[/math]-координата которых не лежит в интервале [math][y_{min}, y_{max}][/math]. Для точек это сделать просто — нужно вручную проверить, лежит ли [math]y[/math]-координата в нужном интервале. Для каждого из полученных поддеревьев обратимся к массиву содержащихся в нем точек и запустим от него приведенную выше функцию [math]range{\_}search(y_{min}, y_{max})[/math]. Все полученные таким образом точки и будут составлять ответ.
Каждая из функций [math]range{\_}search(y_{min}, y_{max})[/math] будет работать в худшем случае за [math]O(\log n)[/math], отсюда получаем итоговое время выполнения запроса [math]O(\log^2 n)[/math]. Что касается памяти, то в сбалансированном дереве поиска [math]O(\log n)[/math] слоев, а каждый слой хранит массивы, содержащие в сумме ровно [math]n[/math] точек, соответственно вся структура в целом занимает [math]O(n\log n)[/math] памяти.

Обобщение для p-мерного пространства

Такую структуру данных можно при необходимости обобщить на случай большей размерности. Пусть у нас есть множество точек из [math]p[/math]-мерного пространства, каждая из которых представляется как [math]n[/math] координатных чисел: [math](\xi_1, \xi_2, ... , \xi_p)[/math]. Тогда, строя дерево поиска по координате [math]\xi_i[/math], в каждой вершине будем хранить другое дерево поиска с ключом [math]\xi_{i+1}[/math], составленное из точек, лежащих в соответствующем поддереве. В дереве поиска, составленном по предпоследней координате [math]\xi_{p-1}[/math], уже не будет необходимости хранить в каждой вершине целое дерево, поскольку при переходе на последнюю координату [math]\xi_{p}[/math] дальнейший поиск производиться не будет, поэтому в вершинах будем хранить массивы, так же, как и в двумерном случае. Оценим занимаемую память и время запроса: при добавлении следующей координаты асимптотика обеих величин умножается на [math]\log n[/math]. Отсюда, получаем оценку [math]O(\log^{p} n)[/math] на время запроса и [math]O(n\log^{p-1} n)[/math] на занимаемую память.

Такой же результат можно получить с помощью сжатого многомерного дерева отрезков.

Ускорение запроса

Для ускорения запроса можно "прошить" дерево поиска по предпоследней координате, а именно: каждый элемент массива, сохраненного в какой-либо вершине, соединить с элементами массивов, сохраненных в вершинах-детях. Соединять будем по следующему принципу: элемент [math](x, y)[/math] массива-предка соединим с элементами [math]upper\_bound(y)[/math] и [math]lower\_bound(y)[/math] каждого массива-ребенка. Ниже представлен пример соединения корня с его левым сыном:

Для выполнения завершающей фазы поиска нам достаточно будет посчитать [math]upper\_bound()[/math] и [math]lower\_bound()[/math] только на массиве, привязанному к корню дерева. Для получения границ на других массивах можно будет просто спуститься по ссылкам. Заметим, что все вершины, к массивам которых нужно перейти, смежны с какой-либо из вершин путей [math]v_l \to v_n[/math] или [math]v_r \to v_n[/math]. Отсюда следует, что число спусков оценивается как [math]O(length(v_l \to v_n) + length(v_r \to v_n)) = O(\log n)[/math].
Таким образом, поиск теперь будет выполняться за [math]O(\log^{p-1} n)[/math], где [math]p[/math] — размерность пространства.