Рекомендуемые источники

ИТМО вики-конспекты: Дерево отрезков. Построение

ИТМО вики-конспекты: Реализация запроса в дереве отрезков сверху

ИТМО вики-конспекты: Реализация запроса в дереве отрезков снизу

Habr: Задача RMQ – 2. Дерево отрезков

Вводная

Что если нас часто просят посчитать сумму чисел на некотором подрегионе массива ? Можно сделать наивную реализацию:

int sum(int from, int to, int[] values) { // from - включительно, to - исключительно
    int result = 0;
    for (int i = from; i < to; ++i) {
        result += values[i];
    }
    return result;
}

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

Заметим что . Т.к , и поэтому .

Поэтому достаточно предподсчитать все суммы на префиксе и сохранить в специальный массив prefix_sum[k] = sum(0, k).

Теперь достаточно на запрос ответить разницей двух элементов этого массива: sum(from, to) = prefix_sum[to] - prefix_sum[from - 1].

Но что делать если на подотрезке массива хочется например найти максимальное или минимальное значение? Ведь вычесть из максимума на префиксе максимум на другом префиксе уже не выйдет.

Деревья отрезков

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

Например пусть на подотрезке запрашивается поиск минимума.

Построим дерево следующим образом - на нижнем уровне будет изначальный массив дополненный до ближайшей степени двойки нейтральными-значениями, например в случае поиска минимума это (а в случае поиска суммы это был бы ):

Min segment tree

В каждом родительском узле будем хранить результат на всем соответсвующем подотрезке, т.е. по сути - результат применения целевой операции к результату хранящемуся в двух детских узлах.

Но как хранить и как построить данное дерево? А так же как отвечать на каждый запрос?

Представление дерева

Создадим один массив под все дерево, корень дерева будем хранить под индексом , его детей под индексом и , следующий уровень - , затем и т.д..

Заметим что тогда:

  • У узла под индексом два ребенка находятся в массиве под индексами и .
  • У узла под индексом родитель находится в массиве под индексом (округление вниз).
  • Если входной массив размера и если округлив его до степени двойки мы получаем , то первый уровень дерева обладает размером , второй и т.д. вплоть до последнего уровня - самого массива дополненного до степени двойки, т.е. обладающего размером . Итого массив под дерево нужно аллоцировать размера .

Как построить дерево

Достаточно дополнить массив нейтральным элементом до размера-степени двойки. Пусть получился размер .

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

Затем нужно посчитать результат операции для каждого узла, это можно сделать от листьев к верхушке, ведь .

Как ответить на запрос обходя дерево сверху вниз

Пусть мы хотим реализовать рекурсивную функцию которой на вход дано уже построенное дерево, индекс обрабатываемого в данный момент узла и отрезок интереса (первая граница включительна, вторая - исключительна):

int calcNodeL(int node) {
    // функция возвращающая левую границу отрезка в изначальном массиве под данным узлом (включительно)
}

int calcNodeR(int node) {
    // функция возвращающая правую границу отрезка в изначальном массиве под данным узлом (исключительно)
}

int rangeMin(int[] tree_min, int node, int from, int to) {
    int l = calcNodeL(node);
    int r = calcNodeR(node);
    if (/* отрезок [l; r) не пересекается с [from; to)*/) {
        return +inf; // нейтральный элемент, в случае min - это большое число, в случае sum - это ноль
    } else if (/* отрезок [l; r) содержится в [from; to)*/) {
        return tree_min[nodes];
    } else {
        int childL = 2 * node + 1;
        int childR = 2 * node + 2;
        // Спускаемся в обоих детей, ищем минимум в каждом из них, и из этих двух минимумов возвращаем самый маленький
        return min(rangeMin(tree_min, childL, from, to), rangeMin(tree_min, childR, from, to));
    }
}

Определять диапазон в массиве который покрывает узел можно одним из следующих способов:

1) Хранить в каждом узле не только значение результата на подотрезке (наприм сумма или минимум), но и собственно int l, int r. Для этого нужно либо завести еще два массива int[] tree_l и int[] tree_r, либо в каждом узле дерева хранить объект своего класса class TreeNode { int result; int l; int r; }

2) Явным образом передавать int l, int r как аргументы функции наравне с int node, int from, int to. И при рекурсивном вызове rangeMin у детей передавать туда соответствующий диапазон, например для левого ребенка, и - для правого.

Как ответить на запрос обходя дерево снизу вверх

Пусть мы не хотим связываться с calcNodeL, calcNodeR и рекурсией.

В таком случае давайте заметим что если изначальный запрос , то эти элементы в дереве лежат по индексам , давайте заменим наш отрезок запроса на этот новый, т.е. сделаем замену и .

Тогда если и , то задачу можно свести к запросу на предыдущем уровне для индексов .

Но что делать если так сделать нельзя? Достаточно взять те одиночные элементы по краям которые нам не позволяют это сделать, добавить к текущему результату, и вновь сделать возможным переход в родителя.

Зачем же рекурсивный обход сверху вниз, раз он сложнее?

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

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

Подробнее можно прочитать здесь.

Доп. задачки

1) Найти число различных чисел на подотрезке.

2) Найти число убывающих подпоследовательностей длины три. Изменится ли задача если бы требовалось находить число подпоследовательностей как обычно на многих подотрезках, а не просто среди всего массива?