Просмотр исходного текста страницы Skip quadtree: определение, время работы

== Описание ==
[[Файл:Skip_quadtree.png | 500px | thumb]]
Skip quadtree {{---}} структура данных, напоминающая [[Список с пропусками | skip-list]], которая позволяет эффективно локализоваться и производить операции над множеством точек.

В данной статье будет рассматриваться только рандомизированая версия этой структуры.

The randomized skip quadtree {{---}} последовательность сжатых квадродеревьев над последовательностью подмножеств некоторого исходного множества точек <tex>S</tex>. <tex>S_0 = S</tex>, в <tex>S_i</tex> каждый элемент из <tex>S_{i-1}</tex> входит с вероятностью <tex>p \in (0, 1)</tex>, то есть <tex>S_i \subset S_{i-1}</tex>. The randomized skip quadtree состоит из последовательности <tex>\{Q_i\}</tex>, где <tex>Q_i</tex> {{---}} [[Квадродеревья#Сжатое квадродерево | сжатое квадродерево]] над множеством <tex>S_i</tex>. Будем называть эти квадродеревья уровнями, при этом нулевой уровень содержит в точности точки из <tex>S</tex>.

На рисунке представлено дерево, состоящее из трех слоев: <tex>Q_0</tex>, <tex>Q_1</tex>, <tex>Q_2</tex>. Одинаковые вершины, находящиеся на разных уровнях, соединены линиями. Стрелками обозначены переходы в процессе локализации при поиске точки <tex>y</tex>.

Любая вершина однозначно определяется своими координатами на каждом уровне. Поэтому по вершине с уровня <tex>i</tex> мы можем получить ее на уровне <tex>i - 1</tex>, если она [[Квадродеревья и перечисление точек в произвольном прямоугольнике (статика)#interesting | интересная]] на уровне <tex>i</tex>, так как в противном случае она могла быть сжата. 

Заметим, что если какой-то квадрат интересный в <tex>Q_i</tex>, то он интересный и в <tex>Q_{i-1}</tex>, так как <tex>S_i \subset S_{i-1}</tex> по определению структуры.

== Операции над skip quadtree ==
Для реализации операций нам нужно уметь получать по вершине с уровня <tex>i</tex> соответствующую ей вершину с уровня <tex>i - 1</tex>. Сделать это можно двумя способами:
* Хранить в вершине ссылку на вершину уровнем ниже.
* Так как каждая вершина однозначно задается своими координатами, можем сопоставить ей маску. Используем ассоциативный массив, чтобы по маске получать ссылку на вершину. Такие массивы будем хранить для каждого уровня skip quadtree.

===Локализация===
Локализация выполняется аналогично локализации в сжатом квадродереве. Под локализацией подразумевается, что мы хотим найти минимальный интересный квадрат, геометрически содержащий данную точку. Сначала локализуемся в квадродереве наибольшего уровня, начиная с его корня. Затем локализуемся в квадродереве уровнем ниже, начиная уже не с корня, а с того квадрата, который нашли на прошлом уровне. Но на каждом уровне, кроме нулевого, локализумся не до листа, а до глубочайшего интересного. Продолжаем, пока не дойдём до нулевого уровня.

===Вставка===
При вставке сначала локализуемся сразу на всех уровнях, запоминая ссылки, дальше добавляем вершину на нулевой уровень, затем с вероятностью <tex>p</tex> добавляемся на уровень выше и так далее до первого недобавления. При этом количество уровней может увеличиться максимум на <tex>1</tex>, то есть, если появился новый уровень, то процесс заканчивается.

===Удаление===
При удалении локализуемся и удаляем вершину со всех уровней, на которых она есть, не забывая обновлять ссылки или ассоциативный массив. При этом какой-то уровень мог стать пустым, в таком случае выкинем его.

== Время работы и память ==

{{Лемма
|about=
О количестве шагов на одном уровне
|statement=
На каждом уровне в среднем совершается <tex>O(1)</tex> шагов поиска для любой точки <tex>x</tex>.
|proof=
Пусть в <tex>Q_i</tex> (то есть на <tex>i</tex>-ом уровне) поиск точки <tex>x</tex>, начинающийся с корня, проходит по квадратам <tex>p_0, p_1, \dots, p_m</tex>. Пусть случайная величина <tex>j</tex> {{---}} количество шагов поиска в <tex>Q_i</tex>, тогда <tex>p_{m - j}</tex> {{---}} последний квадрат из <tex>p_0, p_1, \dots, p_m</tex>, являющийся интересным в <tex>Q_{i + 1}</tex>.

Оценим вероятность того, что делается <tex>j</tex> шагов. Забьём на случай <tex>j = 0</tex>, так как он не важен при расчёте мат. ожидания. На пути <tex>p_{m - j + 1} \dots, p_m</tex> будет хотя бы <tex>j + 1</tex> непустых четвертинок. У первого квадрата на этом пути есть хотя бы 2 непустые четвертинки, одна из них {{---}} следующий квадрат на пути, в котором тоже хотя бы 2 непустые четвертинки, и так далее. В последнем квадрате просто хотя бы 2 непустые четвертинки. Чтобы 
<tex>p_{m - j}</tex> был последним из <tex>p_0, p_1, \dots, p_m</tex> интересным квадратом в <tex>Q_{i + 1}</tex> небходимо, чтобы среди этих как минимум <tex>j + 1</tex> непустых четвертинок только одна (вероятность этого назовём <tex>Pr_1</tex>) или ноль (вероятность этого назовём <tex>Pr_0</tex>) были непустыми в <tex>Q_{i + 1}</tex>. Иначе, если будет хотя бы пара непустых четвертинок, то их наименьший общий предок в дереве будет интересным квадратом и будет находиться глубже <tex>p_{m - j}</tex>. Таким образом, искомая вероятность не превосходит <tex>Pr_0 + Pr_1</tex>.


<tex>q = 1 - p</tex>

<tex>Pr_0 \leq q^{(j + 1)}</tex>, потому что это в сущности вероятность того, что ни одна точка из как минимум <tex>j + 1</tex> непустых четвертинок не попала на уровень выше.

<tex>Pr_1 \leq (j + 1) \cdot pq^j</tex>, потому что это в сущности вероятность того, что ровно одна точка из как минимум <tex>j + 1</tex> непустых четвертинок попала на уровень выше.


<tex>E(j) = \sum\limits_{j = 1}^{m} j \cdot Pr(j) \leq \sum\limits_{j = 1}^{m} j \cdot (q^{(j + 1)} + (j + 1) \cdot pq^j) \leq \sum\limits_{j = 1}^{\infty} j \cdot (q^{(j + 1)} + (j + 1) \cdot pq^j)</tex>

Это почти геометрическая прогрессия, только на полином домножили, определяется всё экспоненциальным множителем, так что это <tex>O(1)</tex>. Можно совсем строго оценить, но и так понятно, что ряд сходится, а сойтись он может только к константе.
}}

{{Лемма
|about=
О количестве уровней
|statement=
Математическое ожидание количества уровней составляет <tex>O(\log(n))</tex>
|proof=
Для оценки мат. ожидания посчитаем вероятность того, что количество уровней <tex>h</tex> равно <tex>k</tex>.

<tex>p(h = k) = 1 - p(h > k) - p(h < k)</tex>.

<tex>p(h < k) = (1 - p^{k})^n</tex>, потому что вероятность того, что точка дойдёт до уровня <tex>k</tex>, равна <tex>p^{k}</tex>.

<tex>p(h > k) = (1 - (1 - p^{k + 1})^n)</tex>, потому что вероятность того, что точка не дойдёт до уровня <tex>k + 1</tex>, равна <tex>1 - p^{k + 1}</tex>.

<tex>p(h = k) = 1 - p(h > k) - p(h < k) = 1 - (1 - (1 - p^{k + 1})^n) - (1 - p^{k})^n = (1 - p^{k + 1})^n - (1 - p^k)^n \leq 1 - (1 - p^k)^n \leq np^k</tex>

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

<tex>E(h) = \sum\limits_{k = 1}^{\infty} k \cdot p(h = k) = p(1) \cdot 1 + \dots + p(\log_{1/p} n) \cdot \log_{1/p} n + \sum\limits_{k = \log_{1/p} n + 1}^{\infty} k \cdot p(k)</tex>

Оценим первую сумму:

<tex>p(1) \cdot 1 + \dots + p(\log_{1/p} n) \cdot \log_{1/p} n \leq p(1) \cdot \log_{1/p} n + \dots + p(\log_{1/p} n) \cdot \log_{1/p} n = O(\log(n))</tex>, поскольку сумма этих вероятностей не превосходит единицу.

Оценим вторую сумму:

<tex>\sum\limits_{k = \log_{1/p} n + 1}^{\infty} k \cdot p(k) = \leq \sum\limits_{k = \log_{1/p} n}^{\infty} k \cdot n p^k = n \cdot \sum\limits_{k = \log_{1/p} n}^{\infty} k \cdot p^k</tex>

Рассмотрим эту сумму:

<tex>\sum\limits_{k = \log_{1/p} n}^{\infty} k \cdot p^k = p^{\log_{1/p} n} \cdot \sum\limits_{k = 0}^{\infty} (k + \log_{1/p} n) \cdot p^k = p^{\log_{1/p} n} \cdot (\sum\limits_{k = 0}^{\infty} (k p^k) + \log_{1/p} n \cdot \sum\limits_{k = 0}^{\infty} (p^k)) =  p^{\log_{1/p} n} \cdot (O(1) + \log_{1/p} n \cdot O(1)) = 1/n \cdot O(\log(n))</tex>

Суммируя всё вышесказанное, получаем, что <tex>O(\log(n))</tex>.

''Для лучшего понимания можно представлять, что <tex>p = 1/2</tex>.''
}}

{{Теорема
|about=
О времени работы
|statement=
Поиск, добавление и удаление точки работают за <tex>O(\log(n))</tex> в среднем.
|proof=
Напрямую следует из двух предыдущих лемм.
}}

{{Теорема
|about=
О занимаемой памяти
|statement=
Математическое ожидание занимаемой памяти {{---}} <tex>O(n)</tex>.
|proof=
Сжатое квадродерево для <tex>n</tex> точек занимает <tex>O(n)</tex> памяти. На нулевом уровне <tex>n</tex> точек. На следующем уровне <tex>p \cdot n</tex> точек, дальше <tex>p^2 \cdot n</tex> и так далее. Получим геометрическую прогрессию, в итоге <tex>O(n)</tex> памяти.
}}

==Запрос точек в прямоугольнике==
Задача: нам дается прямоугольник, нужно выдать все точки, лежащие в нем. 

Реализация запроса на сжатом квадродереве занимает <tex>O(n)</tex> времени. Используем skip quadtree для ускорения поиска. Для этого ослабим условие задачи, тогда skip quadtree позволит очень быстро (асимптотически) отвечать на такие запросы. 

Ослабление: расширим данный прямоугольник на <tex>\varepsilon</tex>.
Тогда в ответ могут попасть точки не из данного прямоугольника, но лежащие внутри <tex>\varepsilon</tex>-области. В большинстве практических задач данное ослабление не ухудшит конечный результат, а только ускорит процесс.

Skip quadtree позволяет отвечать на запрос всех точек, лежащих в прямоугольнике, окруженном <tex>\varepsilon</tex>-областью, за <tex>O(\varepsilon^{-1} \cdot \log n + k)</tex>, где <tex>k</tex> {{---}} число точек в ответе. Алгоритм можно модифицировать для ответа на запрос точек в любой выпуклой фигуре.

Обозначим наш прямоугольник <tex>R</tex>. Тогда <tex>\varepsilon</tex>-область {{---}} область <tex>E</tex>, охватывающая <tex>R</tex>, граница которой удалена от его сторон на <tex>\varepsilon</tex>.

[[Файл:Skip_quadtree_rect.png|right|400px]] 
Данный прямоугольник <tex>R</tex> разбивает вершины на следующие классы:
* <tex>\mathrm{in}</tex> {{---}} ''внутренние'', то есть лежащие внутри <tex>\varepsilon</tex>-области (1 и 6 на рисунке).
* <tex>\mathrm{out}</tex> {{---}} ''внешние'', то есть лежащие вне прямоугольника <tex>R</tex> (2 на рисунке).
* <tex>\mathrm{stabbing}</tex> {{---}} ''пронзающие'', пересекающие <tex>R</tex>, но не являющиеся ''внутренними'' (3, 4 и 5 на рисунке).

Для вершин из классов <tex>\mathrm{in}</tex> и <tex>\mathrm{out}</tex> ответ на запрос находится тривиально {{---}} все поддерево вершины и никакие точки из поддерева соответственно; сложность представляют вершины из класса <tex>\mathrm{stabbing}</tex>. Зная их все, мы можем ответить на запрос. 

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

Назовем ''пронзающую'' вершину ''критической'', если для каждого из ее детей выполняется одно из двух условий:
* ребенок не является ''пронзающей'' вершиной.
* ребенок является ''пронзающим'', но содержит меньшую часть <tex>E</tex>, чем рассматриваемая вершина. 

На рисунке среди вершин 3, 4, 5, 6 только 5 является ''критической''.

Вместо поиска всех ''пронзающих'' вершин, для решения задачи достаточно найти все ''критические'' вершины.

{{Лемма
|about=
Об упаковке
|statement=
Количество ''критически''х вершин на нулевом уровне дерева равно <tex>O(\varepsilon^{-1})</tex>. 
|proof=
Для квадратов с длиной стороны <tex>\varepsilon</tex> верно, что они либо <tex>\mathrm{in}</tex>, либо <tex>\mathrm{out}</tex>, то есть <tex>\mathrm{stabbing}</tex> вершин с такой стороной не бывает, как и со стороной меньше <tex>\varepsilon</tex>.

Все точки, содержащиеся в skip quadtree, находятся внутри какого-то прямоугольника, значит, длина его стороны {{---}} константа. Поэтому длина стороны области пересечения запрашиваемого прямоугольника со skip quadtree {{---}} это тоже константа. Тогда длина стороны запрашиваемого прямоугольника {{---}} <tex>O(1)</tex>.

''Пронзающих'' вершин c длиной стороны чуть больше <tex>\varepsilon</tex>, области которых не пересекаются, может быть <tex>O(\varepsilon^{-1})</tex> {{---}} длина стороны прямоугольника, деленная на <tex>\varepsilon</tex>. Тогда всего их может быть <tex>\varepsilon^{-1} + \genfrac{}{}{}{0}{1}{2} \cdot \varepsilon^{-1} + \genfrac{}{}{}{0}{1}{4} \cdot \varepsilon^{-1} + \dots \  = \ O(\varepsilon^{-1})</tex>, так как пронзающие вершины могут быть вложенными, и длина стороны родителя в два раза больше, чем у ребенка, то количество родителей вершин с такой стороной в два раза меньше.

''Критических'' вершин не больше, чем ''пронзающих'', так что их тоже <tex>O(\varepsilon^{-1})</tex>.
}}

===Алгоритм===
Начинаем отвечать на запрос с корня <tex>Q_0</tex> и определяем тип вершин.
* Если вершина ''внутренняя'', добавляем ее в ответ вместе с поддеревом.
* Если ''внешняя'', то игнорируем.
* Если ''критическая'', то рассмотрим всех ее детей.
* Если не ''критическая'', то найдем минимальную ''критическую'', содержащую ту же часть <tex>E</tex>, что и рассматриваемая вершина.

Первые три варианта рассматриваются тривиально. Покажем, как для данной некритической вершины <tex>p</tex> найти минимальную критическую вершину <tex>q</tex>, содержащую ту же часть <tex>E</tex>, что и <tex>p</tex>. Для это найдем такое <tex>Q_i</tex>, что <tex>p</tex> будет ''критической'' вершиной в <tex>Q_i</tex> при максимальном <tex>i</tex>. И будем действовать аналогично процессу локализации. 

Таким образом, поиск <tex>q</tex> займет <tex>O(\log n)</tex> времени. А так как ''критических'' вершин всего <tex>O(\varepsilon^{-1})</tex>, то итоговая ассимптотика составит <tex>O(\varepsilon^{-1} \cdot \log n + k)</tex>.

===Псевдокод===
    '''void''' points_in_rectangle('''rectangle''' R, '''rectangle''' E, '''vector<point>&''' points)
        '''queue<node>''' que
        que.push(<tex>Q_0</tex>.root)
        '''while''' (!que.empty())
            '''node''' n = que.pop()
            '''rectangle''' K // прямоугольник, соответсвующий вершине n
            '''if''' (R <tex>\cap</tex> K == <tex>\varnothing</tex>) 
                '''continue'''
            '''else if''' (n is leaf)
                '''if''' (n.point in R)
                    points.push_back(n.point)
            '''else if''' (K <tex>\subset</tex> E) 
                n.add_subtree(points) // добавляем все точки поддерева ''внутренней'' вершины
            '''else if''' (n is not critical)
                '''node''' q // некритическая вершина на максимальном уровне, соответствующая n
                level = k - 1 // максимальный уровень, на котором вершина q некритическая
                // k - количество уровней в skip quadtree
                '''while''' (level > 0)
                    node <tex>n_{level}</tex> = n from <tex>Q_{level}</tex> // вершина, соответствующая n в дереве <tex>Q_{level}</tex>
                    '''if''' (<tex>n_{level}</tex> != null '''and''' <tex>n_{level}</tex> is not critical)
                        q = <tex>n_{level}</tex>
                        '''break'''
                    level--
                '''while''' (true)
                    '''if''' (q is not critical)
                        '''node''' qc = ребенок q, содержащий ту же область E, что и q
                        '''if''' (qc is not leaf '''or''' level == 0)
                            q = qc
                        '''else if''' (level > 0)
                            level--
                            q = q from <tex>Q_{level}</tex>
                    '''else if''' (level != 0)
                        level--
                        q = q from <tex>Q_{level}</tex>
                    '''else''' 
                        '''break'''
                que.push(q)
            '''else'''
                que.add_all(n.children)

== Источник ==
* http://arxiv.org/pdf/cs.cg/0507049.pdf
* http://www.ics.uci.edu/~goodrich/pubs/skip.pdf

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